@yadimon/ng-smart-images 0.1.3 → 0.2.1

package/README.md

@@ -5,7 +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.
+- Reuses unchanged generated assets through a fingerprint cache based on source content, normalized config, and package version.
 - 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.
@@ -68,6 +68,7 @@ Generates hashed files into `generatedAssetsDir` and writes:
 - `runtimeManifestJsonPath`
 - `runtimeManifestTsPath`
 - `runtimeHelperTsPath`
+- a sibling `.ng-smart-images.cache.json` file for build-time reuse decisions
 
 ```bash
 npx ng-smart-images generate-hashed
@@ -141,5 +142,5 @@ Repository-wide release guidance lives in [`RELEASING.md`](../../RELEASING.md).
 
 - keep the package on semver
 - use `npm run publish:dry-run` before a real publish
-- bump versions with the root `version:*` scripts
+- bump versions with the root `release:*` scripts
 - prefer GitHub trusted publishing once the repository is connected on npm

package/dist/core/generate.js

@@ -1,36 +1,54 @@
+import { createHash } from 'node:crypto';
 import { constants } from 'node:fs';
-import { access, readFile, stat } from 'node:fs/promises';
+import { access, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { loadProjectConfig, resolveEntryConfig } from './config.js';
 import { generateImageArtifact } from './optimize.js';
 import { writeTextFile } from '../utils/fs.js';
+const IMAGE_REUSE_CACHE_FILE_NAME = '.ng-smart-images.cache.json';
+const IMAGE_REUSE_CACHE_SCHEMA_VERSION = 1;
+let installedPackageVersionPromise = null;
 export async function generateHashedImages(options = {}) {
     const cwd = path.resolve(options.cwd ?? process.cwd());
     const { manifestPath, config } = await loadProjectConfig(cwd, options.manifestPath);
     const generatedAssetsDir = path.join(cwd, config.generatedAssetsDir);
     const assetsRootAbsolute = path.join(cwd, config.assetsRoot);
     const runtimeManifestJsonPath = path.join(cwd, config.runtimeManifestJsonPath);
+    const runtimeCacheJsonPath = path.join(path.dirname(runtimeManifestJsonPath), IMAGE_REUSE_CACHE_FILE_NAME);
     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);
+    const previousReuseCache = await loadReuseCache(runtimeCacheJsonPath);
+    const packageVersion = await getInstalledPackageVersion();
+    const runtimeReuseCache = {
+        schemaVersion: IMAGE_REUSE_CACHE_SCHEMA_VERSION,
+        packageVersion,
+        entries: {},
+    };
     for (const sourceKey of Object.keys(config.images).sort()) {
         const resolvedEntry = resolveEntryConfig(sourceKey, config, cwd);
         if (!resolvedEntry) {
             continue;
         }
+        const fingerprint = await createEntryFingerprint({
+            sourceKey,
+            sourcePath: resolvedEntry.sourcePath,
+            sizes: resolvedEntry.sizes,
+            quality: resolvedEntry.quality,
+            extensions: resolvedEntry.extensions,
+            packageVersion,
+        });
         const reusableEntry = await tryReuseGeneratedEntry({
             existingEntry: previousRuntimeManifest[sourceKey],
-            runtimeManifestMtimeMs,
-            projectManifestMtimeMs,
-            sourcePath: resolvedEntry.sourcePath,
+            cacheEntry: previousReuseCache.entries[sourceKey],
+            fingerprint,
             outputRoot: generatedAssetsDir,
             publicPath: config.publicPath,
         });
         if (reusableEntry) {
             runtimeManifest[sourceKey] = reusableEntry;
+            runtimeReuseCache.entries[sourceKey] = { fingerprint };
             continue;
         }
         const artifact = await generateImageArtifact({
@@ -42,13 +60,16 @@ export async function generateHashedImages(options = {}) {
             entryConfig: resolvedEntry,
         });
         runtimeManifest[sourceKey] = artifact.entry;
+        runtimeReuseCache.entries[sourceKey] = { fingerprint };
     }
     await writeTextFile(runtimeManifestJsonPath, `${JSON.stringify(runtimeManifest, null, 2)}\n`);
+    await writeTextFile(runtimeCacheJsonPath, `${JSON.stringify(runtimeReuseCache, null, 2)}\n`);
     await writeTextFile(runtimeManifestTsPath, buildRuntimeManifestModule(runtimeManifest));
     await writeTextFile(runtimeHelperTsPath, buildRuntimeHelperModule(path.basename(runtimeManifestTsPath, '.ts')));
     return {
         manifestPath,
         runtimeManifestJsonPath,
+        runtimeCacheJsonPath,
         runtimeManifestTsPath,
         runtimeHelperTsPath,
         generatedAssetsDir,
@@ -62,15 +83,10 @@ 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) {
+    if (!input.existingEntry || !input.cacheEntry) {
         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) {
+    if (input.cacheEntry.fingerprint !== input.fingerprint) {
         return null;
     }
     const generatedFilesExist = await allGeneratedFilesExist(input.existingEntry, input.outputRoot, input.publicPath);
@@ -115,13 +131,27 @@ async function loadRuntimeManifest(filePath) {
         return {};
     }
 }
-async function getFileModifiedTime(filePath) {
+async function loadReuseCache(filePath) {
     try {
-        const fileStat = await stat(filePath);
-        return fileStat.mtimeMs;
+        const raw = await readFile(filePath, 'utf8');
+        if (!raw.trim()) {
+            return createEmptyReuseCache();
+        }
+        const parsed = JSON.parse(raw);
+        if (parsed.schemaVersion !== IMAGE_REUSE_CACHE_SCHEMA_VERSION) {
+            return createEmptyReuseCache();
+        }
+        const entries = Object.fromEntries(Object.entries(parsed.entries ?? {}).flatMap(([sourceKey, value]) => value && typeof value.fingerprint === 'string'
+            ? [[sourceKey, { fingerprint: value.fingerprint }]]
+            : []));
+        return {
+            schemaVersion: IMAGE_REUSE_CACHE_SCHEMA_VERSION,
+            packageVersion: typeof parsed.packageVersion === 'string' ? parsed.packageVersion : '',
+            entries,
+        };
     }
     catch {
-        return null;
+        return createEmptyReuseCache();
     }
 }
 async function fileExists(filePath) {
@@ -133,3 +163,32 @@ async function fileExists(filePath) {
         return false;
     }
 }
+function createEmptyReuseCache() {
+    return {
+        schemaVersion: IMAGE_REUSE_CACHE_SCHEMA_VERSION,
+        packageVersion: '',
+        entries: {},
+    };
+}
+async function createEntryFingerprint(input) {
+    const sourceBytes = await readFile(input.sourcePath);
+    const sourceHash = createHash('sha256').update(sourceBytes).digest('hex');
+    return createHash('sha256')
+        .update(JSON.stringify({
+        sourceHash,
+        sourceKey: input.sourceKey,
+        entryConfig: {
+            sizes: input.sizes,
+            quality: input.quality,
+            extensions: input.extensions,
+        },
+        packageVersion: input.packageVersion,
+    }))
+        .digest('hex');
+}
+async function getInstalledPackageVersion() {
+    installedPackageVersionPromise ??= readFile(new URL('../../package.json', import.meta.url), 'utf8')
+        .then((raw) => JSON.parse(raw))
+        .then((pkg) => (typeof pkg.version === 'string' ? pkg.version : '0.0.0'));
+    return installedPackageVersionPromise;
+}

package/dist/core/types.d.ts

@@ -44,11 +44,20 @@ export interface GenerateHashedOptions {
 export interface GeneratedProjectArtifacts {
     manifestPath: string;
     runtimeManifestJsonPath: string;
+    runtimeCacheJsonPath: string;
     runtimeManifestTsPath: string;
     runtimeHelperTsPath: string;
     generatedAssetsDir: string;
     runtimeManifest: SmartImagesManifest;
 }
+export interface SmartImageReuseCacheEntry {
+    fingerprint: string;
+}
+export interface SmartImageReuseCache {
+    schemaVersion: number;
+    packageVersion: string;
+    entries: Record<string, SmartImageReuseCacheEntry>;
+}
 export interface UpdateBundleOptions {
     cwd?: string;
     manifestPath?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yadimon/ng-smart-images",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "CLI-first smart image optimization with hashed asset generation, runtime manifests, and optional Angular helpers.",
   "type": "module",
   "license": "MIT",
@@ -66,7 +66,7 @@
   "dependencies": {
     "picomatch": "^4.0.3",
     "sharp": "^0.34.5",
-    "tinyglobby": "^0.2.15"
+    "tinyglobby": "^0.2.16"
   },
   "peerDependencies": {
     "@angular/core": "^20.0.0 || ^21.0.0 || ^22.0.0"
@@ -77,10 +77,10 @@
     }
   },
   "devDependencies": {
-    "@angular/core": "^21.2.0",
-    "@types/node": "^25.5.0",
-    "@types/picomatch": "^4.0.2",
+    "@angular/core": "^21.2.9",
+    "@types/node": "^25.6.0",
+    "@types/picomatch": "^4.0.3",
     "typescript": "~5.9.3",
-    "vitest": "^4.0.8"
+    "vitest": "^4.1.4"
   }
 }