@divriots/jampack 0.24.3 → 0.25.0

package/dist/cache.d.ts

@@ -1,12 +1,13 @@
 /// <reference types="node" resolution-mode="require"/>
+import { GlobalState } from './state.js';
 declare const listOfCategories: readonly ["img", "img-ext"];
 export type Category = (typeof listOfCategories)[number];
 export type CacheData = {
     buffer: Buffer;
     meta: any;
 };
-declare function cleanCache(full: boolean): Promise<void>;
-declare function computeCacheHash(buffer: Buffer, options?: any): string;
-declare function getFromCache(category: Category, hash: string): Promise<CacheData | undefined>;
-declare function addToCache(category: Category, hash: string, data: CacheData): Promise<void>;
+declare function cleanCache(state: GlobalState, full?: boolean): Promise<void>;
+declare function computeCacheHash(state: GlobalState, buffer: Buffer, options?: any): string;
+declare function getFromCache(state: GlobalState, category: Category, hash: string): Promise<CacheData | undefined>;
+declare function addToCache(state: GlobalState, category: Category, hash: string, data: CacheData): Promise<void>;
 export { cleanCache, computeCacheHash, getFromCache, addToCache };

package/dist/cache.js

@@ -1,14 +1,13 @@
 import { hashSync as hasha } from 'hasha';
 import path from 'path';
 import * as fs from 'fs/promises';
-import $state from './state.js';
 import { CACHE_VERSIONS } from './packagejson.js';
 const listOfCategories = ['img', 'img-ext'];
