@ecopages/core 0.2.0-alpha.4 → 0.2.0-alpha.6

package/src/services/cache/memory-cache-store.js

@@ -1,98 +0,0 @@
-class MemoryCacheStore {
-  cache = /* @__PURE__ */ new Map();
-  tagIndex = /* @__PURE__ */ new Map();
-  maxEntries;
-  constructor(options = {}) {
-    this.maxEntries = options.maxEntries ?? 1e3;
-  }
-  /**
-   * Retrieve an entry by key.
-   * Uses Map's insertion order for LRU tracking - accessed entries are
-   * deleted and re-inserted to move them to the "most recently used" position.
-   */
-  async get(key) {
-    const entry = this.cache.get(key);
-    if (!entry) return null;
-    this.cache.delete(key);
-    this.cache.set(key, entry);
-    return entry;
-  }
-  /**
-   * Store an entry, evicting the oldest if at capacity.
-   * When maxEntries is reached and a new key is added, the first key in
-   * the Map (oldest/least-recently-used) is evicted to make room.
-   * Updating an existing key refreshes its LRU position.
-   */
-  async set(key, entry) {
-    const existingEntry = this.cache.get(key);
-    if (existingEntry) {
-      for (const tag of existingEntry.tags) {
-        this.tagIndex.get(tag)?.delete(key);
-        if (this.tagIndex.get(tag)?.size === 0) {
-          this.tagIndex.delete(tag);
-        }
-      }
-      this.cache.delete(key);
-    } else if (this.cache.size >= this.maxEntries) {
-      const oldestKey = this.cache.keys().next().value;
-      if (oldestKey) await this.delete(oldestKey);
-    }
-    this.cache.set(key, entry);
-    for (const tag of entry.tags) {
-      if (!this.tagIndex.has(tag)) {
-        this.tagIndex.set(tag, /* @__PURE__ */ new Set());
-      }
-      this.tagIndex.get(tag).add(key);
-    }
-  }
-  /**
-   * Delete an entry and clean up its tag index references.
-   * Removes empty tag sets to prevent memory leaks from accumulated tags.
-   */
-  async delete(key) {
-    const entry = this.cache.get(key);
-    if (!entry) return false;
-    for (const tag of entry.tags) {
-      this.tagIndex.get(tag)?.delete(key);
-      if (this.tagIndex.get(tag)?.size === 0) {
-        this.tagIndex.delete(tag);
-      }
-    }
-    return this.cache.delete(key);
-  }
-  async invalidateByTags(tags) {
-    let count = 0;
-    const keysToDelete = /* @__PURE__ */ new Set();
-    for (const tag of tags) {
-      const keys = this.tagIndex.get(tag);
-      if (keys) {
-        for (const key of keys) {
-          keysToDelete.add(key);
-        }
-      }
-    }
-    for (const key of keysToDelete) {
-      if (await this.delete(key)) count++;
-    }
-    return count;
-  }
-  async invalidateByPaths(paths) {
-    let count = 0;
-    for (const path of paths) {
-      if (await this.delete(path)) count++;
-    }
-    return count;
-  }
-  async clear() {
-    this.cache.clear();
-    this.tagIndex.clear();
-  }
-  async stats() {
-    return {
-      entries: this.cache.size
-    };
-  }
-}
-export {
-  MemoryCacheStore
-};

package/src/services/cache/page-cache-service.d.ts

