@yadimon/ng-smart-images 0.1.0 → 0.1.2

package/README.md

@@ -5,6 +5,7 @@
 ## What It Does
 
 - Generates hashed `avif`, `webp`, and original-format outputs.
+- Reuses unchanged generated assets when the source image and manifest config have not changed.
 - Writes a source manifest that you can keep in version control and extend over time.
 - Writes a generated runtime manifest plus helper wrapper for code-driven lookups.
 - Rewrites static `html` and `css` asset references in `dist/` to hashed URLs.

package/dist/core/generate.js

@@ -1,3 +1,5 @@
+import { constants } from 'node:fs';
+import { access, readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { loadProjectConfig, resolveEntryConfig } from './config.js';
 import { generateImageArtifact } from './optimize.js';
@@ -5,14 +7,32 @@ import { writeTextFile } from '../utils/fs.js';
 export async function generateHashedImages(options = {}) {
     const cwd = path.resolve(options.cwd ?? process.cwd());
     const { manifestPath, config } = await loadProjectConfig(cwd, options.manifestPath);
-    const runtimeManifest = {};
     const generatedAssetsDir = path.join(cwd, config.generatedAssetsDir);
     const assetsRootAbsolute = path.join(cwd, config.assetsRoot);
+    const runtimeManifestJsonPath = path.join(cwd, config.runtimeManifestJsonPath);
+    const runtimeManifestTsPath = path.join(cwd, config.runtimeManifestTsPath);
+    const runtimeHelperTsPath = path.join(cwd, config.runtimeHelperTsPath);
+    const runtimeManifest = {};
+    const previousRuntimeManifest = await loadRuntimeManifest(runtimeManifestJsonPath);
+    const runtimeManifestMtimeMs = await getFileModifiedTime(runtimeManifestJsonPath);
+    const projectManifestMtimeMs = await getFileModifiedTime(manifestPath);
     for (const sourceKey of Object.keys(config.images).sort()) {
         const resolvedEntry = resolveEntryConfig(sourceKey, config, cwd);
         if (!resolvedEntry) {
             continue;
         }
+        const reusableEntry = await tryReuseGeneratedEntry({
+            existingEntry: previousRuntimeManifest[sourceKey],
+            runtimeManifestMtimeMs,
+            projectManifestMtimeMs,
+            sourcePath: resolvedEntry.sourcePath,
+            outputRoot: generatedAssetsDir,
+            publicPath: config.publicPath,
+        });
+        if (reusableEntry) {
+            runtimeManifest[sourceKey] = reusableEntry;
+            continue;
+        }
         const artifact = await generateImageArtifact({
             sourceKey,
             sourcePath: resolvedEntry.sourcePath,
@@ -23,9 +43,6 @@ export async function generateHashedImages(options = {}) {
         });
         runtimeManifest[sourceKey] = artifact.entry;
     }
-    const runtimeManifestJsonPath = path.join(cwd, config.runtimeManifestJsonPath);
-    const runtimeManifestTsPath = path.join(cwd, config.runtimeManifestTsPath);
-    const runtimeHelperTsPath = path.join(cwd, config.runtimeHelperTsPath);
     await writeTextFile(runtimeManifestJsonPath, `${JSON.stringify(runtimeManifest, null, 2)}\n`);
     await writeTextFile(runtimeManifestTsPath, buildRuntimeManifestModule(runtimeManifest));
     await writeTextFile(runtimeHelperTsPath, buildRuntimeHelperModule(path.basename(runtimeManifestTsPath, '.ts')));
@@ -44,3 +61,75 @@ function buildRuntimeManifestModule(runtimeManifest) {
 function buildRuntimeHelperModule(runtimeManifestBaseName) {
     return `import manifest from './${runtimeManifestBaseName}.js';\nimport { createSmartImageResolver } from '@yadimon/ng-smart-images/runtime';\n\nconst resolver = createSmartImageResolver(manifest);\n\nexport const hashed = (path: string): string => resolver.hashed(path);\nexport const imageEntry = (path: string) => resolver.imageEntry(path);\nexport const imagePlaceholder = (path: string): string => resolver.imagePlaceholder(path);\nexport const imageSources = (path: string) => resolver.imageSources(path);\nexport const hasImage = (path: string): boolean => resolver.hasImage(path);\n\nexport default resolver;\n`;
 }
+async function tryReuseGeneratedEntry(input) {
+    if (!input.existingEntry || input.runtimeManifestMtimeMs === null) {
+        return null;
+    }
+    const sourceMtimeMs = await getFileModifiedTime(input.sourcePath);
+    if (sourceMtimeMs === null) {
+        return null;
+    }
+    const freshnessFloor = Math.max(sourceMtimeMs, input.projectManifestMtimeMs ?? 0);
+    if (input.runtimeManifestMtimeMs < freshnessFloor) {
+        return null;
+    }
+    const generatedFilesExist = await allGeneratedFilesExist(input.existingEntry, input.outputRoot, input.publicPath);
+    return generatedFilesExist ? input.existingEntry : null;
+}
+async function allGeneratedFilesExist(entry, outputRoot, publicPath) {
+    if (entry.sources.length === 0) {
+        return false;
+    }
+    for (const source of entry.sources) {
+        const generatedPath = resolveGeneratedPath(source.src, outputRoot, publicPath);
+        if (!generatedPath || !(await fileExists(generatedPath))) {
+            return false;
+        }
+    }
+    return true;
+}
+function resolveGeneratedPath(sourceSrc, outputRoot, publicPath) {
+    const normalizedPublicPath = normalizePublicPath(publicPath);
+    if (sourceSrc !== normalizedPublicPath && !sourceSrc.startsWith(`${normalizedPublicPath}/`)) {
+        return null;
+    }
+    const relativePath = sourceSrc.slice(normalizedPublicPath.length).replace(/^\/+/, '');
+    if (!relativePath) {
+        return null;
+    }
+    return path.join(outputRoot, relativePath);
+}
+function normalizePublicPath(publicPath) {
+    const trimmed = publicPath.replace(/\/+$/, '');
+    return trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+}
+async function loadRuntimeManifest(filePath) {
+    try {
+        const raw = await readFile(filePath, 'utf8');
+        if (!raw.trim()) {
+            return {};
+        }
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+async function getFileModifiedTime(filePath) {
+    try {
+        const fileStat = await stat(filePath);
+        return fileStat.mtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
+async function fileExists(filePath) {
+    try {
+        await access(filePath, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yadimon/ng-smart-images",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "CLI-first smart image optimization with hashed asset generation, runtime manifests, and optional Angular helpers.",
   "type": "module",
   "license": "MIT",
@@ -56,7 +56,8 @@
   },
   "scripts": {
     "build": "node ./scripts/build-package.mjs",
-    "pack": "node -e \"require('node:fs').mkdirSync('../../.artifacts', { recursive: true })\" && npm run build && npm pack --pack-destination ../../.artifacts",
+    "prepack": "npm run build",
+    "pack": "node ./scripts/pack-package.mjs",
     "lint": "eslint src tests scripts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "npm run build && vitest run",