@yadimon/ng-smart-images 0.1.0

package/README.md

@@ -0,0 +1,144 @@
+# @yadimon/ng-smart-images
+
+`@yadimon/ng-smart-images` is a CLI-first image optimization tool for Angular and other frontend builds. It generates hashed local image variants, writes a runtime manifest, and can rewrite built HTML and CSS to hashed asset URLs after your normal build finishes.
+
+## What It Does
+
+- Generates hashed `avif`, `webp`, and original-format outputs.
+- 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.
+- Keeps defaults lightweight: `sizes`, `quality`, `extension(s)`, and `ignore`.
+
+## Install
+
+```bash
+npm install @yadimon/ng-smart-images
+```
+
+## Source Manifest
+
+Create a `smart-images.manifest.json` file in your app root.
+
+```json
+{
+  "assetsRoot": "src/assets",
+  "generatedAssetsDir": "src/assets/ng-smart-images",
+  "publicPath": "/assets/ng-smart-images",
+  "runtimeManifestJsonPath": "src/app/generated/ng-smart-images.manifest.json",
+  "runtimeManifestTsPath": "src/app/generated/ng-smart-images.manifest.ts",
+  "runtimeHelperTsPath": "src/app/generated/ng-smart-images.runtime.ts",
+  "ignore": ["src/assets/archive/**", "src/assets/ng-smart-images/**"],
+  "defaults": {
+    "extensions": ["avif", "webp", "original"],
+    "quality": 76,
+    "sizes": []
+  },
+  "images": {
+    "src/assets/landing/hero.webp": {
+      "sizes": [640, 960, 1408]
+    },
+    "src/assets/providers/logo.png": {
+      "extensions": ["webp", "original"]
+    },
+    "src/assets/legacy/old-banner.jpg": {
+      "ignore": true
+    }
+  }
+}
+```
+
+## CLI Commands
+
+### Sync Manifest
+
+Scans `assetsRoot` and adds missing image entries without deleting existing config.
+
+```bash
+npx ng-smart-images sync-manifest
+```
+
+If you want a full refresh, delete `smart-images.manifest.json` and run the command again.
+
+### Generate Hashed Assets
+
+Generates hashed files into `generatedAssetsDir` and writes:
+
+- `runtimeManifestJsonPath`
+- `runtimeManifestTsPath`
+- `runtimeHelperTsPath`
+
+```bash
+npx ng-smart-images generate-hashed
+```
+
+### Update Bundle
+
+Runs after your normal build and rewrites static `html` and `css` references in `dist`.
+
+```bash
+npx ng-smart-images update-bundle --dist dist/app/browser
+```
+
+## Suggested Angular Scripts
+
+Keep Angular on the standard builders and add the image steps around it:
+
+```json
+{
+  "scripts": {
+    "smart-images:sync-manifest": "npx ng-smart-images sync-manifest",
+    "smart-images:generate": "npx ng-smart-images generate-hashed",
+    "smart-images:update-bundle": "npx ng-smart-images update-bundle --dist dist/app/browser",
+    "build": "npm run smart-images:generate && ng build && npm run smart-images:update-bundle",
+    "start": "npm run smart-images:generate && ng serve"
+  }
+}
+```
+
+## Runtime Helper
+
+After `generate-hashed`, import the generated helper from your app:
+
+```ts
+import { hashed, imageEntry } from './generated/ng-smart-images.runtime';
+
+const heroUrl = hashed('src/assets/landing/hero.webp');
+const heroEntry = imageEntry('src/assets/landing/hero.webp');
+```
+
+Behavior:
+
+- known image in the generated manifest: returns the hashed URL
+- missing image or missing manifest entry: falls back to the original `/assets/...` path
+
+## Angular Wrapper
+
+The package also exports an optional Angular wrapper layer:
+
+```ts
+import { provideSmartImages } from '@yadimon/ng-smart-images/angular';
+import manifest from './generated/ng-smart-images.manifest';
+
+providers: [provideSmartImages(manifest)];
+```
+
+You can then inject `SmartImagesService` if you prefer DI over direct helper functions.
+
+## Development
+
+From the repository root:
+
+```bash
+npm install
+npm run verify
+```
+
+## Release Notes For Maintainers
+
+Repository-wide release guidance lives in [`RELEASING.md`](../../RELEASING.md). The short version:
+
+- keep the package on semver
+- use `npm run publish:dry-run` before a real publish
+- bump versions with the root `version:*` scripts
+- prefer GitHub trusted publishing once the repository is connected on npm

package/dist/angular/index.d.ts

@@ -0,0 +1,18 @@
+import { InjectionToken, type ModuleWithProviders, type Provider } from '@angular/core';
+import type { SmartImagesManifest } from '../runtime/manifest.js';
+import { type SmartImageFormat, type SmartImageSource } from '../runtime/index.js';
+export declare const SMART_IMAGES_MANIFEST: InjectionToken<SmartImagesManifest>;
+export declare function provideSmartImages(manifest: SmartImagesManifest): Provider[];
+export declare class SmartImagesService {
+    private readonly manifest;
+    private readonly resolver;
+    constructor();
+    hasImage(path: string): boolean;
+    hashed(path: string): string;
+    imageEntry(path: string): import("../runtime/manifest.js").SmartImageEntry | null;
+    imagePlaceholder(path: string): string;
+    imageSources(path: string, format?: SmartImageFormat): SmartImageSource[];
+}
+export declare class SmartImagesModule {
+    static forManifest(manifest: SmartImagesManifest): ModuleWithProviders<SmartImagesModule>;
+}

package/dist/angular/index.js

