@eighty4/dank 0.0.4-1 → 0.0.4-3

package/lib_js/bin.js

@@ -1,106 +1,100 @@
 #!/usr/bin/env node
 import { buildWebsite } from "./build.js";
-import { loadConfig } from "./config.js";
+import { DankError } from "./errors.js";
 import { serveWebsite } from "./serve.js";
-function printHelp(task) {
-    if (!task || task === 'build') {
-        console.log('dank build [--minify] [--production]');
-    }
-    if (!task || task === 'serve') {
-        console.log(
-        // 'dank serve [--minify] [--preview] [--production]',
-        'dank serve [--minify] [--production]');
-    }
-    console.log('\nOPTIONS:');
-    if (!task || task === 'serve')
-        console.log('  --log-http     print access logs');
-    console.log('  --minify       minify sources');
-    // if (!task || task === 'serve') console.log('  --preview      pre-bundle and build ServiceWorker')
-    console.log('  --production   build for production release');
-    if (task) {
-        console.log();
-        console.log('use `dank -h` for details on all commands');
-    }
-    process.exit(1);
+function printHelp(task2) {
+  if (!task2 || task2 === "build") {
+    console.log("dank build [--minify] [--production]");
+  }
+  if (!task2 || task2 === "serve") {
+    console.log(
+      // 'dank serve [--minify] [--preview] [--production]',
+      "dank serve [--minify] [--production]"
+    );
+  }
+  console.log("\nOPTIONS:");
+  if (!task2 || task2 === "serve")
+    console.log("  --log-http     print access logs");
+  console.log("  --minify       minify sources");
+  console.log("  --production   build for production release");
+  if (task2) {
+    console.log();
+    console.log("use `dank -h` for details on all commands");
+  }
+  process.exit(1);
 }
 const args = (function collectProgramArgs() {
-    const programNames = ['dank', 'bin.js', 'bin.ts'];
-    let args = [...process.argv];
-    while (true) {
-        const shifted = args.shift();
-        if (!shifted || programNames.some(name => shifted.endsWith(name))) {
-            return args;
-        }
+  const programNames = ["dank", "bin.js", "bin.ts"];
+  let args2 = [...process.argv];
+  while (true) {
+    const shifted = args2.shift();
+    if (!shifted || programNames.some((name) => shifted.endsWith(name))) {
+      return args2;
     }
+  }
 })();
 const task = (function resolveTask() {
-    const showHelp = args.some(arg => arg === '-h' || arg === '--help');
-    const task = (() => {
-        while (true) {
-            const shifted = args.shift();
-            switch (shifted) {
-                case '-h':
-                case '--help':
-                    break;
-                case 'build':
-                    return 'build';
-                case 'dev':
-                case 'serve':
-                    return 'serve';
-                default:
-                    if (showHelp) {
-                        printHelp();
-                    }
-                    else if (typeof shifted === 'undefined') {
-                        printError('missing command');
-                        printHelp();
-                    }
-                    else {
-                        printError(shifted + " isn't a command");
-                        printHelp();
-                    }
-            }
-        }
-    })();
-    if (showHelp) {
-        printHelp(task);
+  const showHelp = args.some((arg) => arg === "-h" || arg === "--help");
+  const task2 = (() => {
+    while (true) {
+      const shifted = args.shift();
+      switch (shifted) {
+        case "-h":
+        case "--help":
+          break;
+        case "build":
+          return "build";
+        case "dev":
+        case "serve":
+          return "serve";
+        default:
+          if (showHelp) {
+            printHelp();
+          } else if (typeof shifted === "undefined") {
+            printError("missing command");
+            printHelp();
+          } else {
+            printError(shifted + " isn't a command");
+            printHelp();
+          }
+      }
     }
-    return task;
+  })();
+  if (showHelp) {
+    printHelp(task2);
+  }
+  return task2;
 })();
-const c = await loadConfig();
 try {
-    switch (task) {
-        case 'build':
-            await buildWebsite(c);
-            console.log(green('done'));
-            process.exit(0);
-        case 'serve':
-            await serveWebsite(c);
-    }
-}
-catch (e) {
-    errorExit(e);
+  switch (task) {
+    case "build":
+      await buildWebsite();
+      console.log(green("done"));
+      process.exit(0);
+    case "serve":
+      await serveWebsite();
+  }
+} catch (e) {
+  errorExit(e);
 }
 function printError(e) {
-    if (e !== null) {
-        if (typeof e === 'string') {
-            console.error(red('error:'), e);
-        }
-        else if (e instanceof Error) {
-            console.error(red('error:'), e.message);
-            if (e.stack) {
-                console.error(e.stack);
-            }
-        }
+  if (e !== null) {
+    if (e instanceof DankError) {
+      console.error(red("error:"), e.message);
+    } else if (e instanceof Error) {
+      console.error(red("error:"), e.stack ?? e.message);
+    } else {
+      console.error(red("error:"), e);
     }
+  }
 }
 function green(s) {
-    return `\u001b[32m${s}\u001b[0m`;
+  return `\x1B[32m${s}\x1B[0m`;
 }
 function red(s) {
-    return `\u001b[31m${s}\u001b[0m`;
+  return `\x1B[31m${s}\x1B[0m`;
 }
 function errorExit(e) {
-    printError(e);
-    process.exit(1);
+  printError(e);
+  process.exit(1);
 }

package/lib_js/build.js

@@ -1,95 +1,72 @@
-import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
+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";
-export async function buildWebsite(c, 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 });
-    for (const subdir of Object.keys(c.pages).filter(url => url !== '/')) {
-        await mkdir(join(build.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));
-    return await registry.writeManifest(buildTag);
+import { WebsiteRegistry } from "./registry.js";
+async function buildWebsite(c) {
+  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(c.dirs.buildDist, subdir), { recursive: true });
+  }
+  await mkdir(join(c.dirs.buildRoot, "metafiles"), { recursive: true });
+  const registry = await buildWebpages(c, createGlobalDefinitions(c));
+  return await registry.writeManifest(buildTag);
 }
-// builds all webpage entrypoints in one esbuild.build context
-// to support code splitting
-// returns all built assets URLs and webpage URLs from DankConfig.pages
-async function buildWebpages(c, registry, build, define) {
-    // create HtmlEntrypoint for each webpage and collect awaitable esbuild entrypoints
-    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);
-    }
-    // collect esbuild entrypoints from every HtmlEntrypoint
-    const uniqueEntryPoints = 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);
-    // todo recursively build workers on building workers that create workers
-    const workerEntryPoints = registry.workerEntryPoints();
-    if (workerEntryPoints?.length) {
-        await esbuildWorkers(build, registry, define, workerEntryPoints, c.esbuild);
-    }
-    await rewriteWorkerUrls(build, registry);
-    // write out html output with rewritten hrefs
-    await Promise.all(htmlEntrypoints.map(async (html) => {
-        await writeFile(join(build.dirs.buildDist, html.url, 'index.html'), html.output(registry));
-    }));
+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(registry, define, workerEntryPoints);
+  }
+  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;
 }