-function getCacheFolder() {
-    return $state.args.cache_folder || '.jampack/cache';
+function getCacheFolder(state) {
+    return state.args.cache_folder || '.jampack/cache';
 }
-async function cleanCache(full) {
-    const CACHE_FOLDER = getCacheFolder();
+async function cleanCache(state, full) {
+    const CACHE_FOLDER = getCacheFolder(state);
     if (full) {
         try {
             await fs.rm(CACHE_FOLDER, { recursive: true });
@@ -49,8 +48,8 @@ async function cleanCache(full) {
         }
     }
 }
-function computeCacheHash(buffer, options) {
-    if ($state.args.nocache) {
+function computeCacheHash(state, buffer, options) {
+    if (state.args.nocache) {
         return '';
     }
     let hash = `${hasha(buffer, { algorithm: 'sha256' })}`;
@@ -62,15 +61,15 @@ function computeCacheHash(buffer, options) {
 function getVersionOfCategory(category) {
     return CACHE_VERSIONS[category];
 }
-function getLocation(hash, category) {
-    const CACHE_FOLDER = getCacheFolder();
+function getLocation(state, hash, category) {
+    const CACHE_FOLDER = getCacheFolder(state);
     return path.join(CACHE_FOLDER, category, getVersionOfCategory(category), hash);
 }
-async function getFromCache(category, hash) {
-    if ($state.args.nocache) {
+async function getFromCache(state, category, hash) {
+    if (state.args.nocache) {
         return undefined;
     }
-    const location = getLocation(hash, category);
+    const location = getLocation(state, hash, category);
     try {
         const buffer = await fs.readFile(path.join(location, 'data'));
         const meta = JSON.parse((await fs.readFile(path.join(location, 'meta'))).toString());
@@ -81,11 +80,11 @@ async function getFromCache(category, hash) {
     }
     return undefined;
 }
-async function addToCache(category, hash, data) {
-    if ($state.args.nocache) {
+async function addToCache(state, category, hash, data) {
+    if (state.args.nocache) {
         return;
     }
-    const location = getLocation(hash, category);
+    const location = getLocation(state, hash, category);
     await fs.mkdir(location, { recursive: true });
     await fs.writeFile(path.join(location, 'data'), data.buffer);
     await fs.writeFile(path.join(location, 'meta'), JSON.stringify(data.meta));

package/dist/compress.d.ts

@@ -1 +1,2 @@
-export declare function compressFolder(exclude: string): Promise<void>;
+import { GlobalState } from './state.js';
+export declare function compressFolder(state: GlobalState, exclude?: string): Promise<void>;

package/dist/compress.js

@@ -1,15 +1,13 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { formatBytes } from './utils.js';
-import config from './config.js';
-import $state from './state.js';
 import { globby } from 'globby';
 import ora from 'ora';
 import { compressCSS } from './compressors/css.js';
 import { compressJS } from './compressors/js.js';
 import { compressHTML } from './compressors/html.js';
 import { compressImage } from './compressors/images.js';
-const processFile = async (file, stats) => {
+const processFile = async (state, file, stats) => {
     let writeData = undefined;
     try {
         const ext = path.extname(file);
@@ -20,9 +18,9 @@ const processFile = async (file, stats) => {
             case '.svg':
             case '.webp':
             case '.avif':
-                if (config.image.compress) {
+                if (state.options.image.compress) {
                     const imgData = await fs.readFile(file);
-                    const newImage = await compressImage(imgData, {});
+                    const newImage = await compressImage(state, imgData, {});
                     if ((newImage === null || newImage === void 0 ? void 0 : newImage.data) && newImage.data.length < stats.size) {
                         writeData = newImage.data;
                     }
@@ -31,19 +29,19 @@ const processFile = async (file, stats) => {
             case '.html':
             case '.htm':
                 const htmldata = await fs.readFile(file);
-                const newhtmlData = await compressHTML(htmldata);
+                const newhtmlData = await compressHTML(state, htmldata);
                 writeData = newhtmlData;
                 break;
             case '.css':
                 const cssdata = await fs.readFile(file);
-                const newCSS = await compressCSS(cssdata);
+                const newCSS = await compressCSS(state, cssdata);
                 if (newCSS && newCSS.length < cssdata.length) {
                     writeData = newCSS;
                 }
                 break;
             case '.js':
                 const jsdata = await fs.readFile(file);
-                const newJS = await compressJS(jsdata.toString());
+                const newJS = await compressJS(state, jsdata.toString());
                 if (newJS && newJS.length < jsdata.length) {
                     writeData = newJS;
                 }
@@ -63,30 +61,30 @@ const processFile = async (file, stats) => {
     // Writedata
     if (writeData && writeData.length < result.originalSize) {
         result.compressedSize = writeData.length;
-        if (!$state.args.nowrite) {
+        if (!state.args.nowrite) {
             await fs.writeFile(file, writeData);
         }
     }
-    $state.compressedFiles.add(file);
-    $state.reportSummary(result);
+    state.compressedFiles.add(file);
+    state.reportSummary(result);
 };
-export async function compressFolder(exclude) {
-    const spinner = ora(getProgressText()).start();
+export async function compressFolder(state, exclude) {
+    const spinner = ora(getProgressText(state)).start();
     const globs = ['**/**', '!_jampack/**']; // Exclude jampack folder because already compressed
     if (exclude)
         globs.push('!' + exclude);
-    const paths = await globby(globs, { cwd: $state.dir, absolute: true });
+    const paths = await globby(globs, { cwd: state.dir, absolute: true });
     // "Parallel" processing
     await Promise.all(paths.map(async (file) => {
-        if (!$state.compressedFiles.has(file)) {
-            await processFile(file, await fs.stat(file));
-            spinner.text = getProgressText();
+        if (!state.compressedFiles.has(file)) {
+            await processFile(state, file, await fs.stat(file));
+            spinner.text = getProgressText(state);
         }
     }));
-    spinner.text = getProgressText();
+    spinner.text = getProgressText(state);
     spinner.succeed();
 }
-const getProgressText = () => {
-    const gain = $state.summary.dataLenUncompressed - $state.summary.dataLenCompressed;
-    return `${$state.summary.nbFiles} files | ${formatBytes($state.summary.dataLenUncompressed)} → ${formatBytes($state.summary.dataLenCompressed)} | -${formatBytes(gain)} `;
+const getProgressText = (state) => {
+    const gain = state.summary.dataLenUncompressed - state.summary.dataLenCompressed;
+    return `${state.summary.nbFiles} files | ${formatBytes(state.summary.dataLenUncompressed)} → ${formatBytes(state.summary.dataLenCompressed)} | -${formatBytes(gain)} `;
 };

package/dist/compressors/css.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" resolution-mode="require"/>
-import { Options } from '../config-types.js';
-export declare function compressCSS(originalCode: Buffer, type?: 'inline' | undefined): Promise<Buffer>;
-export declare function loadConfig(config: Options): void;
+import { GlobalState } from '../state.js';
+export declare const defaultTargets: () => import("lightningcss").Targets;
+export declare function compressCSS({ targets }: GlobalState, originalCode: Buffer, type?: 'inline' | undefined): Promise<Buffer>;
+export declare function loadConfigCSS(state: GlobalState): void;

package/dist/compressors/css.js

@@ -1,7 +1,7 @@
 import browserslist from 'browserslist';
 import { browserslistToTargets, transform as lightcss, transformStyleAttribute as lightcssStyleAttribute, } from 'lightningcss';
-let targets = browserslistToTargets(browserslist('defaults'));
-export async function compressCSS(originalCode, type) {
+export const defaultTargets = () => browserslistToTargets(browserslist('defaults'));
+export async function compressCSS({ targets }, originalCode, type) {
     // Compress with lightningcss
     let lightCSSData = undefined;
     try {
@@ -28,10 +28,10 @@ export async function compressCSS(originalCode, type) {
     }
     let resultBuffer = undefined;
     if (lightCSSData && lightCSSData.length < originalCode.length) {
-        resultBuffer = lightCSSData;
+        resultBuffer = Buffer.from(lightCSSData);
     }
     return resultBuffer || originalCode;
 }
-export function loadConfig(config) {
-    targets = browserslistToTargets(browserslist(config.css.browserslist || config.general.browserslist));
+export function loadConfigCSS(state) {
+    const { options } = state;
 }

package/dist/compressors/html.d.ts

@@ -1,2 +1,3 @@
 /// <reference types="node" resolution-mode="require"/>
-export declare function compressHTML(originalCode: Buffer): Promise<Buffer>;
+import { GlobalState } from '../state.js';
+export declare function compressHTML(state: GlobalState, originalCode: Buffer): Promise<Buffer>;

package/dist/compressors/html.js

@@ -1,29 +1,28 @@
 import { minify } from 'html-minifier-terser';
 import { compressCSS } from './css.js';
 import { compressJS } from './js.js';
-import config from '../config.js';
-async function minifyJSinHTML(originalCode) {
-    const newCode = await compressJS(originalCode);
+async function minifyJSinHTML(state, originalCode) {
+    const newCode = await compressJS(state, originalCode);
     if (newCode && newCode.length < originalCode.length)
         return newCode;
     return originalCode;
 }
-async function minifyCSSinHTML(originalCode, type) {
+async function minifyCSSinHTML(state, originalCode, type) {
     // Don't compress media
-    if (type === 'media')
+    if (type !== undefined && type !== 'inline')
         return originalCode;
     const originalBuffer = Buffer.from(originalCode);
-    const newCSS = await compressCSS(originalBuffer, type);
+    const newCSS = await compressCSS(state, originalBuffer, type);
     if (newCSS && newCSS.length > 0 && newCSS.length < originalBuffer.length)
         return newCSS.toString();
     return originalCode;
 }
-export async function compressHTML(originalCode) {
+export async function compressHTML(state, originalCode) {
     const newhtmlData = await minify(originalCode.toString(), {
-        minifyCSS: minifyCSSinHTML,
-        minifyJS: minifyJSinHTML,
+        minifyCSS: (text, type) => minifyCSSinHTML(state, text, type),
+        minifyJS: (text) => minifyJSinHTML(state, text),
         sortClassName: true,
-        sortAttributes: config.html.sort_attributes,
+        sortAttributes: state.options.html.sort_attributes,
     });
     if (newhtmlData)
         return Buffer.from(newhtmlData, 'utf-8');

package/dist/compressors/images.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" resolution-mode="require"/>
 import sharp from 'sharp';
 import { MimeType } from 'file-type';
+import { GlobalState } from '../state.js';
 export type ImageMimeType = MimeType | 'image/svg+xml';
 export declare const AllImageFormat: string[];
 export type ImageFormat = (typeof AllImageFormat)[number] | undefined;
@@ -12,4 +13,4 @@ export type ImageOutputOptions = {
     resize?: sharp.ResizeOptions;
     toFormat?: 'webp' | 'avif' | 'png' | 'jpeg' | 'unchanged';
 };
-export declare function compressImage(data: Buffer, options: ImageOutputOptions): Promise<Image | undefined>;
+export declare function compressImage(state: GlobalState, data: Buffer, options: ImageOutputOptions): Promise<Image | undefined>;

package/dist/compressors/images.js

@@ -1,7 +1,6 @@
 import sharp from 'sharp';
 import { optimize as svgo } from 'svgo';
 import { getFromCache, addToCache, computeCacheHash } from '../cache.js';
-import config from '../config.js';
 export const AllImageFormat = ['webp', 'svg', 'jpg', 'png', 'avif'];
 function createWebpOptions(opt) {
     return {
@@ -10,10 +9,10 @@ function createWebpOptions(opt) {
         effort: opt.effort,
     };
 }
-export async function compressImage(data, options) {
+export async function compressImage(state, data, options) {
     var _a, _b;
-    const cacheHash = computeCacheHash(data, options);
-    const imageFromCache = await getFromCache('img', cacheHash);
+    const cacheHash = computeCacheHash(state, data, options);
+    const imageFromCache = await getFromCache(state, 'img', cacheHash);
     if (imageFromCache) {
         return { data: imageFromCache.buffer, format: imageFromCache.meta };
     }
@@ -27,9 +26,10 @@ export async function compressImage(data, options) {
         return undefined;
     }
     let outputFormat;
+    const imageOptions = state.options.image;
     // Special case for svg
     if (meta.format === 'svg') {
-        if (!config.image.svg.optimization)
+        if (!imageOptions.svg.optimization)
             return undefined;
         try {
             const output = svgo(data.toString(), {
@@ -60,16 +60,16 @@ export async function compressImage(data, options) {
     if (toFormat === 'unchanged') {
         switch (meta.format) {
             case 'png':
-                sharpFile = sharpFile.png(config.image.png.options || {});
+                sharpFile = sharpFile.png(imageOptions.png.options || {});
                 outputFormat = 'png';
                 break;
             case 'jpeg':
             case 'jpg':
-                sharpFile = sharpFile.jpeg(config.image.jpeg.options || {});
+                sharpFile = sharpFile.jpeg(imageOptions.jpeg.options || {});
                 outputFormat = 'jpg';
                 break;
             case 'webp':
-                sharpFile = sharpFile.webp(createWebpOptions(config.image.webp.options_lossly) || {});
+                sharpFile = sharpFile.webp(createWebpOptions(imageOptions.webp.options_lossly) || {});
                 outputFormat = 'webp';
                 break;
             case 'heif':
@@ -83,17 +83,17 @@ export async function compressImage(data, options) {
         // To format
         switch (toFormat) {
             case 'jpeg':
-                sharpFile = sharpFile.jpeg({ ...config.image.jpeg.options } || {});
+                sharpFile = sharpFile.jpeg({ ...imageOptions.jpeg.options } || {});
                 outputFormat = 'jpg';
                 break;
             case 'png':
-                sharpFile = sharpFile.png({ ...config.image.png.options } || {});
+                sharpFile = sharpFile.png({ ...imageOptions.png.options } || {});
                 outputFormat = 'png';
                 break;
             case 'webp':
                 sharpFile = sharpFile.webp(createWebpOptions(meta.format === 'png'
-                    ? config.image.webp.options_lossless
-                    : config.image.webp.options_lossly));
+                    ? imageOptions.webp.options_lossless
+                    : imageOptions.webp.options_lossly));
                 outputFormat = 'webp';
                 break;
             case 'avif':
@@ -125,7 +125,7 @@ export async function compressImage(data, options) {
         format: outputFormat,
         data: await sharpFile.toBuffer(),
     };
-    await addToCache('img', cacheHash, {
+    await addToCache(state, 'img', cacheHash, {
         buffer: outputImage.data,
         meta: outputImage.format,
     });

package/dist/compressors/js.d.ts

@@ -1 +1,2 @@
-export declare function compressJS(originalCode: string): Promise<string>;
+import { GlobalState } from '../state.js';
+export declare function compressJS({ options }: GlobalState, originalCode: string): Promise<string>;

package/dist/compressors/js.js

@@ -1,9 +1,8 @@
 import swc from '@swc/core';
 import * as esbuild from 'esbuild';
-import config from '../config.js';
-export async function compressJS(originalCode) {
+export async function compressJS({ options }, originalCode) {
     let resultCode = originalCode;
-    switch (config.js.compressor) {
+    switch (options.js.compressor) {
         case 'esbuild':
             resultCode = (await esbuild.transform(originalCode, {
                 minify: true,

package/dist/config-default.js

@@ -17,6 +17,8 @@ const default_options = {
         srcset_min_width: 390 * 2, // HiDPI phone
         srcset_max_width: 1920 * 2, // 4K
         max_width: 99999,
+        src_include: /^.*$/,
+        src_exclude: /^\/vercel\/image\?/, // Ignore /vervel/image? URLs because not local and most likely already optimized,
         external: {
             process: 'off',
             src_include: /^.*$/,

package/dist/config-types.d.ts

@@ -24,6 +24,8 @@ export type Options = {
         srcset_min_width: number;
         srcset_max_width: number;
         max_width: number;
+        src_include: RegExp;
+        src_exclude: RegExp | null;
         external: {
             process: 'off' | 'download';
             src_include: RegExp;

package/dist/config.d.ts

@@ -1,4 +1,3 @@
-declare const options: import("./config-types.js").Options;
-export declare function fast(): void;
-export declare function loadConfig(): Promise<void>;
-export default options;
+import { GlobalState } from './state.js';
+export declare function fast(state: GlobalState): void;
+export declare function loadConfig(state: GlobalState): Promise<void>;

package/dist/config.js

@@ -3,16 +3,18 @@ import load from '@proload/core';
 import deepmerge from 'deepmerge';
 import default_options from './config-default.js';
 import fast_options_override from './config-fast.js';
-const options = default_options;
-export function fast() {
-    Object.assign(options, deepmerge(options, fast_options_override));
+import { loadConfigCSS } from './compressors/css.js';
+export function fast(state) {
+    const options = default_options;
+    Object.assign(state.options, deepmerge(options, fast_options_override));
 }
-export async function loadConfig() {
+export async function loadConfig(state) {
+    const options = default_options;
     const proload = await load('jampack', { mustExist: false });
     if (proload) {
         console.log('Merging default config with:');
         console.log(JSON.stringify(proload.value, null, 2));
-        Object.assign(options, deepmerge(options, proload.value));
+        Object.assign(state.options, deepmerge(options, proload.value));
     }
+    loadConfigCSS(state);
 }
-export default options;

package/dist/index.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
+import { Command } from '@commander-js/extra-typings';
 import { compressFolder } from './compress.js';
 import { optimize } from './optimize.js';
-import $state from './state.js';
+import { GlobalState } from './state.js';
 import { table } from 'table';
 import { formatBytes } from './utils.js';
-import config, { fast, loadConfig } from './config.js';
+import { fast, loadConfig } from './config.js';
 import { printTitle } from './logger.js';
 import { exit } from 'process';
 import kleur from 'kleur';
@@ -13,7 +13,6 @@ import { cleanCache } from './cache.js';
 import { VERSION } from './packagejson.js';
 import { mkdirSync } from 'fs';
 import { join } from 'path';
-import { loadConfig as loadConfigCSS } from './compressors/css.js';
 const logo = `     __                                    __    
     |__|____    _____ ___________    ____ |  | __
     |  \\__  \\  /     \\\\____ \\__  \\ _/ ___\\|  |/ /
@@ -43,9 +42,10 @@ program
     .option('--cleancache', 'Clean cache before running')
     .option('--nocache', 'Run with no use of cache')
     .action(async (dir, options) => {
+    const state = new GlobalState();
     // Arguments
-    $state.dir = dir;
-    $state.args = options;
+    state.dir = dir;
+    state.args = options;
     // Print options
     if (options) {
         console.log('Options:');
@@ -53,43 +53,41 @@ program
         console.log('');
     }
     // Override default config with config file
-    await loadConfig();
+    await loadConfig(state);
     // Override config with fast options if set
     if (options.fast) {
-        fast();
+        fast(state);
     }
     // Clean cache
-    await cleanCache(options.cleancache);
+    await cleanCache(state, options.cleancache);
     // Make _jampack folder
     try {
         mkdirSync(join(dir, '_jampack'));
     }
     catch (e) {
-        console.error('Failed to create `_jampack` folder.');
+        console.error('Folder `_jampack` is present in target folder. This means that jampack has already processed this folder. You should always run jampack on clean build of the static website.');
         exit(1);
     }
-    // Inject config into modules
-    loadConfigCSS(config);
     if (!options.onlycomp) {
         printTitle('PASS 1 - Optimizing');
         console.time('Done');
-        await optimize(options.include, options.exclude);
+        await optimize(state, options.include, options.exclude);
         console.timeEnd('Done');
     }
     if (!options.onlyoptim && !options.fast) {
         printTitle('PASS 2 - Compressing the rest');
         console.time('Done');
-        await compressFolder(options.exclude);
+        await compressFolder(state, options.exclude);
         console.timeEnd('Done');
     }
-    printSummary();
-    printIssues();
-    if (options.fail && $state.issues.size > 0) {
+    printSummary(state);
+    printIssues(state);
+    if (options.fail && state.issues.size > 0) {
         exit(1);
     }
 });
 program.parse();
-function printSummary() {
+function printSummary($state) {
     if ($state.summary.nbFiles > 0) {
         printTitle('Summary');
         const dataTable = [
@@ -141,22 +139,22 @@ function printSummary() {
         console.log(table(dataTable, config));
     }
 }
-function printIssues() {
+function printIssues(state) {
     let issueCount = 0;
-    if ($state.issues.size === 0) {
+    if (state.issues.size === 0) {
         printTitle('✔ No issues');
     }
     else {
         printTitle('Issues', kleur.bgRed);
         console.log('');
-        for (let [file, list] of $state.issues) {
+        for (let [file, list] of state.issues) {
             console.log('▶ ' + file + '\n');
             list.forEach((issue) => {
                 issueCount++;
                 console.log(`${kleur.bgYellow(` ${issue.type} `)} ${issue.msg}\n`);
             });
         }
-        printTitle(`${issueCount} issue(s) over ${$state.issues.size} files`, kleur.bgYellow);
+        printTitle(`${issueCount} issue(s) over ${state.issues.size} files`, kleur.bgYellow);
         console.log('');
     }
 }

package/dist/optimize.d.ts

@@ -1 +1,2 @@
-export declare function optimize(include?: string, exclude?: string): Promise<void>;
+import { GlobalState } from './state.js';
+export declare function optimize(state: GlobalState, include?: string, exclude?: string): Promise<void>;

package/dist/optimize.js

@@ -4,10 +4,8 @@ import * as fs from 'fs/promises';
 import { getCanonicalCdnForUrl, getTransformer } from 'unpic';
 import * as cheerio from '@divriots/cheerio';
 import { isNumeric } from './utils.js';
-import config from './config.js';
 import { compressImage, } from './compressors/images.js';
 import svgToMiniDataURI from 'mini-svg-data-uri';
-import $state from './state.js';
 import kleur from 'kleur';
 import ora from 'ora';
 import { isLocal, Resource, translateSrc } from './utils/resource.js';
@@ -25,9 +23,9 @@ function getIntAttr(img, attr) {
         return;
     return parsed;
 }
-async function analyse(file) {
+async function analyse(state, file) {
     console.log('▶ ' + file);
-    const html = (await fs.readFile(path.join($state.dir, file))).toString();
+    const html = (await fs.readFile(path.join(state.dir, file))).toString();
     if (!html.includes('<html'))
         return;
     const $ = cheerio.load(html, { sourceCodeLocationInfo: true });
@@ -46,10 +44,10 @@ async function analyse(file) {
         const isAboveTheFold = isImgAboveTheFold(img, imgElement, theFold);
         img.removeAttr(ABOVE_FOLD_DATA_ATTR);
         try {
-            await processImage(file, img, isAboveTheFold);
+            await processImage(state, file, img, isAboveTheFold);
         }
         catch (e) {
-            $state.reportIssue(file, {
+            state.reportIssue(file, {
                 type: 'erro',
                 msg: e.message ||
                     `Unexpected error while processing image: ${JSON.stringify(e)}`,
@@ -59,7 +57,7 @@ async function analyse(file) {
     // Reset spinner
     spinnerImg.text = kleur.dim(`<img> [${imgsArray.length}/${imgsArray.length}]`);
     // Notify issues
-    const issues = $state.issues.get(file);
+    const issues = state.issues.get(file);
     if (issues) {
         spinnerImg.fail();
         console.log(kleur.red(`  ${issues.length} issue${issues.length > 1 ? 's' : ''}`));
@@ -82,7 +80,7 @@ async function analyse(file) {
             await processIframe(file, $, ifElement, isAboveTheFold);
         }
         catch (e) {
-            $state.reportIssue(file, {
+            state.reportIssue(file, {
                 type: 'erro',
                 msg: e.message ||
                     `Unexpected error while processing image: ${JSON.stringify(e)}`,
@@ -104,7 +102,8 @@ async function analyse(file) {
     const heads = $('head'); // always exists because doc loaded with isDocument=true (default)
     const charsetElements$ = heads.find('meta[charset]');
     const wasCharsetFirst = !charsetElements$.prev().length;
-    if (config.html.add_css_reset_as === 'inline') {
+    const { options } = state;
+    if (options.html.add_css_reset_as === 'inline') {
         prependToHead += `<style>:where(img){height:auto;}</style>`;
     }
     if (prependToHead || appendToHead) {
@@ -115,7 +114,7 @@ async function analyse(file) {
     }
     switch (charsetElements$.length) {
         case 0:
-            $state.reportIssue(file, {
+            state.reportIssue(file, {
                 type: 'fix',
                 msg: 'Adding missing <meta charset="utf-8"> to the top of the <head>',
             });
@@ -123,7 +122,7 @@ async function analyse(file) {
             break;
         case 1:
             if (!wasCharsetFirst) {
-                $state.reportIssue(file, {
+                state.reportIssue(file, {
                     type: 'perf',
                     msg: 'Moving <meta charset> to the top of the <head>',
                 });
@@ -132,7 +131,7 @@ async function analyse(file) {
                 heads.prepend(charsetElements$);
             break;
         default:
-            $state.reportIssue(file, {
+            state.reportIssue(file, {
                 type: 'fix',
                 msg: 'Multiple <meta charset> found in the <head>: taking only the first one and deleting the others',
             });
@@ -142,8 +141,8 @@ async function analyse(file) {
     // Add to <body>
     //
     let appendToBody = '';
-    if (config.misc.prefetch_links === 'in-viewport') {
-        appendToBody += await prefetch_links_in_viewport(file);
+    if (options.misc.prefetch_links === 'in-viewport') {
+        appendToBody += await prefetch_links_in_viewport(state, file);
     }
     if (appendToBody) {
         const body = $('body');
@@ -156,16 +155,16 @@ async function analyse(file) {
     let htmlResult = $.html();
     // Inline critical css
     //
-    if (config.css.inline_critical_css) {
+    if (options.css.inline_critical_css) {
         try {
-            htmlResult = await inlineCriticalCss($state.dir, htmlResult);
+            htmlResult = await inlineCriticalCss(state.dir, htmlResult);
         }
         catch (e) {
             console.warn('Fail to inline critical CSS', e);
         }
     }
-    if (!$state.args.nowrite) {
-        await fs.writeFile(path.join($state.dir, file), htmlResult);
+    if (!state.args.nowrite) {
+        await fs.writeFile(path.join(state.dir, file), htmlResult);
     }
 }
 function isImgAboveTheFold(img, imgElement, theFold) {
@@ -200,7 +199,7 @@ function getTheFold($) {
     }
     return 0;
 }
-async function processImage(htmlfile, img, isAboveTheFold) {
+async function processImage(state, htmlfile, img, isAboveTheFold) {
     var _a, _b;
     /*
      * Attribute 'src'
@@ -214,18 +213,23 @@ async function processImage(htmlfile, img, isAboveTheFold) {
             // Let's not mess with it and hope it's well done
             return; // No warnings
         }
-        $state.reportIssue(htmlfile, {
+        state.reportIssue(htmlfile, {
             type: 'warn',
             msg: `Missing [src] on img - processing skipped.`,
         });
         return;
     }
+    const config = state.options;
+    if (!isIncluded(attrib_src, config.image.src_include, config.image.src_exclude)) {
+        // Setup to ignore
+        return;
+    }
     /*
      * Attribute 'alt'
      */
     const attrib_alt = img.attr('alt');
     if (attrib_alt === undefined) {
-        $state.reportIssue(htmlfile, {
+        state.reportIssue(htmlfile, {
             type: 'a11y',
             msg: `Missing [alt] on img src="${attrib_src}" - Adding alt="" meanwhile.`,
         });
@@ -257,7 +261,7 @@ async function processImage(htmlfile, img, isAboveTheFold) {
                 // Don't touch it
                 break;
             default:
-                $state.reportIssue(htmlfile, {
+                state.reportIssue(htmlfile, {
                     type: 'invalid',
                     msg: `Invalid [loading]="${attr_loading}" on img src="${attrib_src}"`,
                 });
@@ -290,7 +294,7 @@ async function processImage(htmlfile, img, isAboveTheFold) {
                 break;
             let attrib_width = getIntAttr(img, 'width');
             if (!attrib_width) {
-                $state.reportIssue(htmlfile, {
+                state.reportIssue(htmlfile, {
                     type: 'warn',
                     msg: `Missing or malformed'width' attribute for image ${attrib_src}, unable to perform CDN transform`,
                 });
@@ -298,13 +302,13 @@ async function processImage(htmlfile, img, isAboveTheFold) {
             }
             let attrib_height = getIntAttr(img, 'height');
             if (!attrib_height) {
-                $state.reportIssue(htmlfile, {
+                state.reportIssue(htmlfile, {
                     type: 'warn',
                     msg: `Missing or malformed 'height' attribute for image ${attrib_src}, unable to perform CDN transform`,
                 });
                 return;
             }
-            const new_srcset = await generateSrcSetForCdn(attrib_src, cdnTransformer, attrib_width, attrib_height);
+            const new_srcset = await generateSrcSetForCdn(state, attrib_src, cdnTransformer, attrib_width, attrib_height);
             if (new_srcset !== null) {
                 img.attr('srcset', new_srcset);
             }
@@ -322,11 +326,11 @@ async function processImage(htmlfile, img, isAboveTheFold) {
                 if (!isIncluded(attrib_src, config.image.external.src_include, config.image.external.src_exclude))
                     break;
                 try {
-                    attrib_src = await downloadExternalImage(htmlfile, attrib_src);
+                    attrib_src = await downloadExternalImage(state, htmlfile, attrib_src);
                     img.attr('src', attrib_src);
                 }
                 catch (e) {
-                    $state.reportIssue(htmlfile, {
+                    state.reportIssue(htmlfile, {
                         type: 'warn',
                         msg: `Failed to download image: ${attrib_src} - ${e.message}`,
                     });
@@ -338,10 +342,10 @@ async function processImage(htmlfile, img, isAboveTheFold) {
     /*
      * Loading image
      */
-    const originalImage = await Resource.loadResource($state.dir, htmlfile, attrib_src);
+    const originalImage = await Resource.loadResource(state.dir, htmlfile, attrib_src);
     // No file -> give up
     if (!originalImage) {
-        $state.reportIssue(htmlfile, {
+        state.reportIssue(htmlfile, {
             type: 'erro',
             msg: `Can't find img on disk src="${attrib_src}"`,
         });
@@ -365,7 +369,7 @@ async function processImage(htmlfile, img, isAboveTheFold) {
                 : 'webp';
     }
     if (config.image.compress) {
-        newImage = await compressImage(await originalImage.getData(), {
+        newImage = await compressImage(state, await originalImage.getData(), {
             toFormat: srcToFormat,
             resize: { width: config.image.srcset_max_width },
         });
@@ -374,13 +378,13 @@ async function processImage(htmlfile, img, isAboveTheFold) {
         const newFilename = path.join(path.dirname(originalImage.filePathAbsolute), path.basename(originalImage.filePathAbsolute, path.extname(originalImage.filePathAbsolute)) + `.${newImage.format}`);
         const newSrc = path.join(path.dirname(attrib_src), path.basename(attrib_src, path.extname(attrib_src)) +
             `.${newImage.format}`);
-        if (!$state.compressedFiles.has(newFilename) && !$state.args.nowrite) {
+        if (!state.compressedFiles.has(newFilename) && !state.args.nowrite) {
             fs.writeFile(newFilename, newImage.data);
         }
         // Mark new file as compressed
-        $state.compressedFiles.add(newFilename);
+        state.compressedFiles.add(newFilename);
         // Report compression result
-        $state.reportSummary({
+        state.reportSummary({
             action: newFilename !== originalImage.filePathAbsolute
                 ? `${await originalImage.getExt()}->${newImage.format}`
                 : path.extname(originalImage.filePathAbsolute),
@@ -393,7 +397,7 @@ async function processImage(htmlfile, img, isAboveTheFold) {
         // Drop new Image
         newImage = undefined;
         // Report non-compression
-        $state.reportSummary({
+        state.reportSummary({
             action: path.extname(originalImage.filePathAbsolute),
             originalSize: await originalImage.getLen(),
             compressedSize: await originalImage.getLen(),
@@ -433,7 +437,7 @@ async function processImage(htmlfile, img, isAboveTheFold) {
                 img.attr('src', datauri);
                 img.removeAttr('loading');
                 img.removeAttr('decoding');
-                $state.reportSummary({
+                state.reportSummary({
                     action: `${imageToEmbed.format}->embed`,
                     originalSize: await originalImage.getLen(),
                     compressedSize: imageToEmbed.data.length,
@@ -450,7 +454,7 @@ async function processImage(htmlfile, img, isAboveTheFold) {
     /*
      * Attribute 'width' & 'height'
      */
-    const [w, h] = await setImageSize(htmlfile, img, originalImage);
+    const [w, h] = await setImageSize(state, htmlfile, img, originalImage);
     if (isEmbed) {
         // Image is embed, no need for more processing
         return;
@@ -475,7 +479,7 @@ async function processImage(htmlfile, img, isAboveTheFold) {
         // of the srcset
     }
     else {
-        const new_srcset = await generateSrcSet(htmlfile, originalImage, img.attr('src'), imageLengthToBeatInSrcSet, { toFormat: srcToFormat });
+        const new_srcset = await generateSrcSet(state, htmlfile, originalImage, img.attr('src'), imageLengthToBeatInSrcSet, { toFormat: srcToFormat });
         if (new_srcset !== null) {
             img.attr('srcset', new_srcset);
         }
@@ -529,7 +533,7 @@ async function processImage(htmlfile, img, isAboveTheFold) {
                 // Ignore the creation of sources that already exist
                 continue;
             }
-            const srcset = await generateSrcSet(htmlfile, originalImage, undefined, undefined, {
+            const srcset = await generateSrcSet(state, htmlfile, originalImage, undefined, undefined, {
                 toFormat: s.format,
             });
             if (!srcset) {
@@ -543,7 +547,7 @@ async function processImage(htmlfile, img, isAboveTheFold) {
     }
 }
 const isIncluded = (src, includeConf, excludeConf) => !!src.match(includeConf) && (!excludeConf || !src.match(excludeConf));
-async function _generateSrcSet(startSrc, imageWidth, imageHeight, transformSrc) {
+async function _generateSrcSet({ options }, startSrc, imageWidth, imageHeight, transformSrc) {
     // Start from original image
     let new_srcset = '';
     if (!imageWidth || !imageHeight) {
@@ -553,8 +557,8 @@ async function _generateSrcSet(startSrc, imageWidth, imageHeight, transformSrc)
     // Start reduction
     const step = 300; //px
     let valueW = !startSrc ? imageWidth : imageWidth - step;
-    valueW = Math.min(valueW, config.image.srcset_max_width);
-    while (valueW >= config.image.srcset_min_width) {
+    valueW = Math.min(valueW, options.image.srcset_max_width);
+    while (valueW >= options.image.srcset_min_width) {
         let src = await transformSrc(valueW);
         if (src) {
             new_srcset += `, ${src} ${valueW}w`;
@@ -569,7 +573,7 @@ async function _generateSrcSet(startSrc, imageWidth, imageHeight, transformSrc)
     }
     return null;
 }
-async function generateSrcSet(htmlfile, originalImage, startSrc, startSrcLength, options) {
+async function generateSrcSet(state, htmlfile, originalImage, startSrc, startSrcLength, options) {
     const ext = path.extname(originalImage.src);
     const fullbasename = originalImage.src.slice(0, -ext.length);
     const imageSrc = (addition) => {
@@ -582,12 +586,12 @@ async function generateSrcSet(htmlfile, originalImage, startSrc, startSrcLength,
     const imageWidth = (meta === null || meta === void 0 ? void 0 : meta.width) || 0;
     const imageHeight = (meta === null || meta === void 0 ? void 0 : meta.height) || 0;
     let previousImageSize = startSrcLength || Number.MAX_VALUE;
-    return _generateSrcSet(startSrc, imageWidth, imageHeight, async (valueW) => {
+    return _generateSrcSet(state, startSrc, imageWidth, imageHeight, async (valueW) => {
         const src = imageSrc(`@${valueW}w`);
-        const absoluteFilename = translateSrc($state.dir, path.dirname(htmlfile), src);
+        const absoluteFilename = translateSrc(state.dir, path.dirname(htmlfile), src);
         // Don't generate srcset file twice
-        if (!$state.compressedFiles.has(absoluteFilename)) {
-            const compressedImage = await compressImage(await originalImage.getData(), { ...options, resize: { width: valueW } });
+        if (!state.compressedFiles.has(absoluteFilename)) {
+            const compressedImage = await compressImage(state, await originalImage.getData(), { ...options, resize: { width: valueW } });
             if (!(compressedImage === null || compressedImage === void 0 ? void 0 : compressedImage.data) ||
                 compressedImage.data.length >= previousImageSize) {
                 // New image is not compressed or bigger than previous image in srcset
@@ -596,20 +600,20 @@ async function generateSrcSet(htmlfile, originalImage, startSrc, startSrcLength,
             }
             else {
                 // Write file
-                if (!$state.args.nowrite) {
+                if (!state.args.nowrite) {
                     fs.writeFile(absoluteFilename, compressedImage.data);
                 }
                 // Set new previous size to beat
                 previousImageSize = compressedImage.data.length;
                 // Add file to list avoid recompression
-                $state.compressedFiles.add(absoluteFilename);
+                state.compressedFiles.add(absoluteFilename);
             }
         }
         return src;
     });
 }
-async function generateSrcSetForCdn(startSrc, cdnTransformer, imageWidth, imageHeight) {
-    return _generateSrcSet('', imageWidth, imageHeight, (valueW) => {
+async function generateSrcSetForCdn(state, startSrc, cdnTransformer, imageWidth, imageHeight) {
+    return _generateSrcSet(state, '', imageWidth, imageHeight, (valueW) => {
         var _a, _b;
         return (_b = (_a = cdnTransformer({
             url: startSrc,
@@ -617,19 +621,19 @@ async function generateSrcSetForCdn(startSrc, cdnTransformer, imageWidth, imageH
         })) === null || _a === void 0 ? void 0 : _a.toString()) === null || _b === void 0 ? void 0 : _b.replace(UNPIC_DEFAULT_HOST_REGEX, '/');
     });
 }
-async function setImageSize(htmlfile, img, image) {
+async function setImageSize(state, htmlfile, img, image) {
     let width = img.attr('width');
     let height = img.attr('height');
     let width_new = undefined;
     let height_new = undefined;
     const img_fmt = await image.getExt();
-    if (img_fmt === 'svg' && !config.image.svg.add_width_and_height) {
+    if (img_fmt === 'svg' && !state.options.image.svg.add_width_and_height) {
         return [];
     }
     // Check valid values
     if (width !== undefined) {
         if (!isNumeric(width)) {
-            $state.reportIssue(htmlfile, {
+            state.reportIssue(htmlfile, {
                 type: 'fix',
                 msg: `Invalid width attribute format: "${width}" - overriding for ${image.src}`,
             });
@@ -638,7 +642,7 @@ async function setImageSize(htmlfile, img, image) {
     }
     if (height !== undefined) {
         if (!isNumeric(height)) {
-            $state.reportIssue(htmlfile, {
+            state.reportIssue(htmlfile, {
                 type: 'fix',
                 msg: `Invalid height attribute format: "${height}" - overriding for ${image.src}`,
             });
@@ -746,13 +750,13 @@ async function processIframe(htmlfile, $, imgElement, isAboveTheFold) {
         iframe.attr('loading', 'lazy');
     }
 }
-export async function optimize(include, exclude) {
+export async function optimize(state, include, exclude) {
     const glob = include ? [include] : ['**/*.{htm,html}'];
     if (exclude)
         glob.push('!' + exclude);
-    const paths = await globby(glob, { cwd: $state.dir });
+    const paths = await globby(glob, { cwd: state.dir });
     // Sequential async
     for (const file of paths) {
-        await analyse(file);
+        await analyse(state, file);
     }
 }

package/dist/optimizers/img-external.d.ts

@@ -1,2 +1,3 @@
+import { GlobalState } from '../state.js';
 import '../utils/polyfill-fetch.js';
-export declare function downloadExternalImage(htmlfile: string, href: string): Promise<string>;
+export declare function downloadExternalImage(state: GlobalState, htmlfile: string, href: string): Promise<string>;

package/dist/optimizers/img-external.js

@@ -1,12 +1,11 @@
 import * as path from 'path';
 import * as fs from 'fs/promises';
-import $state from '../state.js';
 import { hashSync as hasha } from 'hasha';
 import { fileTypeFromBuffer } from 'file-type';
 import { addToCache, getFromCache } from '../cache.js';
 import { parse } from '../utils/cache-control-parser.js';
 import '../utils/polyfill-fetch.js';
-export async function downloadExternalImage(htmlfile, href) {
+export async function downloadExternalImage(state, htmlfile, href) {
     var _a, _b, _c, _d, _e;
     const hash = hasha(href, {
         algorithm: 'md5',
@@ -15,7 +14,7 @@ export async function downloadExternalImage(htmlfile, href) {
     let buffer;
     let ext;
     // Image is in cache?
-    const dataFromCache = await getFromCache('img-ext', hash);
+    const dataFromCache = await getFromCache(state, 'img-ext', hash);
     const cacheControl = (_a = dataFromCache === null || dataFromCache === void 0 ? void 0 : dataFromCache.meta) === null || _a === void 0 ? void 0 : _a.CacheControl;
     if (dataFromCache && cacheControl) {
         const date = (_b = dataFromCache === null || dataFromCache === void 0 ? void 0 : dataFromCache.meta) === null || _b === void 0 ? void 0 : _b.Date;
@@ -64,7 +63,7 @@ export async function downloadExternalImage(htmlfile, href) {
                 }
                 else {
                     // Add downloaded image to cache
-                    await addToCache('img-ext', hash, {
+                    await addToCache(state, 'img-ext', hash, {
                         buffer,
                         meta: {
                             Date: resp.headers.get('Date'),
@@ -97,7 +96,7 @@ export async function downloadExternalImage(htmlfile, href) {
     if (!ext)
         throw new Error('Unknown image format');
     const htmlFolder = path.dirname(htmlfile);
-    const filename = path.relative(path.join($state.dir, htmlFolder), path.join($state.dir, `_jampack/${contentHash}.${ext}`));
-    await fs.writeFile(path.join($state.dir, htmlFolder, filename), buffer);
+    const filename = path.relative(path.join(state.dir, htmlFolder), path.join(state.dir, `_jampack/${contentHash}.${ext}`));
+    await fs.writeFile(path.join(state.dir, htmlFolder, filename), buffer);
     return filename;
 }

package/dist/optimizers/prefetch-links.d.ts

@@ -1 +1,2 @@
-export declare function prefetch_links_in_viewport(html_file: string): Promise<string>;
+import { GlobalState } from '../state.js';
+export declare function prefetch_links_in_viewport(state: GlobalState, html_file: string): Promise<string>;

package/dist/optimizers/prefetch-links.js

@@ -1,4 +1,3 @@
-import $state from '../state.js';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { createRequire } from 'node:module';
@@ -6,13 +5,15 @@ const require = createRequire(import.meta.url);
 const src_filename = 'quicklink.mjs';
 const folder = `/_jampack/quicklink-2.3.0`;
 const url_loader = `${folder}/loader.js`;
-export async function prefetch_links_in_viewport(html_file) {
+export async function prefetch_links_in_viewport(state, html_file) {
     const path_html = path.dirname('/' + html_file);
-    const quickLinkDestination = path.join($state.dir, folder, src_filename);
-    const payloadStored = await fs.access(quickLinkDestination).catch(() => false);
+    const quickLinkDestination = path.join(state.dir, folder, src_filename);
+    const payloadStored = await fs
+        .access(quickLinkDestination)
+        .catch(() => false);
     if (!payloadStored) {
-        const path_loader = path.join($state.dir, url_loader);
-        await fs.mkdir(path.join($state.dir, folder), { recursive: true });
+        const path_loader = path.join(state.dir, url_loader);
+        await fs.mkdir(path.join(state.dir, folder), { recursive: true });
         // Write loader
         const code_loader = `import { listen } from "./${src_filename}";
     listen();`;

package/dist/state.d.ts

@@ -21,6 +21,8 @@ type Issue = {
 export declare class GlobalState {
     dir: string;
     args: Args;
+    options: import("./config-types.js").Options;
+    targets: import("lightningcss").Targets;
     compressedFiles: Set<string>;
     issues: Map<string, Issue[]>;
     summary: Summary;
@@ -28,5 +30,4 @@ export declare class GlobalState {
     reportIssue(sourceFile: string, issue: Issue): void;
     reportSummary(r: ReportItem): void;
 }
-declare const state: GlobalState;
-export default state;
+export {};

package/dist/state.js

@@ -1,7 +1,11 @@
+import { defaultTargets } from './compressors/css.js';
+import default_options from './config-default.js';
 export class GlobalState {
     constructor() {
         this.dir = 'dist';
         this.args = {};
+        this.options = default_options;
+        this.targets = defaultTargets();
         this.compressedFiles = new Set();
         this.issues = new Map();
         this.summary = {
@@ -23,9 +27,9 @@ export class GlobalState {
     reportSummary(r) {
         const isCompressed = r.compressedSize < r.originalSize ? 1 : 0;
         this.summary.nbFiles++;
-        state.summary.nbFilesCompressed += isCompressed;
-        state.summary.dataLenUncompressed += r.originalSize;
-        state.summary.dataLenCompressed += r.compressedSize;
+        this.summary.nbFilesCompressed += isCompressed;
+        this.summary.dataLenUncompressed += r.originalSize;
+        this.summary.dataLenCompressed += r.compressedSize;
         if (r.action) {
             let summary = this.summaryByExtension[r.action];
             if (!summary) {
@@ -44,5 +48,3 @@ export class GlobalState {
         }
     }
 }
-const state = new GlobalState();
-export default state;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@divriots/jampack",
-  "version": "0.24.3",
+  "version": "0.25.0",
   "cache-version": {
     "img": "v1",
     "img-ext": "v1"
@@ -26,6 +26,7 @@
     "./state": "./dist/state.js"
   },
   "dependencies": {
+    "@commander-js/extra-typings": "^12.0.0",
     "@divriots/cheerio": "1.0.0-rc.12",
     "@proload/core": "^0.3.3",
     "@swc/core": "^1.4.16",
@@ -40,7 +41,7 @@
     "hasha": "^6.0.0",
     "html-minifier-terser": "^7.2.0",
     "kleur": "^4.1.5",
-    "lightningcss": "^1.24.1",
+    "lightningcss": "^1.25.1",
     "mini-svg-data-uri": "^1.4.4",
     "ora": "^8.0.1",
     "quicklink": "^2.3.0",