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

package/src/plugins/alias-resolver-cache.js

@@ -1,106 +1,123 @@
-import path from "node:path";
-const DEFAULT_MAX_ENTRIES = 2e3;
-class AliasResolverCache {
-  entries = /* @__PURE__ */ new Map();
-  maxEntries;
-  hits = 0;
-  misses = 0;
-  constructor(maxEntries = DEFAULT_MAX_ENTRIES) {
-    if (maxEntries <= 0) {
-      throw new Error(`AliasResolverCache: maxEntries must be > 0, got ${maxEntries}`);
+/**
+ * Per-plugin cache for tsconfig path alias resolution.
+ *
+ * @remarks
+ * The `ecopages-alias-resolver` plugin resolves project path aliases to
+ * concrete file paths using the app's tsconfig `paths`. Each resolution goes
+ * through oxc-resolver and may read barrel re-export targets.
+ *
+ * This cache memoizes the result keyed by `(projectRoot, specifier)`. It is
+ * process-local and not currently invalidated by the file watcher —
+ * project contents are assumed to be stable for the lifetime of the process.
+ */
+import path from 'node:path';
+const DEFAULT_MAX_ENTRIES = 2_000;
+export class AliasResolverCache {
+    entries = new Map();
+    maxEntries;
+    hits = 0;
+    misses = 0;
+    constructor(maxEntries = DEFAULT_MAX_ENTRIES) {
+        if (maxEntries <= 0) {
+            throw new Error(`AliasResolverCache: maxEntries must be > 0, got ${maxEntries}`);
+        }
+        this.maxEntries = maxEntries;
     }
-    this.maxEntries = maxEntries;
-  }
-  /**
-   * Look up a previously-computed resolution for `(srcDir, specifier)`.
-   *
-   * Returns `{ hit: true, resolved }` on cache hit (resolved may be
-   * `undefined` for an unresolvable specifier), or `{ hit: false }` on
-   * miss. The caller is responsible for re-running the resolver and
-   * calling `set` to store the new entry.
-   */
-  get(srcDir, specifier) {
-    const key = makeKey(srcDir, specifier);
-    const existing = this.entries.get(key);
-    if (existing) {
-      this.hits += 1;
-      this.entries.delete(key);
-      this.entries.set(key, existing);
-      return { hit: true, resolved: existing.resolved };
+    /**
+     * Look up a previously-computed resolution for `(srcDir, specifier)`.
+     *
+     * Returns `{ hit: true, resolved }` on cache hit (resolved may be
+     * `undefined` for an unresolvable specifier), or `{ hit: false }` on
+     * miss. The caller is responsible for re-running the resolver and
+     * calling `set` to store the new entry.
+     */
+    get(srcDir, specifier) {
+        const key = makeKey(srcDir, specifier);
+        const existing = this.entries.get(key);
+        if (existing) {
+            this.hits += 1;
+            // Refresh LRU position.
+            this.entries.delete(key);
+            this.entries.set(key, existing);
+            return { hit: true, resolved: existing.resolved };
+        }
+        this.misses += 1;
+        return { hit: false };
     }
-    this.misses += 1;
-    return { hit: false };
-  }
-  /**
-   * Store a resolution result.
-   *
-   * Pass `undefined` for `resolved` to memoize the negative case
-   * (specifier did not resolve) and avoid repeating the FS walk on
-   * every `@/...` import.
-   */
-  set(srcDir, specifier, resolved) {
-    const key = makeKey(srcDir, specifier);
-    this.entries.set(key, { srcDir, resolved });
-    if (this.entries.size > this.maxEntries) {
-      const oldestKey = this.entries.keys().next().value;
-      if (oldestKey !== void 0) {
-        this.entries.delete(oldestKey);
-      }
+    /**
+     * Store a resolution result.
+     *
+     * Pass `undefined` for `resolved` to memoize the negative case
+     * (specifier did not resolve) and avoid repeating the FS walk on
+     * every `@/...` import.
+     */
+    set(srcDir, specifier, resolved) {
+        const key = makeKey(srcDir, specifier);
+        this.entries.set(key, { srcDir, resolved });
+        if (this.entries.size > this.maxEntries) {
+            const oldestKey = this.entries.keys().next().value;
+            if (oldestKey !== undefined) {
+                this.entries.delete(oldestKey);
+            }
+        }
     }
-  }
-  /**
-   * Drop all entries whose `srcDir` is under `rootDir`. Use this from
-   * the file watcher when files are added or removed under the app's
-   * source tree.
-   *
-   * Path comparison is path-aware (handles both POSIX `/` and
-   * Windows `\` separators) via `path.relative` so cached entries
-   * normalized on one platform still match the watcher's `rootDir`
-   * on another. Without this, a Windows build that sees
-   * `entry.srcDir === 'C:\app\src'` would miss
-   * `entry.srcDir.startsWith('C:/app/src/')` and leave stale entries.
-   */
-  invalidateUnder(rootDir) {
-    const normalizedRoot = path.resolve(rootDir);
-    let removed = 0;
-    for (const [key, entry] of this.entries) {
-      if (isUnderDirectory(path.resolve(entry.srcDir), normalizedRoot)) {
-        this.entries.delete(key);
-        removed += 1;
-      }
+    /**
+     * Drop all entries whose `srcDir` is under `rootDir`. Use this from
+     * the file watcher when files are added or removed under the app's
+     * source tree.
+     *
+     * Path comparison is path-aware (handles both POSIX `/` and
+     * Windows `\` separators) via `path.relative` so cached entries
+     * normalized on one platform still match the watcher's `rootDir`
+     * on another. Without this, a Windows build that sees
+     * `entry.srcDir === 'C:\app\src'` would miss
+     * `entry.srcDir.startsWith('C:/app/src/')` and leave stale entries.
+     */
+    invalidateUnder(rootDir) {
+        const normalizedRoot = path.resolve(rootDir);
+        let removed = 0;
+        for (const [key, entry] of this.entries) {
+            if (isUnderDirectory(path.resolve(entry.srcDir), normalizedRoot)) {
+                this.entries.delete(key);
+                removed += 1;
+            }
+        }
+        return removed;
+    }
+    /** Clear all entries. */
+    clear() {
+        this.entries.clear();
+        this.hits = 0;
+        this.misses = 0;
+    }
+    /** Current cache size. */
+    get size() {
+        return this.entries.size;
+    }
+    /** Hit/miss counters for observability. */
+    stats() {
+        const total = this.hits + this.misses;
+        return {
+            hits: this.hits,
+            misses: this.misses,
+            size: this.entries.size,
+            hitRate: total === 0 ? 0 : this.hits / total,
+        };
     }
-    return removed;
-  }
-  /** Clear all entries. */
-  clear() {
-    this.entries.clear();
-    this.hits = 0;
-    this.misses = 0;
-  }
-  /** Current cache size. */
-  get size() {
-    return this.entries.size;
-  }
-  /** Hit/miss counters for observability. */
-  stats() {
-    const total = this.hits + this.misses;
-    return {
-      hits: this.hits,
-      misses: this.misses,
-      size: this.entries.size,
-      hitRate: total === 0 ? 0 : this.hits / total
-    };
-  }
 }
 function makeKey(srcDir, specifier) {
-  return `${srcDir} ${specifier}`;
+    return `${srcDir} ${specifier}`;
 }
+/**
+ * Returns true if `candidate` is the same as `parent` or a descendant
+ * of it. Uses `path.relative` so the comparison is path-aware and
+ * works across POSIX and Windows separators.
+ */
 function isUnderDirectory(candidate, parent) {
-  if (candidate === parent) return true;
-  const rel = path.relative(parent, candidate);
-  if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) return false;
-  return true;
+    if (candidate === parent)
+        return true;
+    const rel = path.relative(parent, candidate);
+    if (!rel || rel.startsWith('..') || path.isAbsolute(rel))
+        return false;
+    return true;
 }
-export {
-  AliasResolverCache
-};

package/src/plugins/alias-resolver-plugin.js

@@ -1,52 +1,38 @@
-import { AliasResolverCache } from "./alias-resolver-cache.js";
-import { loadTsconfigPathPrefixes, resolveProjectImportPath } from "./tsconfig-import-resolver.js";
+import { AliasResolverCache } from './alias-resolver-cache.js';
+import { loadTsconfigPathPrefixes, resolveProjectImportPath } from './tsconfig-import-resolver.js';
 function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 function buildPathPrefixFilter(prefix) {
-  if (prefix.endsWith("/")) {
-    return new RegExp(`^${escapeRegExp(prefix)}`);
-  }
-  return new RegExp(`^${escapeRegExp(prefix)}(?:/|$)`);
-}
-function createAliasResolverPlugin(projectRoot, options) {
-  const cache = options?.cache ?? new AliasResolverCache();
-  const pathPrefixes = loadTsconfigPathPrefixes(projectRoot);
-  return {
-    name: "ecopages-alias-resolver",
-    setup(build) {
-      if (pathPrefixes.length === 0) {
-        return;
-      }
-      for (const prefix of pathPrefixes) {
-        build.onResolve({ filter: buildPathPrefixFilter(prefix) }, (args) => {
-          if (!args.importer) {
-            return void 0;
-          }
-          const cached = cache.get(projectRoot, args.path);
-          if (cached.hit) {
-            return cached.resolved ? { path: cached.resolved } : void 0;
-          }
-          const resolved = resolveProjectImportPath(projectRoot, args.importer, args.path);
-          cache.set(projectRoot, args.path, resolved);
-          return resolved ? { path: resolved } : void 0;
-        });
-      }
+    if (prefix.endsWith('/')) {
+        return new RegExp(`^${escapeRegExp(prefix)}`);
     }
-  };
+    return new RegExp(`^${escapeRegExp(prefix)}(?:/|$)`);
+}
+export function createAliasResolverPlugin(projectRoot, options) {
+    const cache = options?.cache ?? new AliasResolverCache();
+    const pathPrefixes = loadTsconfigPathPrefixes(projectRoot);
+    return {
+        name: 'ecopages-alias-resolver',
+        setup(build) {
+            if (pathPrefixes.length === 0) {
+                return;
+            }
+            for (const prefix of pathPrefixes) {
+                build.onResolve({ filter: buildPathPrefixFilter(prefix) }, (args) => {
+                    if (!args.importer) {
+                        return undefined;
+                    }
+                    const cached = cache.get(projectRoot, args.path);
+                    if (cached.hit) {
+                        return cached.resolved ? { path: cached.resolved } : undefined;
+                    }
+                    const resolved = resolveProjectImportPath(projectRoot, args.importer, args.path);
+                    cache.set(projectRoot, args.path, resolved);
+                    return resolved ? { path: resolved } : undefined;
+                });
+            }
+        },
+    };
 }
-import {
-  isBarePackageImportSpecifier,
-  matchesTsconfigPathPrefix,
-  loadTsconfigPathPrefixes as loadTsconfigPathPrefixes2,
-  resolveProjectImportPath as resolveProjectImportPath2,
-  resolveProjectModulePath
-} from "./tsconfig-import-resolver.js";
-export {
-  createAliasResolverPlugin,
-  isBarePackageImportSpecifier,
-  loadTsconfigPathPrefixes2 as loadTsconfigPathPrefixes,
-  matchesTsconfigPathPrefix,
-  resolveProjectImportPath2 as resolveProjectImportPath,
-  resolveProjectModulePath
-};
+export { isBarePackageImportSpecifier, matchesTsconfigPathPrefix, loadTsconfigPathPrefixes, resolveProjectImportPath, resolveProjectModulePath, } from './tsconfig-import-resolver.js';

package/src/plugins/define-integration.js

@@ -1,19 +1,20 @@
-import { IntegrationPlugin } from "./integration-plugin.js";
-function defineIntegration(definition) {
-  const { renderer, ...defaultConfig } = definition;
-  class DefinedIntegrationPlugin extends IntegrationPlugin {
-    renderer = renderer;
-    constructor(options) {
-      super({
-        ...defaultConfig,
-        ...options
-      });
+import { IntegrationPlugin } from './integration-plugin.js';
+/**
+ * Creates a typed integration plugin factory for integrations that only need
+ * declarative config and a renderer class.
+ */
+export function defineIntegration(definition) {
+    const { renderer, ...defaultConfig } = definition;
+    class DefinedIntegrationPlugin extends IntegrationPlugin {
+        renderer = renderer;
+        constructor(options) {
+            super({
+                ...defaultConfig,
+                ...options,
+            });
+        }
     }
-  }
-  const factory = ((options) => new DefinedIntegrationPlugin(options));
-  factory.Plugin = DefinedIntegrationPlugin;
-  return factory;
+    const factory = ((options) => new DefinedIntegrationPlugin(options));
+    factory.Plugin = DefinedIntegrationPlugin;
+    return factory;
 }
-export {
-  defineIntegration
-};