@@ -1,70 +0,0 @@
-/**
- * Page cache service with ISR (Incremental Static Regeneration) support.
- * Handles stale-while-revalidate semantics and background regeneration.
- * @module
- */
-import type { CacheResult, CacheStore, CacheStrategy, RenderResult } from './cache.types.js';
-export interface PageCacheServiceOptions {
-    store?: CacheStore;
-    enabled?: boolean;
-}
-/**
- * Core page caching service with ISR support.
- */
-export declare class PageCacheService {
-    private store;
-    private enabled;
-    private regenerationPromises;
-    constructor(options?: PageCacheServiceOptions);
-    /**
-     * Generate a cache key from URL and optional params.
-     * Uses full URL (path + query) as the key.
-     */
-    generateCacheKey(url: string): string;
-    /**
-     * Check if an entry is stale (past its revalidation time).
-     */
-    private isStale;
-    /**
-     * Create a cache entry from rendered HTML.
-     */
-    private createEntry;
-    /**
-     * Get cached content or create new content with stale-while-revalidate semantics.
-     * @param key - Cache key (URL path + query)
-     * @param defaultStrategy - Default strategy if page doesn't specify one
-     * @param renderFn - Function that renders the page and returns HTML + strategy
-     */
-    getOrCreate(key: string, defaultStrategy: CacheStrategy, renderFn: () => Promise<RenderResult>): Promise<CacheResult>;
-    /**
-     * Regenerate content in the background without blocking the response.
-     * Uses promise deduplication to prevent multiple concurrent regenerations.
-     */
-    private regenerateInBackground;
-    /**
-     * Invalidate cache entries by tags.
-     */
-    invalidateByTags(tags: string[]): Promise<number>;
-    /**
-     * Invalidate cache entries by paths.
-     */
-    invalidateByPaths(paths: string[]): Promise<number>;
-    /**
-     * Clear all cached entries.
-     */
-    clear(): Promise<void>;
-    /**
-     * Get cache statistics.
-     */
-    stats(): Promise<import("./cache.types.js").CacheStats | {
-        entries: number;
-    }>;
-    /**
-     * Get the underlying cache store.
-     */
-    getStore(): CacheStore;
-}
-/**
- * Generate Cache-Control header value from cache strategy.
- */
-export declare function getCacheControlHeader(strategy: CacheStrategy | 'disabled'): string;

package/src/services/cache/page-cache-service.js