@@ -0,0 +1,105 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { inject, Injectable, InjectionToken, NgModule, } from '@angular/core';
+import { EMPTY_SMART_IMAGES_MANIFEST } from '../runtime/manifest.js';
+import { createSmartImageResolver, } from '../runtime/index.js';
+export const SMART_IMAGES_MANIFEST = new InjectionToken('SMART_IMAGES_MANIFEST', {
+    factory: () => EMPTY_SMART_IMAGES_MANIFEST,
+});
+export function provideSmartImages(manifest) {
+    return [{ provide: SMART_IMAGES_MANIFEST, useValue: manifest }];
+}
+let SmartImagesService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var SmartImagesService = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            SmartImagesService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        manifest = inject(SMART_IMAGES_MANIFEST);
+        resolver;
+        constructor() {
+            this.resolver = createSmartImageResolver(this.manifest);
+        }
+        hasImage(path) {
+            return this.resolver.hasImage(path);
+        }
+        hashed(path) {
+            return this.resolver.hashed(path);
+        }
+        imageEntry(path) {
+            return this.resolver.imageEntry(path);
+        }
+        imagePlaceholder(path) {
+            return this.resolver.imagePlaceholder(path);
+        }
+        imageSources(path, format) {
+            return this.resolver.imageSources(path, format);
+        }
+    };
+    return SmartImagesService = _classThis;
+})();
+export { SmartImagesService };
+let SmartImagesModule = (() => {
+    let _classDecorators = [NgModule({})];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var SmartImagesModule = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            SmartImagesModule = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        static forManifest(manifest) {
+            return {
+                ngModule: SmartImagesModule,
+                providers: provideSmartImages(manifest),
+            };
+        }
+    };
+    return SmartImagesModule = _classThis;
+})();
+export { SmartImagesModule };

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { generateHashedImages } from './core/generate.js';
+import { syncProjectManifest } from './core/manifest-sync.js';
+import { updateBundle } from './core/update-bundle.js';
+async function main() {
+    const parsed = parseArgs(process.argv.slice(2));
+    switch (parsed.command) {
+        case 'sync-manifest': {
+            const result = await syncProjectManifest({
+                cwd: parsed.flags.cwd,
+                manifestPath: parsed.flags.manifest,
+            });
+            console.log(`synced ${result.added.length} image entries into ${relativeOrAbsolute(result.manifestPath)}`);
+            return;
+        }
+        case 'generate-hashed': {
+            const result = await generateHashedImages({
+                cwd: parsed.flags.cwd,
+                manifestPath: parsed.flags.manifest,
+            });
+            console.log(`generated ${Object.keys(result.runtimeManifest).length} hashed image entries into ${relativeOrAbsolute(result.generatedAssetsDir)}`);
+            return;
+        }
+        case 'update-bundle': {
+            const distPath = parsed.flags.dist;
+            if (!distPath) {
+                throw new Error('Missing required --dist argument for update-bundle.');
+            }
+            const result = await updateBundle({
+                cwd: parsed.flags.cwd,
+                manifestPath: parsed.flags.manifest,
+                distPath,
+            });
+            console.log(`updated ${result.updatedFiles.length} bundle files and generated ${result.generated.length} additional images`);
+            return;
+        }
+        default:
+            printHelp();
+            process.exitCode = parsed.command ? 1 : 0;
+    }
+}
+function parseArgs(args) {
+    const [command = '', ...rest] = args;
+    const flags = {};
+    for (let index = 0; index < rest.length; index += 1) {
+        const value = rest[index];
+        if (!value.startsWith('--')) {
+            continue;
+        }
+        const key = value.slice('--'.length);
+        const nextValue = rest[index + 1];
+        if (nextValue && !nextValue.startsWith('--')) {
+            flags[key] = nextValue;
+            index += 1;
+        }
+        else {
+            flags[key] = 'true';
+        }
+    }
+    return {
+        command,
+        flags,
+    };
+}
+function relativeOrAbsolute(value) {
+    const cwd = process.cwd();
+    const relative = path.relative(cwd, value);
+    return relative && !relative.startsWith('..') ? relative : value;
+}
+function printHelp() {
+    console.log(`ng-smart-images
+
+Usage:
+  ng-smart-images sync-manifest [--manifest smart-images.manifest.json] [--cwd path]
+  ng-smart-images generate-hashed [--manifest smart-images.manifest.json] [--cwd path]
+  ng-smart-images update-bundle --dist dist/app/browser [--manifest smart-images.manifest.json] [--cwd path]
+`);
+}
+void main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exitCode = 1;
+});

package/dist/core/config.d.ts

@@ -0,0 +1,9 @@
+import type { SmartImageProjectManifest, SmartImageResolvedConfig, SmartImageResolvedEntry } from './types.js';
+export interface LoadedConfig {
+    manifestPath: string;
+    config: SmartImageResolvedConfig;
+}
+export declare function loadProjectConfig(cwd: string, manifestPathInput?: string): Promise<LoadedConfig>;
+export declare function saveProjectManifest(manifestPath: string, config: SmartImageProjectManifest): Promise<void>;
+export declare function resolveEntryConfig(sourceKey: string, config: SmartImageResolvedConfig, cwd: string): SmartImageResolvedEntry | null;
+export declare function createDefaultProjectManifest(): SmartImageProjectManifest;

package/dist/core/config.js