-export async function rewriteWorkerUrls(build, registry) {
-    const workers = registry.workers();
-    if (!workers) {
-        return;
-    }
-    const dependentBundlePaths = workers.map(w => registry.mappedHref(w.dependentEntryPoint));
-    const bundleOutputs = {};
-    // collect all js file contents concurrently
-    const readingFiles = Promise.all(dependentBundlePaths.map(async (p) => {
-        bundleOutputs[p] = await readFile(join(build.dirs.projectRootAbs, build.dirs.buildDist, p), 'utf8');
-    }));
-    // build regex replacements during file reads
-    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)}')`));
+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(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.workerCtor, w.workerUrlPlaceholder), `new ${w.workerCtor}('${registry.mappedHref(w.workerEntryPoint)}')`));
+  }
+  await readingFiles;
+  await Promise.all(Object.entries(bundleOutputs).map(async ([p, content]) => {
+    let result = content;
+    for (const rewriteFn of rewriteChains[p]) {
+      result = rewriteFn(result);
     }
-    // wait for file reads
-    await readingFiles;
-    // run rewrite regex chain and write back to dist
-    await Promise.all(Object.entries(bundleOutputs).map(async ([p, content]) => {
-        let result = content;
-        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);
+  }));
 }
-export 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,
+  createWorkerRegex,
+  rewriteWorkerUrls
+};

package/lib_js/build_tag.js

@@ -1,22 +1,21 @@
-import { exec } from 'node:child_process';
-export async function createBuildTag(build) {
-    const now = new Date();
-    const ms = now.getUTCMilliseconds() +
-        now.getUTCSeconds() * 1000 +
-        now.getUTCMinutes() * 1000 * 60 +
-        now.getUTCHours() * 1000 * 60 * 60;
-    const date = now.toISOString().substring(0, 10);
-    const time = String(ms).padStart(8, '0');
-    const when = `${date}-${time}`;
-    if (build.production) {
-        const gitHash = await new Promise((res, rej) => exec('git rev-parse --short HEAD', (err, stdout) => {
-            if (err)
-                rej(err);
-            res(stdout.trim());
-        }));
-        return `${when}-${gitHash}`;
-    }
-    else {
-        return when;
-    }
+import { exec } from "node:child_process";
+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 (flags.production) {
+    const gitHash = await new Promise((res, rej) => exec("git rev-parse --short HEAD", (err, stdout) => {
+      if (err)
+        rej(err);
+      res(stdout.trim());
+    }));
+    return `${when}-${gitHash}`;
+  } else {
+    return when;
+  }
 }
+export {
+  createBuildTag
+};

package/lib_js/config.js

@@ -1,23 +1,242 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
+import { isAbsolute, resolve } from "node:path";
+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) {
+      return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
+    });
+  }
+  return path;
 };