@@ -1,152 +0,0 @@
-import { appLogger } from "../../global/app-logger.js";
-import { MemoryCacheStore } from "./memory-cache-store.js";
-class PageCacheService {
-  store;
-  enabled;
-  regenerationPromises = /* @__PURE__ */ new Map();
-  constructor(options = {}) {
-    this.store = options.store ?? new MemoryCacheStore();
-    this.enabled = options.enabled ?? true;
-  }
-  /**
-   * Generate a cache key from URL and optional params.
-   * Uses full URL (path + query) as the key.
-   */
-  generateCacheKey(url) {
-    return url;
-  }
-  /**
-   * Check if an entry is stale (past its revalidation time).
-   */
-  isStale(entry) {
-    if (entry.revalidateAfter === null) return false;
-    return Date.now() > entry.revalidateAfter;
-  }
-  /**
-   * Create a cache entry from rendered HTML.
-   */
-  createEntry(html, strategy) {
-    const now = Date.now();
-    let revalidateAfter = null;
-    let tags = [];
-    if (strategy === "static") {
-      revalidateAfter = null;
-    } else if (strategy === "dynamic") {
-      revalidateAfter = 0;
-    } else if (typeof strategy === "object") {
-      revalidateAfter = now + strategy.revalidate * 1e3;
-      tags = strategy.tags ?? [];
-    }
-    return {
-      html,
-      createdAt: now,
-      revalidateAfter,
-      tags,
-      strategy
-    };
-  }
-  /**
-   * Get cached content or create new content with stale-while-revalidate semantics.
-   * @param key - Cache key (URL path + query)
-   * @param defaultStrategy - Default strategy if page doesn't specify one
-   * @param renderFn - Function that renders the page and returns HTML + strategy
-   */
-  async getOrCreate(key, defaultStrategy, renderFn) {
-    if (!this.enabled) {
-      const { html, strategy } = await renderFn();
-      return { html, status: "miss", strategy };
-    }
-    const entry = await this.store.get(key);
-    if (!entry) {
-      const { html, strategy } = await renderFn();
-      const effectiveStrategy = strategy ?? defaultStrategy;
-      if (effectiveStrategy === "dynamic") {
-        return { html, status: "miss", strategy: effectiveStrategy };
-      }
-      const newEntry = this.createEntry(html, effectiveStrategy);
-      await this.store.set(key, newEntry);
-      return { html, status: "miss", strategy: effectiveStrategy };
-    }
-    if (!this.isStale(entry)) {
-      return { html: entry.html, status: "hit", strategy: entry.strategy };
-    }
-    this.regenerateInBackground(key, entry.strategy, renderFn);
-    return { html: entry.html, status: "stale", strategy: entry.strategy };
-  }
-  /**
-   * Regenerate content in the background without blocking the response.
-   * Uses promise deduplication to prevent multiple concurrent regenerations.
-   */
-  regenerateInBackground(key, fallbackStrategy, renderFn) {
-    if (this.regenerationPromises.has(key)) {
-      return;
-    }
-    const regeneratePromise = (async () => {
-      try {
-        const { html, strategy } = await renderFn();
-        const effectiveStrategy = strategy ?? fallbackStrategy;
-        const newEntry = this.createEntry(html, effectiveStrategy);
-        await this.store.set(key, newEntry);
-        return html;
-      } finally {
-        this.regenerationPromises.delete(key);
-      }
-    })();
-    this.regenerationPromises.set(key, regeneratePromise);
-    queueMicrotask(() => {
-      regeneratePromise.catch((error) => {
-        appLogger.error(`[PageCacheService] Failed to regenerate: ${key}`, error);
-      });
-    });
-  }
-  /**
-   * Invalidate cache entries by tags.
-   */
-  async invalidateByTags(tags) {
-    return this.store.invalidateByTags(tags);
-  }
-  /**
-   * Invalidate cache entries by paths.
-   */
-  async invalidateByPaths(paths) {
-    return this.store.invalidateByPaths(paths);
-  }
-  /**
-   * Clear all cached entries.
-   */
-  async clear() {
-    return this.store.clear();
-  }
-  /**
-   * Get cache statistics.
-   */
-  async stats() {
-    return this.store.stats?.() ?? { entries: 0 };
-  }
-  /**
-   * Get the underlying cache store.
-   */
-  getStore() {
-    return this.store;
-  }
-}
-function getCacheControlHeader(strategy) {
-  if (strategy === "disabled") {
-    return "no-store, must-revalidate";
-  }
-  if (strategy === "static") {
-    return "public, max-age=31536000, immutable";
-  }
-  if (strategy === "dynamic") {
-    return "no-store, must-revalidate";
-  }
-  if (typeof strategy === "object") {
-    const swr = strategy.revalidate * 2;
-    return `public, max-age=${strategy.revalidate}, stale-while-revalidate=${swr}`;
-  }
-  return "no-store";
-}
-export {
-  PageCacheService,
-  getCacheControlHeader
-};

package/src/services/html-transformer.service.d.ts

