@ecopages/core 0.2.0-beta.31 → 0.2.0-beta.32

package/src/utils/path-utils.module.js

@@ -1,14 +1,11 @@
-import path from "node:path";
+import path from 'node:path';
 function getEcoTemplateExtension(filePath) {
-  const { name, ext } = path.parse(filePath);
-  const nameParts = name.split(".");
-  const descriptor = nameParts.length > 1 ? nameParts.pop() : void 0;
-  const templateExtension = descriptor ? `.${descriptor}${ext}` : ext;
-  return templateExtension;
+    const { name, ext } = path.parse(filePath);
+    const nameParts = name.split('.');
+    const descriptor = nameParts.length > 1 ? nameParts.pop() : undefined;
+    const templateExtension = descriptor ? `.${descriptor}${ext}` : ext;
+    return templateExtension;
 }
-const PathUtils = {
-  getEcoTemplateExtension
-};
-export {
-  PathUtils
+export const PathUtils = {
+    getEcoTemplateExtension,
 };

package/src/utils/resolve-entry-file.js

@@ -1,41 +1,73 @@
-import { parseArgs } from "node:util";
-import { getRuntimeArgv } from "./runtime.js";
-const DEFAULT_ENTRY_FILE = "app.ts";
-const ENTRY_FILE_ENV = "ECOPAGES_ENTRY_FILE";
-const entryFileOptions = {
-  "entry-file": { type: "string", short: "e" }
+import { parseArgs } from 'node:util';
+import { getRuntimeArgv } from './runtime.js';
+/**
+ * The default entry file name when no other source provides a value.
+ */
+export const DEFAULT_ENTRY_FILE = 'app.ts';
+/**
+ * The environment variable used to override the entry file path.
+ */
+export const ENTRY_FILE_ENV = 'ECOPAGES_ENTRY_FILE';
+/**
+ * Centralized definition of the entry-file CLI argument.
+ *
+ * Exported so callers (CLI, tests, docs) reference a single source of truth
+ * for the flag name, short alias, and type. Keep this in sync with
+ * `resolveEntryFile` below.
+ */
+export const entryFileOptions = {
+    'entry-file': { type: 'string', short: 'e' },
 };
-const ENTRY_FILE_FLAG = "entry-file";
-function resolveEntryFile({
-  entryFile,
-  env = process.env,
-  argv = getRuntimeArgv()
-} = {}) {
-  if (entryFile && entryFile.length > 0) return entryFile;
-  const fromEnv = env[ENTRY_FILE_ENV];
-  if (fromEnv && fromEnv.length > 0) return fromEnv;
-  const fromFlag = readEntryFileFlag(argv);
-  if (fromFlag) return fromFlag;
-  return DEFAULT_ENTRY_FILE;
+/**
+ * The long flag name for the entry file option. Re-exported as a
+ * constant so consumers don't hardcode the string.
+ */
+export const ENTRY_FILE_FLAG = 'entry-file';
+/**
+ * Resolves the entry file path using standard precedence.
+ *
+ * This is the single source of truth for entry-file resolution across
+ * the CLI, build pipeline, and runtime. Both the CLI layer and the
+ * runtime builders call into this function instead of reimplementing
+ * the precedence chain.
+ *
+ * @example
+ *   resolveEntryFile();                                     // 'app.ts' (or env/argv)
+ *   resolveEntryFile({ entryFile: 'src/server.ts' });       // 'src/server.ts'
+ *   resolveEntryFile({ env: { ECOPAGES_ENTRY_FILE: 'x' }}); // 'x'
+ *   resolveEntryFile({ argv: ['node', '-e', 'flag.ts'] });  // 'flag.ts'
+ */
+export function resolveEntryFile({ entryFile, env = process.env, argv = getRuntimeArgv(), } = {}) {
+    if (entryFile && entryFile.length > 0)
+        return entryFile;
+    const fromEnv = env[ENTRY_FILE_ENV];
+    if (fromEnv && fromEnv.length > 0)
+        return fromEnv;
+    const fromFlag = readEntryFileFlag(argv);
+    if (fromFlag)
+        return fromFlag;
+    return DEFAULT_ENTRY_FILE;
 }
-function readEntryFileFlag(argv = getRuntimeArgv()) {
-  const { values } = parseArgs({
-    args: argv.slice(1),
-    options: { ...entryFileOptions },
-    strict: false
-  });
-  const raw = values[ENTRY_FILE_FLAG];
-  return typeof raw === "string" && raw.length > 0 ? raw : void 0;
+/**
+ * Parses argv for the entry-file flag using the shared `parseArgs` config.
+ *
+ * Exposed for callers that need the raw flag value without the full
+ * precedence chain (e.g. CLI help text, validation).
+ */
+export function readEntryFileFlag(argv = getRuntimeArgv()) {
+    const { values } = parseArgs({
+        args: argv.slice(1),
+        options: { ...entryFileOptions },
+        strict: false,
+    });
+    const raw = values[ENTRY_FILE_FLAG];
+    return typeof raw === 'string' && raw.length > 0 ? raw : undefined;
 }
-const SERVER_BUNDLE_DIR = ".server";
-const SERVER_BUNDLE_FILENAME = "app.mjs";
-export {
-  DEFAULT_ENTRY_FILE,
-  ENTRY_FILE_ENV,
-  ENTRY_FILE_FLAG,
-  SERVER_BUNDLE_DIR,
-  SERVER_BUNDLE_FILENAME,
-  entryFileOptions,
-  readEntryFileFlag,
-  resolveEntryFile
-};
+/**
+ * The subdirectory inside `dist/` where the bundled server entry is placed.
+ */
+export const SERVER_BUNDLE_DIR = '.server';
+/**
+ * The filename of the bundled server entry.
+ */
+export const SERVER_BUNDLE_FILENAME = 'app.mjs';

package/src/utils/resolve-work-dir.js

@@ -1,31 +1,27 @@
-import path from "node:path";
-import { DEFAULT_ECOPAGES_WORK_DIR } from "../config/constants.js";
+import path from 'node:path';
+import { DEFAULT_ECOPAGES_WORK_DIR } from '../config/constants.js';
 function isInsideNodeModules(directory) {
-  return path.normalize(directory).split(path.sep).includes("node_modules");
+    return path.normalize(directory).split(path.sep).includes('node_modules');
 }
-function resolveInternalWorkDir(appConfig) {
-  if (appConfig.absolutePaths?.workDir) {
-    return appConfig.absolutePaths.workDir;
-  }
-  if (appConfig.rootDir) {
-    return path.join(appConfig.rootDir, appConfig.workDir ?? DEFAULT_ECOPAGES_WORK_DIR);
-  }
-  if (appConfig.workDir) {
-    return appConfig.workDir;
-  }
-  return DEFAULT_ECOPAGES_WORK_DIR;
+export function resolveInternalWorkDir(appConfig) {
+    if (appConfig.absolutePaths?.workDir) {
+        return appConfig.absolutePaths.workDir;
+    }
+    if (appConfig.rootDir) {
+        return path.join(appConfig.rootDir, appConfig.workDir ?? DEFAULT_ECOPAGES_WORK_DIR);
+    }
+    if (appConfig.workDir) {
+        return appConfig.workDir;
+    }
+    return DEFAULT_ECOPAGES_WORK_DIR;
 }
-function resolveInternalExecutionDir(appConfig) {
-  const workDir = resolveInternalWorkDir(appConfig);
-  if (!isInsideNodeModules(workDir)) {
-    return workDir;
-  }
-  if (appConfig.rootDir) {
-    return path.join(appConfig.rootDir, DEFAULT_ECOPAGES_WORK_DIR);
-  }
-  return DEFAULT_ECOPAGES_WORK_DIR;
+export function resolveInternalExecutionDir(appConfig) {
+    const workDir = resolveInternalWorkDir(appConfig);
+    if (!isInsideNodeModules(workDir)) {
+        return workDir;
+    }
+    if (appConfig.rootDir) {
+        return path.join(appConfig.rootDir, DEFAULT_ECOPAGES_WORK_DIR);
+    }
+    return DEFAULT_ECOPAGES_WORK_DIR;
 }
-export {
-  resolveInternalExecutionDir,
-  resolveInternalWorkDir
-};

package/src/utils/runtime.js

@@ -1,40 +1,31 @@
-import { createHash } from "node:crypto";
-const RUNTIME_ERRORS = {
-  BUN_RUNTIME_REQUIRED: "Bun runtime is required"
+import { createHash } from 'node:crypto';
+export const RUNTIME_ERRORS = {
+    BUN_RUNTIME_REQUIRED: 'Bun runtime is required',
 };
-function getBunRuntime() {
-  return globalThis.Bun;
+export function getBunRuntime() {
+    return globalThis.Bun;
 }
-function getRequiredBunRuntime() {
-  const bun = getBunRuntime();
-  if (!bun) {
-    throw new Error(RUNTIME_ERRORS.BUN_RUNTIME_REQUIRED);
-  }
-  return bun;
+export function getRequiredBunRuntime() {
+    const bun = getBunRuntime();
+    if (!bun) {
+        throw new Error(RUNTIME_ERRORS.BUN_RUNTIME_REQUIRED);
+    }
+    return bun;
 }
-function getRuntimeArgv() {
-  return process.argv;
+export function getRuntimeArgv() {
+    return process.argv;
 }
-function isDevelopmentRuntime() {
-  return process.env.NODE_ENV === "development";
+export function isDevelopmentRuntime() {
+    return process.env.NODE_ENV === 'development';
 }
-function isProductionRuntime() {
-  return process.env.NODE_ENV === "production";
+export function isProductionRuntime() {
+    return process.env.NODE_ENV === 'production';
 }
-function runtimeHash(content) {
-  const bun = getBunRuntime();
-  if (bun) {
-    return bun.hash(content);
-  }
-  const hex = createHash("sha256").update(content).digest("hex").slice(0, 16);
-  return BigInt(`0x${hex}`);
+export function runtimeHash(content) {
+    const bun = getBunRuntime();
+    if (bun) {
+        return bun.hash(content);
+    }
+    const hex = createHash('sha256').update(content).digest('hex').slice(0, 16);
+    return BigInt(`0x${hex}`);
 }
-export {
-  RUNTIME_ERRORS,
-  getBunRuntime,
-  getRequiredBunRuntime,
-  getRuntimeArgv,
-  isDevelopmentRuntime,
-  isProductionRuntime,
-  runtimeHash
-};

package/src/utils/server-utils.module.js

@@ -1,55 +1,63 @@
-import { hasKnownStaticExtension } from "./static-file-extensions.js";
-const ContentTypeMap = /* @__PURE__ */ new Map([
-  ["jpg", "image/jpeg"],
-  ["jpeg", "image/jpeg"],
-  ["png", "image/png"],
-  ["gif", "image/gif"],
-  ["bmp", "image/bmp"],
-  ["svg", "image/svg+xml"],
-  ["tiff", "image/tiff"],
-  ["webp", "image/webp"],
-  ["avif", "image/avif"],
-  ["ico", "image/x-icon"],
-  ["mp3", "audio/mpeg"],
-  ["ogg", "audio/ogg"],
-  ["wav", "audio/wav"],
-  ["mp4", "video/mp4"],
-  ["webm", "video/webm"],
-  ["ogv", "video/ogg"],
-  ["mov", "video/quicktime"],
-  ["txt", "text/plain"],
-  ["md", "text/markdown"],
-  ["html", "text/html"],
-  ["css", "text/css"],
-  ["js", "text/javascript"],
-  ["mjs", "text/javascript"],
-  ["json", "application/json"],
-  ["map", "application/json"],
-  ["xml", "application/xml"],
-  ["webmanifest", "application/manifest+json"],
-  ["wasm", "application/wasm"],
-  ["csv", "text/csv"],
-  ["ttf", "font/ttf"],
-  ["woff", "font/woff"],
-  ["woff2", "font/woff2"],
-  ["otf", "font/otf"],
-  ["eot", "application/vnd.ms-fontobject"],
-  ["gz", "application/x-gzip"],
-  ["zip", "application/zip"],
-  ["pdf", "application/pdf"],
-  ["doc", "application/msword"]
+import { hasKnownStaticExtension } from './static-file-extensions.js';
+const ContentTypeMap = new Map([
+    ['jpg', 'image/jpeg'],
+    ['jpeg', 'image/jpeg'],
+    ['png', 'image/png'],
+    ['gif', 'image/gif'],
+    ['bmp', 'image/bmp'],
+    ['svg', 'image/svg+xml'],
+    ['tiff', 'image/tiff'],
+    ['webp', 'image/webp'],
+    ['avif', 'image/avif'],
+    ['ico', 'image/x-icon'],
+    ['mp3', 'audio/mpeg'],
+    ['ogg', 'audio/ogg'],
+    ['wav', 'audio/wav'],
+    ['mp4', 'video/mp4'],
+    ['webm', 'video/webm'],
+    ['ogv', 'video/ogg'],
+    ['mov', 'video/quicktime'],
+    ['txt', 'text/plain'],
+    ['md', 'text/markdown'],
+    ['html', 'text/html'],
+    ['css', 'text/css'],
+    ['js', 'text/javascript'],
+    ['mjs', 'text/javascript'],
+    ['json', 'application/json'],
+    ['map', 'application/json'],
+    ['xml', 'application/xml'],
+    ['webmanifest', 'application/manifest+json'],
+    ['wasm', 'application/wasm'],
+    ['csv', 'text/csv'],
+    ['ttf', 'font/ttf'],
+    ['woff', 'font/woff'],
+    ['woff2', 'font/woff2'],
+    ['otf', 'font/otf'],
+    ['eot', 'application/vnd.ms-fontobject'],
+    ['gz', 'application/x-gzip'],
+    ['zip', 'application/zip'],
+    ['pdf', 'application/pdf'],
+    ['doc', 'application/msword'],
 ]);
-const getContentType = (file) => {
-  const extension = file.split(".").pop() || "txt";
-  return ContentTypeMap.get(extension) || "text/plain";
+/**
+ * Get the content type of a file based on its extension.
+ * @param file - The file name.
+ * @returns The content type.
+ */
+export const getContentType = (file) => {
+    const extension = file.split('.').pop() || 'txt';
+    return ContentTypeMap.get(extension) || 'text/plain';
 };
-import { hasKnownStaticExtension as hasKnownStaticExtension2 } from "./static-file-extensions.js";
-const ServerUtils = {
-  getContentType,
-  hasKnownStaticExtension
-};
-export {
-  ServerUtils,
-  getContentType,
-  hasKnownStaticExtension2 as hasKnownStaticExtension
+/**
+ * Check if a file path has a known static file extension.
+ * @param file - The file name or path.
+ * @returns true if the extension is recognized.
+ */
+export { hasKnownStaticExtension } from './static-file-extensions.js';
+/**
+ * A module for server utilities.
+ */
+export const ServerUtils = {
+    getContentType,
+    hasKnownStaticExtension,
 };

package/src/utils/static-file-extensions.js

@@ -1,48 +1,54 @@
-const STATIC_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
-  "jpg",
-  "jpeg",
-  "png",
-  "gif",
-  "bmp",
-  "svg",
-  "tiff",
-  "webp",
-  "avif",
-  "ico",
-  "mp3",
-  "ogg",
-  "wav",
-  "mp4",
-  "webm",
-  "ogv",
-  "mov",
-  "txt",
-  "md",
-  "html",
-  "css",
-  "js",
-  "mjs",
-  "json",
-  "map",
-  "xml",
-  "webmanifest",
-  "wasm",
-  "csv",
-  "ttf",
-  "woff",
-  "woff2",
-  "otf",
-  "eot",
-  "gz",
-  "zip",
-  "pdf",
-  "doc"
+/**
+ * Known static asset extensions served directly from disk.
+ *
+ * @remarks
+ * Keep this list aligned with server static-file handling and client routers
+ * that must bypass SPA navigation for same-origin asset links.
+ */
+export const STATIC_FILE_EXTENSIONS = new Set([
+    'jpg',
+    'jpeg',
+    'png',
+    'gif',
+    'bmp',
+    'svg',
+    'tiff',
+    'webp',
+    'avif',
+    'ico',
+    'mp3',
+    'ogg',
+    'wav',
+    'mp4',
+    'webm',
+    'ogv',
+    'mov',
+    'txt',
+    'md',
+    'html',
+    'css',
+    'js',
+    'mjs',
+    'json',
+    'map',
+    'xml',
+    'webmanifest',
+    'wasm',
+    'csv',
+    'ttf',
+    'woff',
+    'woff2',
+    'otf',
+    'eot',
+    'gz',
+    'zip',
+    'pdf',
+    'doc',
 ]);
-function hasKnownStaticExtension(fileOrPath) {
-  const extension = fileOrPath.split(".").pop();
-  return extension !== void 0 && STATIC_FILE_EXTENSIONS.has(extension);
+/**
+ * Returns whether a path or filename ends with a known static asset extension.
+ */
+export function hasKnownStaticExtension(fileOrPath) {
+    const extension = fileOrPath.split('.').pop();
+    return extension !== undefined && STATIC_FILE_EXTENSIONS.has(extension);
 }
-export {
-  STATIC_FILE_EXTENSIONS,
-  hasKnownStaticExtension
-};

package/src/watchers/project-watcher-ignore.js

@@ -1,16 +1,17 @@
-import path from "node:path";
-function createProjectWatcherIgnorePredicate(absolutePaths) {
-  const ignoredPrefixes = [absolutePaths.workDir, absolutePaths.distDir];
-  return (watchedPath) => {
-    const segments = watchedPath.split(path.sep);
-    if (segments.includes("node_modules") || segments.includes(".git")) {
-      return true;
-    }
-    return ignoredPrefixes.some(
-      (prefix) => watchedPath === prefix || watchedPath.startsWith(`${prefix}${path.sep}`)
-    );
-  };
+import path from 'node:path';
+/**
+ * @remarks
+ * chokidar v4+ no longer treats glob strings in `ignored` as patterns. A path
+ * predicate keeps node_modules, VCS metadata, and scoped artifact dirs out of
+ * the watch tree without descending into symlinked monorepo node_modules.
+ */
+export function createProjectWatcherIgnorePredicate(absolutePaths) {
+    const ignoredPrefixes = [absolutePaths.workDir, absolutePaths.distDir];
+    return (watchedPath) => {
+        const segments = watchedPath.split(path.sep);
+        if (segments.includes('node_modules') || segments.includes('.git')) {
+            return true;
+        }
+        return ignoredPrefixes.some((prefix) => watchedPath === prefix || watchedPath.startsWith(`${prefix}${path.sep}`));
+    };
 }
-export {
-  createProjectWatcherIgnorePredicate
-};