-import { isAbsolute, resolve } from 'node:path';
-const CFG_P = './dank.config.ts';
-export async function loadConfig(path = CFG_P) {
-    const modulePath = `${resolveConfigPath(path)}?${Date.now()}`;
-    const module = await import(__rewriteRelativeImportExtension(modulePath));
-    return await module.default;
+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;
+}
+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);
+  }
+}
+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(details) : module.default;
+  validateDankConfig(c);
+  return c;
+}
+function resolveDankDetails(mode, flags) {
+  return {
+    dev: !flags.production,
+    production: flags.production,
+    mode
+  };
+}
+function validateDankConfig(c) {
+  try {
+    validatePorts(c);
+    validatePages(c.pages);
+    validateDevPages(c.devPages);
+    validateDevServices(c.services);
+    validateEsbuildConfig(c.esbuild);
+  } catch (e) {
+    throw e;
+  }
+}
+function validatePorts(c) {
+  if (c.port !== null && typeof c.port !== "undefined") {
+    if (typeof c.port !== "number") {
+      throw Error("DankConfig.port must be a number");
+    }
+  }
+  if (c.previewPort !== null && typeof c.previewPort !== "undefined") {
+    if (typeof c.previewPort !== "number") {
+      throw Error("DankConfig.previewPort must be a number");
+    }
+  }
+}
+function validateEsbuildConfig(esbuild) {
+  if (esbuild?.loaders !== null && typeof esbuild?.loaders !== "undefined") {
+    if (typeof esbuild.loaders !== "object") {
+      throw Error("DankConfig.esbuild.loaders must be a map of extensions to esbuild loaders");
+    } else {
+      for (const [ext, loader] of Object.entries(esbuild.loaders)) {
+        if (typeof loader !== "string") {
+          throw Error(`DankConfig.esbuild.loaders['${ext}'] must be a string of a loader name`);
+        }
+      }
+    }
+  }
+  if (esbuild?.plugins !== null && typeof esbuild?.plugins !== "undefined") {
+    if (!Array.isArray(esbuild.plugins)) {
+      throw Error("DankConfig.esbuild.plugins must be an array of esbuild plugins");
+    }
+  }
+  if (esbuild?.port !== null && typeof esbuild?.port !== "undefined") {
+    if (typeof esbuild.port !== "number") {
+      throw Error("DankConfig.esbuild.port must be a number");
+    }
+  }
+}
+function validatePages(pages) {
+  if (pages === null || typeof pages === "undefined" || Object.keys(pages).length === 0) {
+    throw Error("DankConfig.pages is required");
+  }
+  for (const [urlPath, mapping] of Object.entries(pages)) {
+    if (typeof mapping === "string" && mapping.endsWith(".html")) {
+      continue;
+    }
+    if (typeof mapping === "object") {
+      validatePageMapping(urlPath, mapping);
+      continue;
+    }
+    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`);
+  }
+  if (mapping.pattern === null || typeof mapping.pattern === "undefined") {
+    return;
+  }
+  if (typeof mapping.pattern === "object" && mapping.pattern.constructor.name === "RegExp") {
+    return;
+  }
+  throw Error(`DankConfig.pages['${urlPath}'].pattern must be a RegExp`);
 }
-export function resolveConfigPath(path) {
-    if (isAbsolute(path)) {
-        return path;
+function validateDevServices(services) {
+  if (services === null || typeof services === "undefined") {
+    return;
+  }
+  if (!Array.isArray(services)) {
+    throw Error(`DankConfig.services must be an array`);
+  }
+  for (let i = 0; i < services.length; i++) {
+    const s = services[i];
+    if (s.command === null || typeof s.command === "undefined") {
+      throw Error(`DankConfig.services[${i}].command is required`);
+    } else if (typeof s.command !== "string" || s.command.length === 0) {
+      throw Error(`DankConfig.services[${i}].command must be a non-empty string`);
+    }
+    if (s.cwd !== null && typeof s.cwd !== "undefined") {
+      if (typeof s.cwd !== "string" || s.cwd.trim().length === 0) {
+        throw Error(`DankConfig.services[${i}].cwd must be a non-empty string`);
+      }
     }
-    else {
-        return resolve(process.cwd(), path);
+    if (s.env !== null && typeof s.env !== "undefined") {
+      if (typeof s.env !== "object") {
+        throw Error(`DankConfig.services[${i}].env must be an env variable map`);
+      }
+      for (const [k, v] of Object.entries(s.env)) {
+        if (typeof v !== "string") {
+          throw Error(`DankConfig.services[${i}].env[${k}] must be a string`);
+        }
+      }
     }
+    if (s.http !== null && typeof s.http !== "undefined") {
+      if (typeof s.http.port !== "number") {
+        throw Error(`DankConfig.services[${i}].http.port must be a number`);
+      }
+    }
+  }
+}
+function normalizePages(pages) {
+  const result = {};
+  for (const [pageUrl, mapping] of Object.entries(pages)) {
+    const mappedMapping = typeof mapping === "string" ? { webpage: mapping } : mapping;
+    mappedMapping.webpage = mappedMapping.webpage.replace(/^\.\//, "");
+    result[pageUrl] = mappedMapping;
+  }
+  return result;
 }
+export {
+  loadConfig
+};