@@ -1,50 +0,0 @@
-import type { ProcessedAsset } from './asset-processing-service/assets.types';
-export type HtmlRewriterMode = 'auto' | 'native' | 'worker-tools' | 'fallback';
-export interface HtmlTransformerServiceOptions {
-    htmlRewriterMode?: HtmlRewriterMode;
-}
-export declare class HtmlTransformerService {
-    private processedDependencies;
-    private htmlRewriterConstructorPromise?;
-    private htmlRewriterMode;
-    constructor(options?: HtmlTransformerServiceOptions);
-    /**
-     * Overrides the HTML rewriter runtime selection.
-     *
-     * This is intended for internal/runtime tests that need deterministic
-     * selection between native, worker-tools, and string fallback behavior.
-     *
-     * @param mode Requested runtime selection strategy.
-     */
-    setHtmlRewriterMode(mode: HtmlRewriterMode): void;
-    /**
-     * Creates an HTML rewriter instance from the best available runtime.
-     *
-     * Resolution order is:
-     * 1. native `globalThis.HTMLRewriter`
-     * 2. `@worker-tools/html-rewriter/base64`
-     * 3. `null`, which triggers the string-based fallback path
-     *
-     * @returns HTML rewriter instance when available; otherwise `null`.
-     */
-    private createHtmlRewriter;
-    /**
-     * Resolves the constructor used for HTML rewriting.
-     *
-     * The worker-tools fallback is loaded lazily so native runtimes avoid the WASM
-     * dependency cost unless it is actually needed.
-     *
-     * @returns Rewriter constructor when available; otherwise `null`.
-     */
-    private resolveHtmlRewriterConstructor;
-    private formatAttributes;
-    private generateScriptTag;
-    private generateStylesheetTag;
-    private appendDependencies;
-    private buildDependencyTags;
-    private injectBeforeClosingTag;
-    setProcessedDependencies(processedDependencies: ProcessedAsset[]): void;
-    getProcessedDependencies(): ProcessedAsset[];
-    transform(res: Response): Promise<Response>;
-    private groupDependenciesByPosition;
-}

package/src/services/html-transformer.service.js

