@eighty4/dank 0.0.4-1 → 0.0.4-3

package/lib_js/dank.js

@@ -1,123 +1,6 @@
-export async function defineConfig(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');
-        }
-    }
-    validatePages(c.pages);
-    validateDevServices(c.services);
-    validateEsbuildConfig(c.esbuild);
-    normalizePagePaths(c.pages);
-    return c;
-}
-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 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`);
-}
-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`);
-            }
-        }
-        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 normalizePagePaths(pages) {
-    for (const [pageUrl, mapping] of Object.entries(pages)) {
-        if (typeof mapping === 'string') {
-            pages[pageUrl] = normalizePagePath(mapping);
-        }
-        else {
-            mapping.webpage = normalizePagePath(mapping.webpage);
-        }
-    }
-}
-function normalizePagePath(p) {
-    return p.replace(/^\.\//, '');
+function defineConfig(config) {
+  return config;
 }
+export {
+  defineConfig
+};

package/lib_js/define.js

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

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,186 +1,174 @@
-import { readFile } from 'node:fs/promises';
-import esbuild, {} from 'esbuild';
-export async function esbuildDevContext(b, r, define, entryPoints, c) {
-    return await esbuild.context({
-        define,
-        entryNames: '[dir]/[name]',
-        entryPoints: mapEntryPointPaths(entryPoints),
-        outdir: b.dirs.buildWatch,
-        ...commonBuildOptions(b, r, c),
-        splitting: false,
-        write: false,
-    });
+import { readFile } from "node:fs/promises";
+import esbuild, {} from "esbuild";
+async function esbuildDevContext(r, define, entryPoints) {
+  return await esbuild.context({
+    define,
+    entryNames: "[dir]/[name]",
+    entryPoints: mapEntryPointPaths(entryPoints),
+    outdir: r.config.dirs.buildWatch,
+    ...commonBuildOptions(r),
+    splitting: false,
+    write: false
+  });
 }
-export async function esbuildWebpages(b, r, define, entryPoints, c) {
-    try {
-        await esbuild.build({
-            define,
-            entryNames: '[dir]/[name]-[hash]',
-            entryPoints: mapEntryPointPaths(entryPoints),
-            outdir: b.dirs.buildDist,
-            ...commonBuildOptions(b, r, c),
-        });
-    }
-    catch (ignore) {
-        process.exit(1);
-    }
+async function esbuildWebpages(r, define, entryPoints) {
+  try {
+    await esbuild.build({
+      define,
+      entryNames: "[dir]/[name]-[hash]",
+      entryPoints: mapEntryPointPaths(entryPoints),
+      outdir: r.config.dirs.buildDist,
+      ...commonBuildOptions(r)
+    });
+  } catch (ignore) {
+    process.exit(1);
+  }
 }
-export async function esbuildWorkers(b, r, define, entryPoints, c) {
-    try {
-        await esbuild.build({
-            define,
-            entryNames: '[dir]/[name]-[hash]',
-            entryPoints: mapEntryPointPaths(entryPoints),
-            outdir: b.dirs.buildDist,
-            ...commonBuildOptions(b, r, c),
-            splitting: false,
-            metafile: true,
-            write: true,
-            assetNames: 'assets/[name]-[hash]',
-        });
-    }
-    catch (ignore) {
-        process.exit(1);
-    }
+async function esbuildWorkers(r, define, entryPoints) {
+  try {
+    await esbuild.build({
+      define,
+      entryNames: "[dir]/[name]-[hash]",
+      entryPoints: mapEntryPointPaths(entryPoints),
+      outdir: r.config.dirs.buildDist,
+      ...commonBuildOptions(r),
+      splitting: false,
+      metafile: true,
+      write: true,
+      assetNames: "assets/[name]-[hash]"
+    });
+  } catch (ignore) {
+    process.exit(1);
+  }
 }
-function commonBuildOptions(b, r, c) {
-    const p = workersPlugin(r.buildRegistry());
-    return {
-        absWorkingDir: b.dirs.projectRootAbs,
-        assetNames: 'assets/[name]-[hash]',
-        bundle: true,
-        format: 'esm',
-        loader: c?.loaders || defaultLoaders(),
-        metafile: true,
-        minify: b.minify,
-        platform: 'browser',
-        plugins: c?.plugins?.length ? [p, ...c.plugins] : [p],
-        splitting: true,
-        treeShaking: true,
-        write: true,
-    };
+function commonBuildOptions(r) {
+  const p = workersPlugin(r.buildRegistry());
+  return {
+    assetNames: "assets/[name]-[hash]",
+    bundle: true,
+    format: "esm",
+    loader: r.config.esbuild?.loaders || defaultLoaders(),
+    metafile: true,
+    minify: r.config.flags.minify,
+    platform: "browser",
+    plugins: r.config.esbuild?.plugins?.length ? [p, ...r.config.esbuild?.plugins] : [p],
+    splitting: true,
+    treeShaking: true,
+    write: true
+  };
 }
 function defaultLoaders() {
-    return {
-        '.woff': 'file',
-        '.woff2': 'file',
-    };
+  return {
+    ".woff": "file",
+    ".woff2": "file"
+  };
 }
-// esbuild will append the .js or .css to output filenames
-// keeping extension on entryPoints data for consistency
-// and only trimming when creating esbuild opts
 function mapEntryPointPaths(entryPoints) {
-    return entryPoints.map(entryPoint => {
-        return {
-            in: entryPoint.in,
-            out: entryPoint.out.replace(/\.(tsx?|jsx?|css)$/, ''),
-        };
-    });
+  return entryPoints.map((entryPoint) => {
+    return {
+      in: entryPoint.in,
+      out: entryPoint.out.replace(/\.(tsx?|jsx?|css)$/, "")
+    };
+  });
 }
 const WORKER_CTOR_REGEX = /new(?:\s|\r?\n)+(?<ctor>(?:Shared)?Worker)(?:\s|\r?\n)*\((?:\s|\r?\n)*(?<url>.*?)(?:\s|\r?\n)*(?<end>[\),])/g;
 const WORKER_URL_REGEX = /^('.*'|".*")$/;
-export 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;
-                let errors = undefined;
-                for (const workerCtorMatch of contents.matchAll(WORKER_CTOR_REGEX)) {
-                    if (!WORKER_URL_REGEX.test(workerCtorMatch.groups.url)) {
-                        if (!errors)
-                            errors = [];
-                        errors.push(invalidWorkerUrlCtorArg(locationFromMatch(args, contents, workerCtorMatch), workerCtorMatch));
-                        continue;
-                    }
-                    if (isIndexCommented(contents, workerCtorMatch.index)) {
-                        continue;
-                    }
-                    const clientScript = args.path
-                        .replace(absWorkingDir, '')
-                        .substring(1);
-                    const workerUrl = workerCtorMatch.groups.url.substring(1, workerCtorMatch.groups.url.length - 1);
-                    const workerEntryPoint = r.resolver.resolveHrefInPagesDir(clientScript, workerUrl);
-                    if (workerEntryPoint === 'outofbounds') {
-                        if (!errors)
-                            errors = [];
-                        errors.push(outofboundsWorkerUrlCtorArg(locationFromMatch(args, contents, workerCtorMatch), workerCtorMatch));
-                        continue;
-                    }
-                    const workerUrlPlaceholder = workerEntryPoint
-                        .replace(/^pages/, '')
-                        .replace(/\.(t|m?j)s$/, '.js');
-                    const workerCtorReplacement = `new ${workerCtorMatch.groups.ctor}('${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,
-                        workerUrl,
-                        workerUrlPlaceholder,
-                    });
-                }
-                const loader = args.path.endsWith('ts') ? 'ts' : 'js';
-                return { contents, errors, loader };
-            });
-            build.onEnd((result) => {
-                if (result.metafile) {
-                    r.completeBuild(result);
-                }
-            });
-        },
-    };
+function workersPlugin(r) {
+  return {
+    name: "@eighty4/dank/esbuild/workers",
+    setup(build) {
+      if (!build.initialOptions.metafile)
+        throw TypeError("plugin requires metafile");
+      build.onLoad({ filter: /\.(t|m?j)s$/ }, async (args) => {
+        let contents = await readFile(args.path, "utf8");
+        let offset = 0;
+        let errors = void 0;
+        for (const workerCtorMatch of contents.matchAll(WORKER_CTOR_REGEX)) {
+          if (!WORKER_URL_REGEX.test(workerCtorMatch.groups.url)) {
+            if (!errors)
+              errors = [];
+            errors.push(invalidWorkerUrlCtorArg(locationFromMatch(args, contents, workerCtorMatch), workerCtorMatch));
+            continue;
+          }
+          if (isIndexCommented(contents, workerCtorMatch.index)) {
+            continue;
+          }
+          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") {
+            if (!errors)
+              errors = [];
+            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 ${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
+          });
+        }
+        const loader = args.path.endsWith("ts") ? "ts" : "js";
+        return { contents, errors, loader };
+      });
+      build.onEnd((result) => {
+        if (result.metafile) {
+          r.completeBuild(result);
+        }
+      });
+    }
+  };
 }
 function isIndexCommented(contents, index) {
-    const preamble = contents.substring(0, index);
-    const lineIndex = preamble.lastIndexOf('\n') || 0;
-    const lineCommented = /\/\//.test(preamble.substring(lineIndex));
-    if (lineCommented) {
-        return true;
-    }
-    const blockCommentIndex = preamble.lastIndexOf('/*');
-    const blockCommented = blockCommentIndex !== -1 &&
-        preamble.substring(blockCommentIndex).indexOf('*/') === -1;
-    return blockCommented;
+  const preamble = contents.substring(0, index);
+  const lineIndex = preamble.lastIndexOf("\n") || 0;
+  const lineCommented = /\/\//.test(preamble.substring(lineIndex));
+  if (lineCommented) {
+    return true;
+  }
+  const blockCommentIndex = preamble.lastIndexOf("/*");
+  const blockCommented = blockCommentIndex !== -1 && preamble.substring(blockCommentIndex).indexOf("*/") === -1;
+  return blockCommented;
 }
 function locationFromMatch(args, contents, match) {
-    const preamble = contents.substring(0, match.index);
-    const line = preamble.match(/\n/g)?.length || 0;
-    let lineIndex = preamble.lastIndexOf('\n');
-    lineIndex = lineIndex === -1 ? 0 : lineIndex + 1;
-    const column = preamble.length - lineIndex;
-    const lineText = contents.substring(lineIndex, contents.indexOf('\n', lineIndex) || contents.length);
-    return {
-        lineText,
-        line,
-        column,
-        file: args.path,
-        length: match[0].length,
-    };
+  const preamble = contents.substring(0, match.index);
+  const line = preamble.match(/\n/g)?.length || 0;
+  let lineIndex = preamble.lastIndexOf("\n");
+  lineIndex = lineIndex === -1 ? 0 : lineIndex + 1;
+  const column = preamble.length - lineIndex;
+  const lineText = contents.substring(lineIndex, contents.indexOf("\n", lineIndex) || contents.length);
+  return {
+    lineText,
+    line,
+    column,
+    file: args.path,
+    length: match[0].length
+  };
 }
 function outofboundsWorkerUrlCtorArg(location, workerCtorMatch) {
-    return {
-        id: 'worker-url-outofbounds',
-        text: `The ${workerCtorMatch.groups.ctor} constructor URL arg \`${workerCtorMatch.groups.url}\` cannot resolve to a path outside of the pages directory`,
-        location,
-    };
+  return {
+    id: "worker-url-outofbounds",
+    text: `The ${workerCtorMatch.groups.ctor} constructor URL arg \`${workerCtorMatch.groups.url}\` cannot resolve to a path outside of the pages directory`,
+    location
+  };
 }
 function invalidWorkerUrlCtorArg(location, workerCtorMatch) {
-    return {
-        id: 'worker-url-unresolvable',
-        text: `The ${workerCtorMatch.groups.ctor} constructor URL arg \`${workerCtorMatch.groups.url}\` must be a relative module path`,
-        location,
-    };
+  return {
+    id: "worker-url-unresolvable",
+    text: `The ${workerCtorMatch.groups.ctor} constructor URL arg \`${workerCtorMatch.groups.url}\` must be a relative module path`,
+    location
+  };
 }
+export {
+  esbuildDevContext,
+  esbuildWebpages,
+  esbuildWorkers,
+  workersPlugin
+};