@@ -0,0 +1,130 @@
+import { access, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { constants } from 'node:fs';
+import { normalizeSourceKey } from './discovery.js';
+import { toPosixPath, writeTextFile } from '../utils/fs.js';
+const DEFAULT_MANIFEST_FILE = 'smart-images.manifest.json';
+const DEFAULT_PUBLIC_PATH = '/assets/ng-smart-images';
+const DEFAULT_ASSETS_ROOT = 'src/assets';
+const DEFAULT_GENERATED_ASSETS_DIR = 'src/assets/ng-smart-images';
+const DEFAULT_RUNTIME_MANIFEST_JSON = 'src/app/generated/ng-smart-images.manifest.json';
+const DEFAULT_RUNTIME_MANIFEST_TS = 'src/app/generated/ng-smart-images.manifest.ts';
+const DEFAULT_RUNTIME_HELPER_TS = 'src/app/generated/ng-smart-images.runtime.ts';
+const DEFAULT_QUALITY = 76;
+const DEFAULT_EXTENSIONS = ['avif', 'webp', 'original'];
+export async function loadProjectConfig(cwd, manifestPathInput) {
+    const manifestPath = resolveManifestPath(cwd, manifestPathInput);
+    const raw = await readProjectManifest(manifestPath);
+    const config = {
+        assetsRoot: normalizeProjectPath(raw.assetsRoot ?? DEFAULT_ASSETS_ROOT),
+        generatedAssetsDir: normalizeProjectPath(raw.generatedAssetsDir ?? DEFAULT_GENERATED_ASSETS_DIR),
+        publicPath: normalizePublicPath(raw.publicPath ?? DEFAULT_PUBLIC_PATH),
+        runtimeManifestJsonPath: normalizeProjectPath(raw.runtimeManifestJsonPath ?? DEFAULT_RUNTIME_MANIFEST_JSON),
+        runtimeManifestTsPath: normalizeProjectPath(raw.runtimeManifestTsPath ?? DEFAULT_RUNTIME_MANIFEST_TS),
+        runtimeHelperTsPath: normalizeProjectPath(raw.runtimeHelperTsPath ?? DEFAULT_RUNTIME_HELPER_TS),
+        ignore: normalizeIgnore(raw.ignore ?? [], raw.generatedAssetsDir ?? DEFAULT_GENERATED_ASSETS_DIR),
+        defaults: {
+            ignore: false,
+            sizes: normalizeSizes(raw.defaults?.sizes),
+            quality: normalizeQuality(raw.defaults?.quality),
+            extensions: normalizeExtensions(raw.defaults),
+        },
+        images: normalizeImageConfigMap(raw.images ?? {}, cwd),
+    };
+    return {
+        manifestPath,
+        config,
+    };
+}
+export async function saveProjectManifest(manifestPath, config) {
+    await writeTextFile(manifestPath, `${JSON.stringify(config, null, 2)}\n`);
+}
+export function resolveEntryConfig(sourceKey, config, cwd) {
+    const normalizedKey = normalizeSourceKey(sourceKey, cwd);
+    const entry = config.images[normalizedKey];
+    if (entry?.ignore) {
+        return null;
+    }
+    return {
+        sourceKey: normalizedKey,
+        sourcePath: path.join(cwd, normalizedKey),
+        sizes: normalizeSizes(entry?.sizes, config.defaults.sizes),
+        quality: normalizeQuality(entry?.quality, config.defaults.quality),
+        extensions: normalizeExtensions(entry, config.defaults.extensions),
+    };
+}
+export function createDefaultProjectManifest() {
+    return {
+        assetsRoot: DEFAULT_ASSETS_ROOT,
+        generatedAssetsDir: DEFAULT_GENERATED_ASSETS_DIR,
+        publicPath: DEFAULT_PUBLIC_PATH,
+        runtimeManifestJsonPath: DEFAULT_RUNTIME_MANIFEST_JSON,
+        runtimeManifestTsPath: DEFAULT_RUNTIME_MANIFEST_TS,
+        runtimeHelperTsPath: DEFAULT_RUNTIME_HELPER_TS,
+        ignore: ['src/assets/archive/**', 'src/assets/ng-smart-images/**'],
+        defaults: {
+            quality: DEFAULT_QUALITY,
+            extensions: [...DEFAULT_EXTENSIONS],
+            sizes: [],
+        },
+        images: {},
+    };
+}
+async function readProjectManifest(manifestPath) {
+    try {
+        await access(manifestPath, constants.F_OK);
+    }
+    catch {
+        return createDefaultProjectManifest();
+    }
+    const raw = await readFile(manifestPath, 'utf8');
+    if (!raw.trim()) {
+        return createDefaultProjectManifest();
+    }
+    return JSON.parse(raw);
+}
+function resolveManifestPath(cwd, manifestPathInput) {
+    return path.resolve(cwd, manifestPathInput ?? DEFAULT_MANIFEST_FILE);
+}
+function normalizeProjectPath(value) {
+    return toPosixPath(value).replace(/^\.\/+/, '');
+}
+function normalizePublicPath(value) {
+    const normalized = normalizeProjectPath(value);
+    return normalized.startsWith('/') ? normalized : `/${normalized}`;
+}
+function normalizeIgnore(values, generatedAssetsDir) {
+    return Array.from(new Set([
+        ...values,
+        normalizeProjectPath(generatedAssetsDir),
+        `${normalizeProjectPath(generatedAssetsDir)}/**`,
+    ]
+        .map((value) => normalizeProjectPath(value))
+        .filter((value) => value.length > 0)));
+}
+function normalizeImageConfigMap(input, cwd) {
+    return Object.fromEntries(Object.entries(input).map(([key, value]) => [normalizeSourceKey(key, cwd), value]));
+}
+function normalizeSizes(input, fallback = []) {
+    if (!Array.isArray(input) || input.length === 0) {
+        return [...fallback];
+    }
+    return Array.from(new Set(input.filter((value) => Number.isFinite(value) && value > 0))).sort((left, right) => left - right);
+}
+function normalizeQuality(input, fallback = DEFAULT_QUALITY) {
+    if (typeof input !== 'number' || !Number.isFinite(input)) {
+        return fallback;
+    }
+    return Math.max(1, Math.min(100, Math.round(input)));
+}
+function normalizeExtensions(input, fallback = DEFAULT_EXTENSIONS) {
+    const source = Array.isArray(input?.extensions)
+        ? input.extensions
+        : input?.extension
+            ? Array.isArray(input.extension)
+                ? input.extension
+                : [input.extension]
+            : fallback;
+    const normalized = source.filter((value) => value === 'avif' || value === 'webp' || value === 'original');
+    return normalized.length > 0 ? Array.from(new Set(normalized)) : [...fallback];
+}

package/dist/core/discovery.d.ts

@@ -0,0 +1,5 @@
+export declare function isSupportedImagePath(value: string): boolean;
+export declare function normalizeSourceKey(value: string, cwd: string): string;
+export declare function isIgnored(value: string, ignorePatterns: string[]): boolean;
+export declare function resolveAssetUrlToSourceKey(assetUrl: string, assetsRoot: string, cwd: string): string | null;
+export declare function isStaticLocalAssetReference(value: string): boolean;

package/dist/core/discovery.js

@@ -0,0 +1,38 @@
+import path from 'node:path';
+import picomatch from 'picomatch';
+import { toPosixPath } from '../utils/fs.js';
+const IMAGE_EXTENSION_PATTERN = /\.(avif|gif|jpe?g|png|webp)$/i;
+export function isSupportedImagePath(value) {
+    return IMAGE_EXTENSION_PATTERN.test(value);
+}
+export function normalizeSourceKey(value, cwd) {
+    const normalized = toPosixPath(path.isAbsolute(value) ? path.relative(cwd, value) : value);
+    return normalized.replace(/^\.\/+/, '');
+}
+export function isIgnored(value, ignorePatterns) {
+    const normalized = toPosixPath(value);
+    return ignorePatterns.some((pattern) => picomatch(pattern)(normalized));
+}
+export function resolveAssetUrlToSourceKey(assetUrl, assetsRoot, cwd) {
+    const normalized = assetUrl.trim();
+    if (!isStaticLocalAssetReference(normalized)) {
+        return null;
+    }
+    const relativeAssetPath = normalized
+        .replace(/^\/+/, '')
+        .replace(/^assets\//, '')
+        .replace(/^\/assets\//, '');
+    return normalizeSourceKey(path.join(assetsRoot, relativeAssetPath), cwd);
+}
+export function isStaticLocalAssetReference(value) {
+    if (!value || value.includes('{{')) {
+        return false;
+    }
+    if (/^(https?:)?\/\//i.test(value)) {
+        return false;
+    }
+    if (/^(data:|blob:|#)/i.test(value)) {
+        return false;
+    }
+    return isSupportedImagePath(value);
+}

package/dist/core/generate.d.ts

@@ -0,0 +1,2 @@
+import type { GenerateHashedOptions, GeneratedProjectArtifacts } from './types.js';
+export declare function generateHashedImages(options?: GenerateHashedOptions): Promise<GeneratedProjectArtifacts>;

package/dist/core/generate.js

@@ -0,0 +1,46 @@
+import path from 'node:path';
+import { loadProjectConfig, resolveEntryConfig } from './config.js';
+import { generateImageArtifact } from './optimize.js';
+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);
+    for (const sourceKey of Object.keys(config.images).sort()) {
+        const resolvedEntry = resolveEntryConfig(sourceKey, config, cwd);
+        if (!resolvedEntry) {
+            continue;
+        }
+        const artifact = await generateImageArtifact({
+            sourceKey,
+            sourcePath: resolvedEntry.sourcePath,
+            sourceRootPath: assetsRootAbsolute,
+            publicPath: config.publicPath,
+            outputRoot: generatedAssetsDir,
+            entryConfig: resolvedEntry,
+        });
+        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')));
+    return {
+        manifestPath,
+        runtimeManifestJsonPath,
+        runtimeManifestTsPath,
+        runtimeHelperTsPath,
+        generatedAssetsDir,
+        runtimeManifest,
+    };
+}
+function buildRuntimeManifestModule(runtimeManifest) {
+    return `import type { SmartImagesManifest } from '@yadimon/ng-smart-images/runtime';\n\nconst manifest: SmartImagesManifest = ${JSON.stringify(runtimeManifest, null, 2)};\n\nexport default manifest;\n`;
+}
+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`;
+}

package/dist/core/manifest-sync.d.ts

@@ -0,0 +1,5 @@
+import type { GenerateHashedOptions } from './types.js';
+export declare function syncProjectManifest(options?: GenerateHashedOptions): Promise<{
+    manifestPath: string;
+    added: string[];
+}>;

package/dist/core/manifest-sync.js

@@ -0,0 +1,45 @@
+import path from 'node:path';
+import { loadProjectConfig, saveProjectManifest } from './config.js';
+import { isIgnored, isSupportedImagePath, normalizeSourceKey } from './discovery.js';
+import { listFilesRecursive } from '../utils/fs.js';
+export async function syncProjectManifest(options = {}) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const { manifestPath, config } = await loadProjectConfig(cwd, options.manifestPath);
+    const assetsRootAbsolute = path.join(cwd, config.assetsRoot);
+    const assetFiles = await listFilesRecursive(assetsRootAbsolute);
+    const existingImages = { ...config.images };
+    const added = [];
+    for (const assetFile of assetFiles) {
+        const normalizedKey = normalizeSourceKey(assetFile, cwd);
+        if (!isSupportedImagePath(normalizedKey)) {
+            continue;
+        }
+        if (isIgnored(normalizedKey, config.ignore)) {
+            continue;
+        }
+        if (!(normalizedKey in existingImages)) {
+            existingImages[normalizedKey] = {};
+            added.push(normalizedKey);
+        }
+    }
+    const sourceManifest = {
+        assetsRoot: config.assetsRoot,
+        generatedAssetsDir: config.generatedAssetsDir,
+        publicPath: config.publicPath,
+        runtimeManifestJsonPath: config.runtimeManifestJsonPath,
+        runtimeManifestTsPath: config.runtimeManifestTsPath,
+        runtimeHelperTsPath: config.runtimeHelperTsPath,
+        ignore: [...config.ignore],
+        defaults: {
+            quality: config.defaults.quality,
+            sizes: [...config.defaults.sizes],
+            extensions: [...config.defaults.extensions],
+        },
+        images: Object.fromEntries(Object.entries(existingImages).sort(([left], [right]) => left.localeCompare(right))),
+    };
+    await saveProjectManifest(manifestPath, sourceManifest);
+    return {
+        manifestPath,
+        added,
+    };
+}

package/dist/core/optimize.d.ts

@@ -0,0 +1,13 @@
+import type { SmartImagesManifest } from '../runtime/manifest.js';
+import type { SmartImageResolvedEntry } from './types.js';
+export interface GeneratedImageArtifact {
+    entry: SmartImagesManifest[string];
+}
+export declare function generateImageArtifact(input: {
+    sourceKey: string;
+    sourcePath: string;
+    sourceRootPath: string;
+    publicPath: string;
+    outputRoot: string;
+    entryConfig: SmartImageResolvedEntry;
+}): Promise<GeneratedImageArtifact>;

package/dist/core/optimize.js

@@ -0,0 +1,114 @@
+import { createHash } from 'node:crypto';
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import sharp from 'sharp';
+import { toPosixPath } from '../utils/fs.js';
+export async function generateImageArtifact(input) {
+    const metadata = await sharp(input.sourcePath, { failOn: 'error' }).metadata();
+    if (!metadata.width || !metadata.height || !metadata.format) {
+        throw new Error(`Cannot determine image metadata for ${input.sourcePath}`);
+    }
+    const outputWidths = normalizeOutputWidths(input.entryConfig.sizes, metadata.width);
+    const relativeSourcePath = toPosixPath(path.relative(input.sourceRootPath, input.sourcePath));
+    const relativeDir = path.dirname(relativeSourcePath) === '.' ? '' : path.dirname(relativeSourcePath);
+    const baseName = path.parse(relativeSourcePath).name;
+    const originalExtension = metadata.format === 'jpeg' ? 'jpg' : metadata.format;
+    const sources = [];
+    const generatedOutputExtensions = new Set();
+    for (const extension of input.entryConfig.extensions) {
+        const effectiveExtension = extension === 'original' ? (originalExtension ?? 'png') : extension;
+        if (generatedOutputExtensions.has(effectiveExtension)) {
+            continue;
+        }
+        const generatedSources = await buildSourcesForExtension({
+            extension,
+            widths: outputWidths,
+            quality: input.entryConfig.quality,
+            sourcePath: input.sourcePath,
+            relativeDir,
+            baseName,
+            outputRoot: input.outputRoot,
+            publicPath: input.publicPath,
+        });
+        sources.push(...generatedSources);
+        generatedOutputExtensions.add(effectiveExtension);
+    }
+    const fallbackSrc = pickFirstSourceByFormat(sources, 'original')?.src ??
+        pickFirstSourceByFormat(sources, 'webp')?.src ??
+        sources[0]?.src ??
+        '';
+    return {
+        entry: {
+            key: input.sourceKey,
+            originalPath: input.sourceKey,
+            width: metadata.width,
+            height: metadata.height,
+            fallbackSrc,
+            placeholderDataUrl: '',
+            sources,
+        },
+    };
+}
+async function buildSourcesForExtension(input) {
+    const metadata = await sharp(input.sourcePath, { failOn: 'error' }).metadata();
+    const originalExtension = metadata.format === 'jpeg' ? 'jpg' : (metadata.format ?? 'png');
+    const outputs = [];
+    for (const width of input.widths) {
+        const transformer = sharp(input.sourcePath, { failOn: 'error' }).resize({
+            width,
+            withoutEnlargement: true,
+        });
+        let fileExtension = originalExtension;
+        let buffer;
+        if (input.extension === 'avif') {
+            fileExtension = 'avif';
+            buffer = await transformer.avif({ quality: input.quality }).toBuffer();
+        }
+        else if (input.extension === 'webp') {
+            fileExtension = 'webp';
+            buffer = await transformer.webp({ quality: input.quality }).toBuffer();
+        }
+        else {
+            buffer = await toOriginalFormatBuffer(transformer, fileExtension, input.quality);
+        }
+        const hash = createHash('sha256').update(buffer).digest('hex').slice(0, 10);
+        const widthSuffix = width > 0 ? `-${width}` : '';
+        const fileName = `${input.baseName}${widthSuffix}-${hash}.${fileExtension}`;
+        const targetPath = path.join(input.outputRoot, input.relativeDir, fileName);
+        await mkdir(path.dirname(targetPath), { recursive: true });
+        await writeFile(targetPath, buffer);
+        outputs.push({
+            format: input.extension,
+            width,
+            src: `${input.publicPath}/${toPosixPath(path.posix.join(input.relativeDir, fileName)).replace(/^\/+/, '')}`,
+        });
+    }
+    return outputs;
+}
+async function toOriginalFormatBuffer(transformer, extension, quality) {
+    switch (extension) {
+        case 'jpg':
+        case 'jpeg':
+            return transformer.jpeg({ quality }).toBuffer();
+        case 'png':
+            return transformer.png({ quality }).toBuffer();
+        case 'webp':
+            return transformer.webp({ quality }).toBuffer();
+        case 'avif':
+            return transformer.avif({ quality }).toBuffer();
+        default:
+            return transformer.toFormat(extension).toBuffer();
+    }
+}
+function normalizeOutputWidths(configuredSizes, sourceWidth) {
+    const filtered = configuredSizes.filter((value) => value > 0 && value <= sourceWidth);
+    if (filtered.length === 0) {
+        return [sourceWidth];
+    }
+    return Array.from(new Set(filtered)).sort((left, right) => left - right);
+}
+function pickFirstSourceByFormat(sources, format) {
+    return ([...sources]
+        .filter((entry) => entry.format === format)
+        .sort((left, right) => right.width - left.width)[0] ?? null);
+}

package/dist/core/types.d.ts

@@ -0,0 +1,56 @@
+import type { SmartImageFormat, SmartImagesManifest } from '../runtime/manifest.js';
+export interface SmartImageConfigEntry {
+    ignore?: boolean;
+    sizes?: number[];
+    quality?: number;
+    extension?: SmartImageFormat | SmartImageFormat[];
+    extensions?: SmartImageFormat[];
+}
+export interface SmartImageProjectManifest {
+    assetsRoot?: string;
+    generatedAssetsDir?: string;
+    publicPath?: string;
+    runtimeManifestJsonPath?: string;
+    runtimeManifestTsPath?: string;
+    runtimeHelperTsPath?: string;
+    ignore?: string[];
+    defaults?: SmartImageConfigEntry;
+    images?: Record<string, SmartImageConfigEntry>;
+}
+export interface SmartImageResolvedConfig {
+    assetsRoot: string;
+    generatedAssetsDir: string;
+    publicPath: string;
+    runtimeManifestJsonPath: string;
+    runtimeManifestTsPath: string;
+    runtimeHelperTsPath: string;
+    ignore: string[];
+    defaults: Required<Pick<SmartImageConfigEntry, 'sizes' | 'quality' | 'extensions'>> & {
+        ignore: false;
+    };
+    images: Record<string, SmartImageConfigEntry>;
+}
+export interface SmartImageResolvedEntry {
+    sourceKey: string;
+    sourcePath: string;
+    sizes: number[];
+    quality: number;
+    extensions: SmartImageFormat[];
+}
+export interface GenerateHashedOptions {
+    cwd?: string;
+    manifestPath?: string;
+}
+export interface GeneratedProjectArtifacts {
+    manifestPath: string;
+    runtimeManifestJsonPath: string;
+    runtimeManifestTsPath: string;
+    runtimeHelperTsPath: string;
+    generatedAssetsDir: string;
+    runtimeManifest: SmartImagesManifest;
+}
+export interface UpdateBundleOptions {
+    cwd?: string;
+    manifestPath?: string;
+    distPath: string;
+}

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/update-bundle.d.ts

@@ -0,0 +1,5 @@
+import type { UpdateBundleOptions } from './types.js';
+export declare function updateBundle(options: UpdateBundleOptions): Promise<{
+    updatedFiles: string[];
+    generated: string[];
+}>;

package/dist/core/update-bundle.js

@@ -0,0 +1,120 @@
+import { access, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { constants } from 'node:fs';
+import { loadProjectConfig, resolveEntryConfig } from './config.js';
+import { generateImageArtifact } from './optimize.js';
+import { isStaticLocalAssetReference, normalizeSourceKey, resolveAssetUrlToSourceKey, } from './discovery.js';
+import { listFilesRecursive, writeTextFile } from '../utils/fs.js';
+const OUTPUT_FILE_PATTERN = /\.(css|html)$/i;
+export async function updateBundle(options) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const distPath = path.resolve(cwd, options.distPath);
+    const { config } = await loadProjectConfig(cwd, options.manifestPath);
+    const manifestCache = await loadGeneratedRuntimeManifest(cwd, config.runtimeManifestJsonPath);
+    const generatedDistFiles = new Set();
+    const ensureEntry = async (sourceKey) => {
+        const normalizedKey = normalizeSourceKey(sourceKey, cwd);
+        const existing = manifestCache[normalizedKey];
+        if (existing) {
+            return existing;
+        }
+        const resolvedEntry = resolveEntryConfig(normalizedKey, config, cwd);
+        if (!resolvedEntry) {
+            return null;
+        }
+        try {
+            await access(resolvedEntry.sourcePath, constants.F_OK);
+        }
+        catch {
+            return null;
+        }
+        const artifact = await generateImageArtifact({
+            sourceKey: normalizedKey,
+            sourcePath: resolvedEntry.sourcePath,
+            sourceRootPath: path.join(cwd, config.assetsRoot),
+            publicPath: config.publicPath,
+            outputRoot: path.join(distPath, config.publicPath.replace(/^\/+/, '')),
+            entryConfig: resolvedEntry,
+        });
+        manifestCache[normalizedKey] = artifact.entry;
+        generatedDistFiles.add(normalizedKey);
+        return artifact.entry;
+    };
+    const files = await listFilesRecursive(distPath);
+    const updatedFiles = [];
+    for (const filePath of files) {
+        if (!OUTPUT_FILE_PATTERN.test(filePath)) {
+            continue;
+        }
+        const original = await readFile(filePath, 'utf8');
+        const rewritten = path.extname(filePath).toLowerCase() === '.css'
+            ? await rewriteCssContent(original, ensureEntry, config.assetsRoot, cwd)
+            : await rewriteHtmlContent(original, ensureEntry, config.assetsRoot, cwd);
+        if (rewritten !== original) {
+            await writeTextFile(filePath, rewritten);
+            updatedFiles.push(filePath);
+        }
+    }
+    return {
+        updatedFiles,
+        generated: [...generatedDistFiles].sort(),
+    };
+}
+async function rewriteHtmlContent(content, ensureEntry, assetsRoot, cwd) {
+    return replaceAsync(content, /(['"])(\/?assets\/[^'"]+\.(?:avif|gif|jpe?g|png|webp))\1/gi, async (fullMatch, quote, assetUrl) => {
+        if (!isStaticLocalAssetReference(assetUrl)) {
+            return fullMatch;
+        }
+        const sourceKey = resolveAssetUrlToSourceKey(assetUrl, assetsRoot, cwd);
+        if (!sourceKey) {
+            return fullMatch;
+        }
+        const entry = await ensureEntry(sourceKey);
+        return entry ? `${quote}${entry.fallbackSrc}${quote}` : fullMatch;
+    });
+}
+async function rewriteCssContent(content, ensureEntry, assetsRoot, cwd) {
+    return replaceAsync(content, /url\(\s*(?:'([^']+)'|"([^"]+)"|([^'")]+))\s*\)/gi, async (fullMatch, singleQuoted, doubleQuoted, bare) => {
+        const assetUrl = singleQuoted ?? doubleQuoted ?? bare ?? '';
+        if (!isStaticLocalAssetReference(assetUrl)) {
+            return fullMatch;
+        }
+        const sourceKey = resolveAssetUrlToSourceKey(assetUrl, assetsRoot, cwd);
+        if (!sourceKey) {
+            return fullMatch;
+        }
+        const entry = await ensureEntry(sourceKey);
+        return entry ? `url("${entry.fallbackSrc}")` : fullMatch;
+    });
+}
+async function replaceAsync(input, pattern, replacer) {
+    const matches = [...input.matchAll(pattern)];
+    if (matches.length === 0) {
+        return input;
+    }
+    let output = '';
+    let lastIndex = 0;
+    for (const match of matches) {
+        const fullMatch = match[0];
+        const matchIndex = match.index ?? 0;
+        output += input.slice(lastIndex, matchIndex);
+        output += await replacer(...match);
+        lastIndex = matchIndex + fullMatch.length;
+    }
+    output += input.slice(lastIndex);
+    return output;
+}
+async function loadGeneratedRuntimeManifest(cwd, runtimeManifestJsonPath) {
+    const filePath = path.join(cwd, runtimeManifestJsonPath);
+    try {
+        await access(filePath, constants.F_OK);
+    }
+    catch {
+        return {};
+    }
+    const raw = await readFile(filePath, 'utf8');
+    if (!raw.trim()) {
+        return {};
+    }
+    return JSON.parse(raw);
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { EMPTY_SMART_IMAGES_MANIFEST, resolveSmartImage, type SmartImageEntry, type SmartImageFormat, type SmartImageSource, type SmartImagesManifest, } from './runtime/manifest.js';
+export { createSmartImageResolver, hashed, imageEntry, imagePlaceholder, imageSources, normalizeImageKey, toPublicAssetPath, type SmartImageResolver, } from './runtime/index.js';
+export { SmartImagesModule, SMART_IMAGES_MANIFEST, SmartImagesService, provideSmartImages, } from './angular/index.js';
+export { createDefaultProjectManifest, loadProjectConfig, resolveEntryConfig, saveProjectManifest, type LoadedConfig, } from './core/config.js';
+export { generateHashedImages } from './core/generate.js';
+export { syncProjectManifest } from './core/manifest-sync.js';
+export { updateBundle } from './core/update-bundle.js';
+export type { GenerateHashedOptions, GeneratedProjectArtifacts, SmartImageConfigEntry, SmartImageProjectManifest, SmartImageResolvedConfig, SmartImageResolvedEntry, UpdateBundleOptions, } from './core/types.js';

package/dist/index.js

@@ -0,0 +1,7 @@
+export { EMPTY_SMART_IMAGES_MANIFEST, resolveSmartImage, } from './runtime/manifest.js';
+export { createSmartImageResolver, hashed, imageEntry, imagePlaceholder, imageSources, normalizeImageKey, toPublicAssetPath, } from './runtime/index.js';
+export { SmartImagesModule, SMART_IMAGES_MANIFEST, SmartImagesService, provideSmartImages, } from './angular/index.js';
+export { createDefaultProjectManifest, loadProjectConfig, resolveEntryConfig, saveProjectManifest, } from './core/config.js';
+export { generateHashedImages } from './core/generate.js';
+export { syncProjectManifest } from './core/manifest-sync.js';
+export { updateBundle } from './core/update-bundle.js';

package/dist/runtime/index.d.ts

@@ -0,0 +1,2 @@
+export { EMPTY_SMART_IMAGES_MANIFEST, resolveSmartImage, type SmartImageEntry, type SmartImageFormat, type SmartImageSource, type SmartImagesManifest, } from './manifest.js';
+export { createSmartImageResolver, hashed, imageEntry, imagePlaceholder, imageSources, normalizeImageKey, toPublicAssetPath, type SmartImageResolver, } from './resolver.js';

package/dist/runtime/index.js

@@ -0,0 +1,2 @@
+export { EMPTY_SMART_IMAGES_MANIFEST, resolveSmartImage, } from './manifest.js';
+export { createSmartImageResolver, hashed, imageEntry, imagePlaceholder, imageSources, normalizeImageKey, toPublicAssetPath, } from './resolver.js';

package/dist/runtime/manifest.d.ts

@@ -0,0 +1,19 @@
+export type SmartImageFormat = 'avif' | 'webp' | 'original';
+export interface SmartImageSource {
+    format: SmartImageFormat;
+    src: string;
+    width: number;
+}
+export interface SmartImageEntry {
+    key: string;
+    originalPath: string;
+    width: number;
+    height: number;
+    fallbackSrc: string;
+    placeholderDataUrl: string;
+    sources: ReadonlyArray<SmartImageSource>;
+}
+export type SmartImagesManifest = Record<string, SmartImageEntry>;
+export declare const EMPTY_SMART_IMAGES_MANIFEST: SmartImagesManifest;
+export declare function resolveSmartImage(key: string, manifest?: SmartImagesManifest): SmartImageEntry | null;
+export default EMPTY_SMART_IMAGES_MANIFEST;

package/dist/runtime/manifest.js

@@ -0,0 +1,5 @@
+export const EMPTY_SMART_IMAGES_MANIFEST = {};
+export function resolveSmartImage(key, manifest = EMPTY_SMART_IMAGES_MANIFEST) {
+    return manifest[key] ?? null;
+}
+export default EMPTY_SMART_IMAGES_MANIFEST;

package/dist/runtime/resolver.d.ts

@@ -0,0 +1,15 @@
+import type { SmartImageEntry, SmartImageFormat, SmartImageSource, SmartImagesManifest } from './manifest.js';
+export interface SmartImageResolver {
+    hasImage(path: string): boolean;
+    hashed(path: string): string;
+    imageEntry(path: string): SmartImageEntry | null;
+    imagePlaceholder(path: string): string;
+    imageSources(path: string, format?: SmartImageFormat): SmartImageSource[];
+}
+export declare function createSmartImageResolver(manifest?: SmartImagesManifest): SmartImageResolver;
+export declare function hashed(path: string, manifest?: SmartImagesManifest): string;
+export declare function imageEntry(path: string, manifest?: SmartImagesManifest): SmartImageEntry | null;
+export declare function imagePlaceholder(path: string, manifest?: SmartImagesManifest): string;
+export declare function imageSources(path: string, manifest?: SmartImagesManifest, format?: SmartImageFormat): SmartImageSource[];
+export declare function normalizeImageKey(path: string): string;
+export declare function toPublicAssetPath(path: string): string;

package/dist/runtime/resolver.js

@@ -0,0 +1,58 @@
+import { EMPTY_SMART_IMAGES_MANIFEST } from './manifest.js';
+export function createSmartImageResolver(manifest = EMPTY_SMART_IMAGES_MANIFEST) {
+    return {
+        hasImage(path) {
+            return imageEntry(path, manifest) !== null;
+        },
+        hashed(path) {
+            return hashed(path, manifest);
+        },
+        imageEntry(path) {
+            return imageEntry(path, manifest);
+        },
+        imagePlaceholder(path) {
+            return imagePlaceholder(path, manifest);
+        },
+        imageSources(path, format) {
+            return imageSources(path, manifest, format);
+        },
+    };
+}
+export function hashed(path, manifest = EMPTY_SMART_IMAGES_MANIFEST) {
+    return imageEntry(path, manifest)?.fallbackSrc ?? toPublicAssetPath(path);
+}
+export function imageEntry(path, manifest = EMPTY_SMART_IMAGES_MANIFEST) {
+    return manifest[normalizeImageKey(path)] ?? null;
+}
+export function imagePlaceholder(path, manifest = EMPTY_SMART_IMAGES_MANIFEST) {
+    const entry = imageEntry(path, manifest);
+    return entry?.placeholderDataUrl || entry?.fallbackSrc || toPublicAssetPath(path);
+}
+export function imageSources(path, manifest = EMPTY_SMART_IMAGES_MANIFEST, format) {
+    const entry = imageEntry(path, manifest);
+    if (!entry) {
+        return [];
+    }
+    const sources = [...entry.sources].sort((left, right) => left.width - right.width);
+    return format ? sources.filter((source) => source.format === format) : sources;
+}
+export function normalizeImageKey(path) {
+    const normalized = path.trim().replace(/\\/g, '/');
+    if (normalized.startsWith('src/assets/')) {
+        return normalized;
+    }
+    if (normalized.startsWith('/assets/')) {
+        return `src${normalized}`;
+    }
+    if (normalized.startsWith('assets/')) {
+        return `src/${normalized}`;
+    }
+    return normalized;
+}
+export function toPublicAssetPath(path) {
+    const normalized = normalizeImageKey(path);
+    if (normalized.startsWith('src/')) {
+        return `/${normalized.slice('src/'.length)}`;
+    }
+    return normalized.startsWith('/') ? normalized : `/${normalized}`;
+}

package/dist/utils/fs.d.ts

@@ -0,0 +1,4 @@
+export declare function listFilesRecursive(rootDir: string): Promise<string[]>;
+export declare function writeTextFile(targetPath: string, content: string): Promise<void>;
+export declare function copyFileBytes(sourcePath: string, targetPath: string): Promise<void>;
+export declare function toPosixPath(value: string): string;

package/dist/utils/fs.js

@@ -0,0 +1,27 @@
+import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+export async function listFilesRecursive(rootDir) {
+    const entries = await readdir(rootDir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path.join(rootDir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await listFilesRecursive(fullPath)));
+            continue;
+        }
+        files.push(fullPath);
+    }
+    return files;
+}
+export async function writeTextFile(targetPath, content) {
+    await mkdir(path.dirname(targetPath), { recursive: true });
+    await writeFile(targetPath, content, 'utf8');
+}
+export async function copyFileBytes(sourcePath, targetPath) {
+    const bytes = await readFile(sourcePath);
+    await mkdir(path.dirname(targetPath), { recursive: true });
+    await writeFile(targetPath, bytes);
+}
+export function toPosixPath(value) {
+    return value.replace(/\\/g, '/');
+}

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@yadimon/ng-smart-images",
+  "version": "0.1.0",
+  "description": "CLI-first smart image optimization with hashed asset generation, runtime manifests, and optional Angular helpers.",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yadimon/ng-smart-images.git"
+  },
+  "homepage": "https://github.com/yadimon/ng-smart-images#readme",
+  "bugs": {
+    "url": "https://github.com/yadimon/ng-smart-images/issues"
+  },
+  "keywords": [
+    "angular",
+    "cli",
+    "images",
+    "avif",
+    "webp",
+    "performance"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "ng-smart-images": "dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime/index.d.ts",
+      "default": "./dist/runtime/index.js"
+    },
+    "./angular": {
+      "types": "./dist/angular/index.d.ts",
+      "default": "./dist/angular/index.js"
+    },
+    "./manifest": {
+      "types": "./dist/runtime/manifest.d.ts",
+      "default": "./dist/runtime/manifest.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": "^20.19.0 || ^22.14.0 || ^24.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "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",
+    "lint": "eslint src tests scripts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "npm run build && vitest run",
+    "test:integration": "npm run build && vitest run tests/integration.spec.ts"
+  },
+  "dependencies": {
+    "picomatch": "^4.0.3",
+    "sharp": "^0.34.5",
+    "tinyglobby": "^0.2.15"
+  },
+  "peerDependencies": {
+    "@angular/core": "^20.0.0 || ^21.0.0 || ^22.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@angular/core": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@angular/core": "^21.2.0",
+    "@types/node": "^24.6.0",
+    "@types/picomatch": "^4.0.2",
+    "typescript": "~5.9.3",
+    "vitest": "^4.0.8"
+  }
+}