@@ -1,163 +0,0 @@
-import { appLogger } from "../global/app-logger.js";
-class HtmlTransformerService {
-  processedDependencies = [];
-  htmlRewriterConstructorPromise;
-  htmlRewriterMode = "auto";
-  constructor(options = {}) {
-    this.setHtmlRewriterMode(options.htmlRewriterMode ?? "auto");
-  }
-  /**
-   * Overrides the HTML rewriter runtime selection.
-   *
-   * This is intended for internal/runtime tests that need deterministic
-   * selection between native, worker-tools, and string fallback behavior.
-   *
-   * @param mode Requested runtime selection strategy.
-   */
-  setHtmlRewriterMode(mode) {
-    this.htmlRewriterMode = mode;
-    this.htmlRewriterConstructorPromise = void 0;
-  }
-  /**
-   * Creates an HTML rewriter instance from the best available runtime.
-   *
-   * Resolution order is:
-   * 1. native `globalThis.HTMLRewriter`
-   * 2. `@worker-tools/html-rewriter/base64`
-   * 3. `null`, which triggers the string-based fallback path
-   *
-   * @returns HTML rewriter instance when available; otherwise `null`.
-   */
-  async createHtmlRewriter() {
-    const RuntimeHtmlRewriter = await this.resolveHtmlRewriterConstructor();
-    return RuntimeHtmlRewriter ? new RuntimeHtmlRewriter() : null;
-  }
-  /**
-   * Resolves the constructor used for HTML rewriting.
-   *
-   * The worker-tools fallback is loaded lazily so native runtimes avoid the WASM
-   * dependency cost unless it is actually needed.
-   *
-   * @returns Rewriter constructor when available; otherwise `null`.
-   */
-  async resolveHtmlRewriterConstructor() {
-    if (!this.htmlRewriterConstructorPromise) {
-      const mode = this.htmlRewriterMode;
-      const RuntimeHtmlRewriter = globalThis.HTMLRewriter;
-      if (mode === "fallback") {
-        this.htmlRewriterConstructorPromise = Promise.resolve(null);
-      } else if (mode === "native") {
-        if (RuntimeHtmlRewriter) {
-          this.htmlRewriterConstructorPromise = Promise.resolve(RuntimeHtmlRewriter);
-        } else {
-          appLogger.warn(
-            "[HtmlTransformerService] Native HTMLRewriter was forced but is unavailable, falling back to string injection."
-          );
-          this.htmlRewriterConstructorPromise = Promise.resolve(null);
-        }
-      } else if (mode === "auto" && RuntimeHtmlRewriter) {
-        this.htmlRewriterConstructorPromise = Promise.resolve(RuntimeHtmlRewriter);
-      } else {
-        this.htmlRewriterConstructorPromise = import("@worker-tools/html-rewriter/base64").then((module) => module.HTMLRewriter).catch((error) => {
-          const message = error instanceof Error ? error.message : String(error);
-          appLogger.warn(
-            `[HtmlTransformerService] Failed to load @worker-tools/html-rewriter/base64, falling back to string injection: ${message}`
-          );
-          return null;
-        });
-      }
-    }
-    return this.htmlRewriterConstructorPromise;
-  }
-  formatAttributes(attrs) {
-    if (!attrs) return "";
-    return ` ${Object.entries(attrs).map(([key, value]) => `${key}="${value}"`).join(" ")}`;
-  }
-  generateScriptTag(dep) {
-    return dep.inline ? `<script${this.formatAttributes(dep.attributes)}>${dep.content}<\/script>` : `<script src="${dep.srcUrl}"${this.formatAttributes(dep.attributes)}><\/script>`;
-  }
-  generateStylesheetTag(dep) {
-    return dep.inline ? `<style${this.formatAttributes(dep.attributes)}>${dep.content}</style>` : `<link rel="stylesheet" href="${dep.srcUrl}"${this.formatAttributes(dep.attributes)}>`;
-  }
-  appendDependencies(element, dependencies) {
-    for (const dep of dependencies) {
-      const tag = dep.kind === "script" ? this.generateScriptTag(dep) : this.generateStylesheetTag(dep);
-      element.append(tag, { html: true });
-    }
-  }
-  buildDependencyTags(dependencies) {
-    return dependencies.map(
-      (dep) => dep.kind === "script" ? this.generateScriptTag(dep) : this.generateStylesheetTag(dep)
-    ).join("");
-  }
-  injectBeforeClosingTag(html, tag, content) {
-    if (!content) {
-      return html;
-    }
-    const closingTag = `</${tag}>`;
-    const lowerHtml = html.toLowerCase();
-    const closingTagIndex = lowerHtml.lastIndexOf(closingTag);
-    if (closingTagIndex !== -1) {
-      return `${html.slice(0, closingTagIndex)}${content}${html.slice(closingTagIndex)}`;
-    }
-    if (tag === "head") {
-      return `${content}${html}`;
-    }
-    return `${html}${content}`;
-  }
-  setProcessedDependencies(processedDependencies) {
-    this.processedDependencies = processedDependencies;
-  }
-  getProcessedDependencies() {
-    return this.processedDependencies;
-  }
-  async transform(res) {
-    const { head, body } = this.groupDependenciesByPosition();
-    const htmlRewriter = await this.createHtmlRewriter();
-    const html = await res.text();
-    const headers = new Headers(res.headers);
-    if (htmlRewriter) {
-      htmlRewriter.on("head", {
-        element: (element) => this.appendDependencies(element, head)
-      }).on("body", {
-        element: (element) => this.appendDependencies(element, body)
-      });
-      return htmlRewriter.transform(
-        new Response(html, {
-          headers,
-          status: res.status,
-          statusText: res.statusText
-        })
-      );
-    }
-    const withHeadDependencies = this.injectBeforeClosingTag(html, "head", this.buildDependencyTags(head));
-    const transformedHtml = this.injectBeforeClosingTag(
-      withHeadDependencies,
-      "body",
-      this.buildDependencyTags(body)
-    );
-    return new Response(transformedHtml, {
-      headers,
-      status: res.status,
-      statusText: res.statusText
-    });
-  }
-  groupDependenciesByPosition() {
-    return this.processedDependencies.reduce(
-      (acc, dep) => {
-        if (dep.kind === "script") {
-          if (dep.excludeFromHtml) return acc;
-          const position = dep.position || "body";
-          acc[position].push(dep);
-        } else if (dep.kind === "stylesheet") {
-          acc.head.push(dep);
-        }
-        return acc;
-      },
-      { head: [], body: [] }
-    );
-  }
-}
-export {
-  HtmlTransformerService
-};