@ecopages/image-processor 0.2.0-beta.0 → 0.2.0-beta.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecopages/image-processor",
-  "version": "0.2.0-beta.0",
+  "version": "0.2.0-beta.10",
   "description": "Image processor, transform and optimize images for web",
   "keywords": [
     "image",
@@ -11,14 +11,14 @@
   "type": "module",
   "repository": {
     "type": "git",
-    "url": "https://github.com/ecopages/ecopages.git",
+    "url": "git+https://github.com/ecopages/ecopages.git",
     "directory": "packages/processors/image-processor"
   },
   "peerDependencies": {
-    "@ecopages/core": "0.2.0-beta.0"
+    "@ecopages/core": "0.2.0-beta.10"
   },
   "dependencies": {
-    "@ecopages/file-system": "0.2.0-beta.0",
+    "@ecopages/file-system": "0.2.0-beta.10",
     "@ecopages/logger": "^0.2.3",
     "react": "^19.2.6",
     "react-dom": "^19.2.6",

package/src/image-processor.js

@@ -37,10 +37,10 @@ class ImageProcessor {
       if (this.config.cacheEnabled) {
         const cached = await this.cacheManager.readCache(cacheKey);
         if (cached) {
-          const mainFilePath = path.join(process.cwd(), cached.attributes.src);
+          const mainFilePath = path.join(this.config.outputDir, path.basename(cached.attributes.src));
           const mainFileExists = fileSystem.exists(mainFilePath);
           const variantsExist = cached.variants.every(
-            (v) => fileSystem.exists(path.join(process.cwd(), v.src))
+            (variant) => fileSystem.exists(path.join(this.config.outputDir, path.basename(variant.src)))
           );
           if (mainFileExists && variantsExist) {
             appLogger.debug(`Cache hit for ${imagePath}`);

package/src/image-runtime-state.d.ts

@@ -0,0 +1,20 @@
+import type { ImageSpecifications } from './types.js';
+export type ImageMap = Record<string, ImageSpecifications>;
+export type ImageProcessorDiskConfig = {
+    sourceDir: string;
+    outputDir: string;
+    acceptedFormats?: string[];
+};
+/**
+ * Parses export bindings from the generated image virtual-module source file.
+ */
+export declare function parseVirtualModuleExports(content: string): Record<string, ImageSpecifications> | null;
+export declare function getSourceImagePaths(resolvedConfig: ImageProcessorDiskConfig): Promise<string[]>;
+/**
+ * Restores processed image state from generated dist artifacts when every source
+ * image has a matching virtual-module export and output files on disk.
+ */
+export declare function loadProcessedImagesFromDisk(options: {
+    resolvedConfig: ImageProcessorDiskConfig;
+    runtimeVirtualModulePath: string;
+}): Promise<ImageMap | null>;

package/src/image-runtime-state.js

@@ -0,0 +1,58 @@
+import path from "node:path";
+import { fileSystem } from "@ecopages/file-system";
+import { anyCaseToCamelCase } from "./utils.js";
+function parseVirtualModuleExports(content) {
+  const exports = {};
+  const pattern = /export const (\w+) = ([\s\S]*?) as const;/g;
+  let match;
+  while ((match = pattern.exec(content)) !== null) {
+    try {
+      exports[match[1]] = JSON.parse(match[2]);
+    } catch {
+      return null;
+    }
+  }
+  return exports;
+}
+async function getSourceImagePaths(resolvedConfig) {
+  const acceptedFormats = resolvedConfig.acceptedFormats ?? ["jpg", "jpeg", "png", "webp"];
+  return fileSystem.glob([`${resolvedConfig.sourceDir}/**/*.{${acceptedFormats.join(",")}}`]);
+}
+function getGeneratedOutputPath(outputDir, src) {
+  return path.join(outputDir, path.basename(src));
+}
+async function loadProcessedImagesFromDisk(options) {
+  const sourceImages = await getSourceImagePaths(options.resolvedConfig);
+  if (sourceImages.length === 0) {
+    return {};
+  }
+  if (!fileSystem.exists(options.runtimeVirtualModulePath)) {
+    return null;
+  }
+  const exportsByName = parseVirtualModuleExports(fileSystem.readFileSync(options.runtimeVirtualModulePath));
+  if (!exportsByName) {
+    return null;
+  }
+  const imageMap = {};
+  for (const file of sourceImages) {
+    const basename = path.basename(file);
+    const exportName = anyCaseToCamelCase(basename);
+    const spec = exportsByName[exportName];
+    if (!spec) {
+      return null;
+    }
+    const outputPaths = [spec.attributes.src, ...spec.variants.map((variant) => variant.src)];
+    if (!outputPaths.every(
+      (src) => fileSystem.exists(getGeneratedOutputPath(options.resolvedConfig.outputDir, src))
+    )) {
+      return null;
+    }
+    imageMap[basename] = spec;
+  }
+  return imageMap;
+}
+export {
+  getSourceImagePaths,
+  loadProcessedImagesFromDisk,
+  parseVirtualModuleExports
+};

package/src/plugin.d.ts

@@ -32,7 +32,7 @@ export interface ImageProcessorConfig {
  * ImageMap
  * This is the representation of the image map in the virtual module
  */
-export type ImageMap = Record<string, ImageSpecifications>;
+export type { ImageMap } from './image-runtime-state.js';
 /**
  * ImageProcessorPlugin
  * A Processor for optimizing images.
@@ -54,22 +54,29 @@ export declare class ImageProcessorPlugin extends Processor<ImageProcessorConfig
      */
     private replaceProcessedImages;
     /**
-     * Prepares the image virtual-module state before config build seals the app
-     * manifest.
+     * Resolves processor config and creates the sharp-backed worker instance.
+     */
+    private initializeProcessor;
+    /**
+     * Prepares build-facing processor state before config build seals the app manifest.
+     *
+     * @remarks
+     * Image processing stays in {@link setup}; this hook only initializes config and
+     * restores any previously generated virtual-module state from disk.
      */
     prepareBuildContributions(): Promise<void>;
     private getRuntimeVirtualModulePath;
     private getGeneratedOutputPath;
-    private hasGeneratedOutputs;
-    private rehydrateGeneratedOutputs;
     /**
-     * Generate dependencies for processor.
-     * It is ossible to define which one should be included in the final bundle based on the environment.
-     * @returns
+     * Restores in-memory image state from previously generated dist artifacts.
+     *
+     * @returns `true` when state was restored without invoking sharp.
      */
-    private generateDependencies;
+    private syncProcessedImagesFromDisk;
+    private ensureGeneratedOutputs;
+    private writeGeneratedFile;
     /**
-     * Prepares build contributions if not already done and rehydrates previously generated image outputs.
+     * Ensures optimized image outputs and virtual-module state exist on disk.
      */
     setup(): Promise<void>;
     /**

package/src/plugin.js

@@ -8,6 +8,7 @@ import {
 import { Logger } from "@ecopages/logger";
 import { createImagePlugin, createImagePluginBundler } from "./image-plugins.js";
 import { ImageProcessor } from "./image-processor.js";
+import { getSourceImagePaths, loadProcessedImagesFromDisk } from "./image-runtime-state.js";
 import { anyCaseToCamelCase } from "./utils.js";
 function resolveGeneratedPath(type, options) {
   const { root, module, subPath } = options;
@@ -110,11 +111,10 @@ class ImageProcessorPlugin extends Processor {
     Object.assign(this.processedImages, images);
   }
   /**
-   * Prepares the image virtual-module state before config build seals the app
-   * manifest.
+   * Resolves processor config and creates the sharp-backed worker instance.
    */
-  async prepareBuildContributions() {
-    if (this.buildContributionsPrepared) {
+  initializeProcessor() {
+    if (this.processor && this.resolvedConfig) {
       return;
     }
     if (!this.context) {
@@ -138,12 +138,27 @@ class ImageProcessorPlugin extends Processor {
       readCache: (key) => this.readCache(key),
       writeCache: (key, data) => this.writeCache(key, data)
     });
-    this.replaceProcessedImages(await this.processor.processDirectory());
     if (this.watchConfig) {
       this.watchConfig.paths = [config.sourceDir];
     }
-    this.dependencies = this.generateDependencies();
-    this.generateTypes();
+  }
+  /**
+   * Prepares build-facing processor state before config build seals the app manifest.
+   *
+   * @remarks
+   * Image processing stays in {@link setup}; this hook only initializes config and
+   * restores any previously generated virtual-module state from disk.
+   */
+  async prepareBuildContributions() {
+    if (this.buildContributionsPrepared) {
+      return;
+    }
+    if (process.env.ECOPAGES_LIT_STATIC_RENDER_WORKER === "true") {
+      this.buildContributionsPrepared = true;
+      return;
+    }
+    this.initializeProcessor();
+    await this.syncProcessedImagesFromDisk();
     this.buildContributionsPrepared = true;
   }
   getRuntimeVirtualModulePath() {
@@ -162,46 +177,58 @@ class ImageProcessorPlugin extends Processor {
     }
     return path.join(this.resolvedConfig.outputDir, path.basename(src));
   }
-  hasGeneratedOutputs() {
+  /**
+   * Restores in-memory image state from previously generated dist artifacts.
+   *
+   * @returns `true` when state was restored without invoking sharp.
+   */
+  async syncProcessedImagesFromDisk() {
     if (!this.resolvedConfig) {
       return false;
     }
-    if (!fileSystem.exists(this.resolvedConfig.outputDir) || !fileSystem.exists(this.getRuntimeVirtualModulePath())) {
+    const sourceImages = await getSourceImagePaths(this.resolvedConfig);
+    const imageMap = await loadProcessedImagesFromDisk({
+      resolvedConfig: this.resolvedConfig,
+      runtimeVirtualModulePath: this.getRuntimeVirtualModulePath()
+    });
+    if (imageMap === null) {
       return false;
     }
-    return Object.values(this.processedImages).every((image) => {
-      const outputPaths = [image.attributes.src, ...image.variants.map((variant) => variant.src)];
-      return outputPaths.every((src) => fileSystem.exists(this.getGeneratedOutputPath(src)));
-    });
+    if (sourceImages.length > 0 && Object.keys(imageMap).length !== sourceImages.length) {
+      return false;
+    }
+    this.replaceProcessedImages(imageMap);
+    if (Object.keys(imageMap).length > 0) {
+      this.generateTypes();
+    }
+    return true;
   }
-  async rehydrateGeneratedOutputs() {
+  async ensureGeneratedOutputs() {
     if (!this.processor) {
       throw new Error("ImageProcessor not initialized");
     }
-    if (this.hasGeneratedOutputs()) {
+    if (await this.syncProcessedImagesFromDisk()) {
       return;
     }
     this.replaceProcessedImages(await this.processor.processDirectory());
-    this.dependencies = this.generateDependencies();
     this.generateTypes();
   }
-  /**
-   * Generate dependencies for processor.
-   * It is ossible to define which one should be included in the final bundle based on the environment.
-   * @returns
-   */
-  generateDependencies() {
-    const deps = [];
-    if (process.env.NODE_ENV === "development") {
+  writeGeneratedFile(filePath, content) {
+    fileSystem.ensureDir(path.dirname(filePath));
+    if (fileSystem.exists(filePath) && fileSystem.readFileSync(filePath) === content) {
+      return;
     }
-    return deps;
+    fileSystem.write(filePath, content);
   }
   /**
-   * Prepares build contributions if not already done and rehydrates previously generated image outputs.
+   * Ensures optimized image outputs and virtual-module state exist on disk.
    */
   async setup() {
-    await this.prepareBuildContributions();
-    await this.rehydrateGeneratedOutputs();
+    if (process.env.ECOPAGES_LIT_STATIC_RENDER_WORKER === "true") {
+      return;
+    }
+    this.initializeProcessor();
+    await this.ensureGeneratedOutputs();
   }
   /**
    * Process images.
@@ -288,8 +315,7 @@ declare module "ecopages:images" {
       module: this.name,
       subPath: "virtual-module.d.ts"
     });
-    fileSystem.ensureDir(path.dirname(typesDir));
-    fileSystem.write(typesDir, content);
+    this.writeGeneratedFile(typesDir, content);
     logger.debug("Generated types for virtual module", { typesDir });
     const indexTypesDir = resolveGeneratedPath("types", {
       root: this.context.rootDir,
@@ -297,7 +323,7 @@ declare module "ecopages:images" {
       subPath: "index.d.ts"
     });
     const indexContent = 'import "./virtual-module.d.js";';
-    fileSystem.write(indexTypesDir, indexContent);
+    this.writeGeneratedFile(indexTypesDir, indexContent);
     logger.debug("Generated index types for virtual module", { indexTypesDir });
     const runtimeVirtualModulePath = resolveGeneratedPath("cache", {
       root: this.context.distDir,
@@ -307,8 +333,7 @@ declare module "ecopages:images" {
     const runtimeModuleContent = Object.entries(this.processedImages).map(([key, value]) => {
       return `export const ${anyCaseToCamelCase(key)} = ${JSON.stringify(value, null, 2)} as const;`;
     }).join("\n\n");
-    fileSystem.ensureDir(path.dirname(runtimeVirtualModulePath));
-    fileSystem.write(runtimeVirtualModulePath, runtimeModuleContent);
+    this.writeGeneratedFile(runtimeVirtualModulePath, runtimeModuleContent);
     logger.debug("Generated runtime virtual module for images", { runtimeVirtualModulePath });
   }
   /**