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

package/src/services/assets/asset-processing-service/processors/stylesheet/stylesheet-processor-pipeline.js

@@ -1,43 +1,44 @@
-import path from "node:path";
-const PROCESSABLE_STYLESHEET_EXTENSIONS = /* @__PURE__ */ new Set([".css", ".scss", ".sass", ".less"]);
+import path from 'node:path';
+const PROCESSABLE_STYLESHEET_EXTENSIONS = new Set(['.css', '.scss', '.sass', '.less']);
 function isProcessableStylesheet(filepath) {
-  return PROCESSABLE_STYLESHEET_EXTENSIONS.has(path.extname(filepath));
+    return PROCESSABLE_STYLESHEET_EXTENSIONS.has(path.extname(filepath));
 }
+/**
+ * Legacy fallback for processors that transform stylesheets without declaring
+ * capabilities (notably PostCSS before capability metadata was required).
+ */
 function shouldRunStylesheetProcessor(processor, filepath) {
-  const hasCapabilities = processor.getAssetCapabilities().length > 0;
-  const canProcessStylesheet = processor.canProcessAsset("stylesheet", filepath);
-  if (canProcessStylesheet) {
-    return true;
-  }
-  if (hasCapabilities) {
-    return false;
-  }
-  return processor.getName().includes("postcss");
-}
-async function applyStylesheetProcessors(appConfig, content, filepath) {
-  if (!isProcessableStylesheet(filepath)) {
-    return content;
-  }
-  let transformedContent = content;
-  const processors = appConfig.processors ? Array.from(appConfig.processors.values()) : [];
-  for (const processor of processors) {
-    if (!shouldRunStylesheetProcessor(processor, filepath)) {
-      continue;
+    const hasCapabilities = processor.getAssetCapabilities().length > 0;
+    const canProcessStylesheet = processor.canProcessAsset('stylesheet', filepath);
+    if (canProcessStylesheet) {
+        return true;
     }
-    if (!processor.matchesFileFilter(filepath)) {
-      continue;
+    if (hasCapabilities) {
+        return false;
     }
-    const result = await processor.process(transformedContent, filepath);
-    if (typeof result === "string") {
-      transformedContent = result;
-      continue;
+    return processor.getName().includes('postcss');
+}
+export async function applyStylesheetProcessors(appConfig, content, filepath) {
+    if (!isProcessableStylesheet(filepath)) {
+        return content;
     }
-    if (result instanceof Buffer) {
-      transformedContent = result.toString();
+    let transformedContent = content;
+    const processors = appConfig.processors ? Array.from(appConfig.processors.values()) : [];
+    for (const processor of processors) {
+        if (!shouldRunStylesheetProcessor(processor, filepath)) {
+            continue;
+        }
+        if (!processor.matchesFileFilter(filepath)) {
+            continue;
+        }
+        const result = await processor.process(transformedContent, filepath);
+        if (typeof result === 'string') {
+            transformedContent = result;
+            continue;
+        }
+        if (result instanceof Buffer) {
+            transformedContent = result.toString();
+        }
     }
-  }
-  return transformedContent;
+    return transformedContent;
 }
-export {
-  applyStylesheetProcessors
-};

package/src/services/assets/asset-processing-service/resolve-integration-plugin.js

@@ -1,17 +1,15 @@
-function resolveIntegrationPluginForProcessingKey(appConfig, processingKey) {
-  if (!appConfig.integrations?.length) {
-    return void 0;
-  }
-  const exactMatch = appConfig.integrations.find((integration) => integration.name === processingKey);
-  if (exactMatch) {
-    return exactMatch;
-  }
-  const baseName = processingKey.split(":")[0];
-  if (!baseName || baseName === processingKey) {
-    return void 0;
-  }
-  return appConfig.integrations.find((integration) => integration.name === baseName);
+/** Resolves the integration plugin that owns one asset-processing batch key. */
+export function resolveIntegrationPluginForProcessingKey(appConfig, processingKey) {
+    if (!appConfig.integrations?.length) {
+        return undefined;
+    }
+    const exactMatch = appConfig.integrations.find((integration) => integration.name === processingKey);
+    if (exactMatch) {
+        return exactMatch;
+    }
+    const baseName = processingKey.split(':')[0];
+    if (!baseName || baseName === processingKey) {
+        return undefined;
+    }
+    return appConfig.integrations.find((integration) => integration.name === baseName);
 }
-export {
-  resolveIntegrationPluginForProcessingKey
-};

package/src/services/assets/asset-processing-service/ungrouped-dependency-processing.js

@@ -1,40 +1,28 @@
-import { fileSystem } from "@ecopages/file-system";
-import { finalizeProcessedAsset } from "./finalize-processed-asset.js";
-async function processUngroupedDependency(options) {
-  const {
-    dep,
-    depKey,
-    getCachedAsset,
-    getProcessor,
-    resolveProcessedAssetSrcUrl,
-    setCachedAsset,
-    logMissingProcessor,
-    logMissingFile,
-    logProcessingError
-  } = options;
-  const cached = getCachedAsset(dep, depKey);
-  if (cached) {
-    return finalizeProcessedAsset(cached, resolveProcessedAssetSrcUrl);
-  }
-  const processor = getProcessor(dep);
-  if (!processor) {
-    logMissingProcessor(dep);
-    return null;
-  }
-  if (dep.source === "file" && "filepath" in dep && !fileSystem.exists(dep.filepath)) {
-    logMissingFile(dep);
-    return null;
-  }
-  try {
-    const processed = await processor.process(dep);
-    const finalized = finalizeProcessedAsset(processed, resolveProcessedAssetSrcUrl);
-    setCachedAsset(dep, depKey, finalized);
-    return finalized;
-  } catch (error) {
-    logProcessingError(dep, error);
-    return null;
-  }
+import { fileSystem } from '@ecopages/file-system';
+import { finalizeProcessedAsset } from './finalize-processed-asset.js';
+export async function processUngroupedDependency(options) {
+    const { dep, depKey, getCachedAsset, getProcessor, resolveProcessedAssetSrcUrl, setCachedAsset, logMissingProcessor, logMissingFile, logProcessingError, } = options;
+    const cached = getCachedAsset(dep, depKey);
+    if (cached) {
+        return finalizeProcessedAsset(cached, resolveProcessedAssetSrcUrl);
+    }
+    const processor = getProcessor(dep);
+    if (!processor) {
+        logMissingProcessor(dep);
+        return null;
+    }
+    if (dep.source === 'file' && 'filepath' in dep && !fileSystem.exists(dep.filepath)) {
+        logMissingFile(dep);
+        return null;
+    }
+    try {
+        const processed = await processor.process(dep);
+        const finalized = finalizeProcessedAsset(processed, resolveProcessedAssetSrcUrl);
+        setCachedAsset(dep, depKey, finalized);
+        return finalized;
+    }
+    catch (error) {
+        logProcessingError(dep, error);
+        return null;
+    }
 }
-export {
-  processUngroupedDependency
-};

package/src/services/assets/browser-bundle.service.js

@@ -1,50 +1,55 @@
-import { createBrowserBuildRequest } from "../../build/runtime/build-request-policy.js";
-import { requireBuildRuntime } from "../../build/runtime/build-runtime.js";
-import { startupTrace } from "../../diagnostics/startup-trace.js";
-import { requestBuildDedupe } from "../../diagnostics/request-build-dedupe.js";
-import { createBuildRequestIdentity } from "../../build/runtime/build-request-identity.js";
+import { createBrowserBuildRequest } from '../../build/runtime/build-request-policy.js';
+import { requireBuildRuntime } from '../../build/runtime/build-runtime.js';
+import { startupTrace } from '../../diagnostics/startup-trace.js';
+import { requestBuildDedupe } from '../../diagnostics/request-build-dedupe.js';
+import { createBuildRequestIdentity } from '../../build/runtime/build-request-identity.js';
 function resolveBrowserBundleExecutor(appConfig, profile, executor) {
-  const buildRuntime = requireBuildRuntime(appConfig);
-  if (executor === "hmr" && (profile === "hmr-entrypoint" || profile === "hmr-runtime")) {
-    return buildRuntime.getProfile("browser-hmr");
-  }
-  return buildRuntime.getProfile("route-module");
+    const buildRuntime = requireBuildRuntime(appConfig);
+    if (executor === 'hmr' && (profile === 'hmr-entrypoint' || profile === 'hmr-runtime')) {
+        return buildRuntime.getProfile('browser-hmr');
+    }
+    return buildRuntime.getProfile('route-module');
 }
-class BrowserBundleService {
-  appConfig;
-  constructor(appConfig) {
-    this.appConfig = appConfig;
-  }
-  /**
-   * Runs one browser-targeted build through the app-owned executor.
-   *
-   * @remarks
-   * Browser defaults, app-owned browser plugins, and
-   * {@link getAppSourceTransforms | app source transforms} are applied here
-   * so HMR and asset generation do not recreate that policy at each call site.
-   */
-  async bundle(options) {
-    const { profile, executor = "hmr", ...requestInput } = options;
-    const request = createBrowserBuildRequest(this.appConfig, {
-      ...requestInput,
-      profile
-    });
-    const buildExecutor = resolveBrowserBundleExecutor(this.appConfig, profile, executor);
-    const dedupeKey = createBuildRequestIdentity(request);
-    return requestBuildDedupe.dedupeBuild(dedupeKey, async () => {
-      const result = await buildExecutor.build(request);
-      startupTrace.recordBrowserBundle(result.outputs);
-      return result;
-    });
-  }
-  async bundleGroupedEntries(entries, options) {
-    const request = {
-      ...options,
-      entrypoints: Object.fromEntries(entries.map((entry) => [entry.entryName, entry.entrypoint]))
-    };
-    return this.bundle(request);
-  }
+/**
+ * App-owned boundary for browser-oriented bundle work.
+ *
+ * @remarks
+ * Owns shared browser transpile defaults and ensures browser builds run through
+ * the app-owned executor rather than direct backend calls. Assembles a complete
+ * request via {@link createBrowserBuildRequest} before scheduling.
+ */
+export class BrowserBundleService {
+    appConfig;
+    constructor(appConfig) {
+        this.appConfig = appConfig;
+    }
+    /**
+     * Runs one browser-targeted build through the app-owned executor.
+     *
+     * @remarks
+     * Browser defaults, app-owned browser plugins, and
+     * {@link getAppSourceTransforms | app source transforms} are applied here
+     * so HMR and asset generation do not recreate that policy at each call site.
+     */
+    async bundle(options) {
+        const { profile, executor = 'hmr', ...requestInput } = options;
+        const request = createBrowserBuildRequest(this.appConfig, {
+            ...requestInput,
+            profile,
+        });
+        const buildExecutor = resolveBrowserBundleExecutor(this.appConfig, profile, executor);
+        const dedupeKey = createBuildRequestIdentity(request);
+        return requestBuildDedupe.dedupeBuild(dedupeKey, async () => {
+            const result = await buildExecutor.build(request);
+            startupTrace.recordBrowserBundle(result.outputs);
+            return result;
+        });
+    }
+    async bundleGroupedEntries(entries, options) {
+        const request = {
+            ...options,
+            entrypoints: Object.fromEntries(entries.map((entry) => [entry.entryName, entry.entrypoint])),
+        };
+        return this.bundle(request);
+    }
 }
-export {
-  BrowserBundleService
-};

package/src/services/cache/cache.types.js

@@ -0,0 +1,5 @@
+/**
+ * Cache types and interfaces for page caching and ISR
+ * @module
+ */
+export {};

package/src/services/cache/index.js

@@ -1,7 +1,6 @@
-import { MemoryCacheStore } from "./memory-cache-store.js";
-import { getCacheControlHeader, PageCacheService } from "./page-cache-service.js";
-export {
-  MemoryCacheStore,
-  PageCacheService,
-  getCacheControlHeader
-};
+/**
+ * Cache services exports
+ * @module
+ */
+export { MemoryCacheStore } from './memory-cache-store.js';
+export { getCacheControlHeader, PageCacheService } from './page-cache-service.js';

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

@@ -1,98 +1,110 @@
-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);
+/**
+ * In-memory cache store with LRU eviction.
+ * Suitable for single-instance deployments and development.
+ * @module
+ */
+/**
+ * Simple in-memory cache store with LRU eviction.
+ * Uses Map insertion order for LRU tracking.
+ */
+export class MemoryCacheStore {
+    cache = new Map();
+    tagIndex = new Map();
+    maxEntries;
+    constructor(options = {}) {
+        this.maxEntries = options.maxEntries ?? 1000;
+    }
+    /**
+     * 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, new Set());
+            }
+            this.tagIndex.get(tag).add(key);
         }
-      }
-      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);
     }
-  }
-  /**
-   * 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);
-      }
+    async invalidateByTags(tags) {
+        let count = 0;
+        const keysToDelete = 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;
     }
-    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);
+    async invalidateByPaths(paths) {
+        let count = 0;
+        for (const path of paths) {
+            if (await this.delete(path))
+                count++;
         }
-      }
+        return count;
     }
-    for (const key of keysToDelete) {
-      if (await this.delete(key)) count++;
+    async clear() {
+        this.cache.clear();
+        this.tagIndex.clear();
     }
-    return count;
-  }
-  async invalidateByPaths(paths) {
-    let count = 0;
-    for (const path of paths) {
-      if (await this.delete(path)) count++;
+    async stats() {
+        return {
+            entries: this.cache.size,
+        };
     }
-    return count;
-  }
-  async clear() {
-    this.cache.clear();
-    this.tagIndex.clear();
-  }
-  async stats() {
-    return {
-      entries: this.cache.size
-    };
-  }
 }
-export {
-  MemoryCacheStore
-};