@divriots/jampack 0.0.9 → 0.1.1

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright 2022 ‹div›RIOTS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+## jampack
+
+Optimize static websites for maximum performance and best Core Web Vitals scores.

package/dist/compress.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" resolution-mode="require"/>
+import sharp from 'sharp';
+import type { Result } from './types.js';
+export declare const compressImage: (data: Buffer, resize: sharp.ResizeOptions) => Promise<Buffer | undefined>;
+export declare function compress(dir: string, initResult: Result[]): Promise<void>;

package/dist/compress.js

@@ -0,0 +1,182 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { optimize as svgo } from "svgo";
+import { minify as htmlminifier } from 'html-minifier-terser';
+import { minify as csso } from "csso";
+import { formatBytes } from './utils.js';
+import { table } from 'table';
+import sharp from 'sharp';
+import swc from '@swc/core';
+let state;
+let compressedFiles = [];
+const beginProgress = (initResults) => {
+    state = {
+        total: {
+            nbFiles: 0,
+            nbFilesCompressed: 0,
+            dataLenUncompressed: 0,
+            dataLenCompressed: 0
+        },
+        detailsByExtension: {},
+    };
+    initResults.forEach(r => {
+        addProgress(r);
+        compressedFiles.push(r.file);
+    });
+};
+const addProgress = (r) => {
+    const isCompressed = r.compressedSize < r.originalSize ? 1 : 0;
+    state.total.nbFiles++;
+    state.total.nbFilesCompressed += isCompressed;
+    state.total.dataLenUncompressed += r.originalSize;
+    state.total.dataLenCompressed += r.compressedSize;
+    const ext = path.extname(r.file);
+    if (ext) {
+        var summary = state.detailsByExtension[ext];
+        if (!summary) {
+            summary = {
+                nbFiles: 0,
+                nbFilesCompressed: 0,
+                dataLenUncompressed: 0,
+                dataLenCompressed: 0
+            };
+            state.detailsByExtension[ext] = summary;
+        }
+        summary.nbFiles++;
+        summary.nbFilesCompressed += isCompressed;
+        summary.dataLenUncompressed += r.originalSize;
+        summary.dataLenCompressed += r.compressedSize;
+    }
+};
+const printProgress = (r) => {
+    addProgress(r);
+    process.stdout.clearLine(0);
+    process.stdout.cursorTo(0);
+    process.stdout.write(`${state.total.nbFiles} files | ${formatBytes(state.total.dataLenUncompressed)} → ${formatBytes(state.total.dataLenCompressed)}`);
+};
+const endProgress = () => {
+    process.stdout.write('\n');
+};
+const printDetails = () => {
+    const dataTable = [['Extension', 'Files', 'Compressed', 'Original', 'Compressed', 'Gain']];
+    const config = {
+        columns: [
+            { alignment: 'left' },
+            { alignment: 'right' },
+            { alignment: 'right' },
+            { alignment: 'right' },
+            { alignment: 'right' }
+        ],
+    };
+    Object.entries(state.detailsByExtension).forEach(([ext, summary]) => {
+        if (summary.dataLenCompressed < summary.dataLenUncompressed) {
+            const row = [ext, summary.nbFiles, summary.nbFilesCompressed, formatBytes(summary.dataLenUncompressed), formatBytes(summary.dataLenCompressed), '-' + formatBytes(summary.dataLenUncompressed - summary.dataLenCompressed)];
+            dataTable.push(row);
+        }
+    });
+    const total = ['Total', state.total.nbFiles, state.total.nbFilesCompressed, formatBytes(state.total.dataLenUncompressed), formatBytes(state.total.dataLenCompressed), '-' + formatBytes(state.total.dataLenUncompressed - state.total.dataLenCompressed)];
+    dataTable.push(total);
+    console.log(table(dataTable, config));
+};
+const processFile = async (file, stats) => {
+    const result = {
+        file,
+        originalSize: stats.size,
+        compressedSize: stats.size
+    };
+    let writeData = undefined;
+    try {
+        const ext = path.extname(file);
+        switch (ext) {
+            case '.svg':
+            case '.png':
+            case '.jpg':
+            case '.jpeg':
+            case '.webp':
+            case '.gif':
+                const newImageData = await compressImageFile(file);
+                if (newImageData && newImageData.length < result.originalSize) {
+                    writeData = newImageData;
+                }
+                break;
+            case '.html':
+            case '.htm':
+                const htmldata = await fs.readFile(file);
+                const newhtmlData = await htmlminifier(htmldata.toString(), { minifyCSS: true, minifyJS: true, sortClassName: true, sortAttributes: true });
+                writeData = newhtmlData;
+                break;
+            case '.css':
+                const cssdata = await fs.readFile(file);
+                const newcssData = await csso(cssdata.toString()).css;
+                if (newcssData) {
+                    writeData = newcssData;
+                }
+                break;
+            case '.js':
+                const jsdata = await fs.readFile(file);
+                const newjsresult = await swc.minify(jsdata.toString(), { compress: true, mangle: true });
+                if (newjsresult.code && newjsresult.code.length < jsdata.length) {
+                    writeData = newjsresult.code;
+                }
+                break;
+        }
+    }
+    catch (e) {
+        // console error for the moment
+        console.error(e);
+    }
+    // Writedata
+    if (writeData && writeData.length < result.originalSize) {
+        result.compressedSize = writeData.length;
+        await fs.writeFile(file, writeData);
+    }
+    printProgress(result);
+    return result;
+};
+export const compressImage = async (data, resize) => {
+    const sharpFile = await sharp(data);
+    const meta = await sharpFile.metadata();
+    switch (meta.format) {
+        case 'svg':
+            const newData = svgo(data, {});
+            if (newData.error || newData.modernError) {
+                console.log(`Error processing svg ${data}`);
+                return undefined;
+            }
+            return Buffer.from(newData.data, 'utf8');
+        case 'png':
+        case 'jpg':
+        case 'jpeg':
+        case 'webp':
+        case 'gif':
+            return await sharpFile.resize(resize).toBuffer();
+    }
+    return undefined;
+};
+const compressImageFile = async (file) => {
+    const buffer = await fs.readFile(file);
+    return compressImage(buffer, {});
+};
+const processDirectory = async (directoryPath) => {
+    const filesInDirectory = await fs.readdir(directoryPath);
+    const files = await Promise.all(filesInDirectory.map(async (file) => {
+        const filePath = path.join(directoryPath, file);
+        const stats = await fs.stat(filePath);
+        if (stats.isDirectory()) {
+            return processDirectory(filePath);
+        }
+        else {
+            if (compressedFiles.includes(filePath)) {
+                return [];
+            }
+            return [await processFile(filePath, stats)];
+        }
+    }));
+    return files.filter((file) => file.length).flat(1); // Remove empty dir and flat it all
+};
+export async function compress(dir, initResult) {
+    beginProgress(initResult);
+    await processDirectory(dir);
+    endProgress();
+    printDetails();
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { compress } from './compress.js';
+import { optimize } from './optimize.js';
+const program = new Command();
+program
+    .name('jampack')
+    .description('Static website Optimizer')
+    .version('0.0.1');
+program.command('pack', { isDefault: true })
+    .description('todo')
+    .argument('<dir>', 'Directory to pack')
+    .action(async (str, options) => {
+    let compressedResults = [];
+    console.log(`PASS 1 - Optimizing...`);
+    compressedResults = await optimize(str);
+    console.log(`PASS 2 - Compressing...`);
+    await compress(str, compressedResults);
+});
+program.parse();

package/dist/optimize.d.ts

@@ -0,0 +1,2 @@
+import type { Result } from './types.js';
+export declare function optimize(dir: string): Promise<Result[]>;

package/dist/optimize.js

@@ -0,0 +1,225 @@
+import { globby } from 'globby';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import cheerio from 'cheerio';
+import { isLocal, isNumeric, translateSrc } from './utils.js';
+import sharp from "sharp";
+import options from './options.js';
+import { compressImage } from './compress.js';
+import svgToMiniDataURI from 'mini-svg-data-uri';
+const compressedImages = [];
+const compressedResults = [];
+async function analyse(dir, file) {
+    console.log('Processing ' + file);
+    const html = (await fs.readFile(path.join(dir, file))).toString();
+    const $ = cheerio.load(html, {});
+    const imgs = $('img');
+    const imgsArray = [];
+    imgs.each(async (index, imgElement) => {
+        imgsArray.push(imgElement);
+    });
+    // Process images sequentially
+    await imgsArray.reduce(async (previousPromise, imgElement) => {
+        await previousPromise;
+        return processImage(dir, file, $, imgElement);
+    }, Promise.resolve());
+    await fs.writeFile(path.join(dir, file), $.html());
+}
+async function processImage(dir, file, $, imgElement) {
+    const img = $(imgElement);
+    /*
+     * Attribute 'alt'
+     */
+    const attrib_alt = img.attr('alt');
+    if (attrib_alt === undefined) {
+        console.warn('<img> has no alt attribute - adding an empty but you should fix it');
+        img.attr('alt', "");
+    }
+    /*
+     * Attribute 'src'
+     */
+    const attrib_src = img.attr('src');
+    console.log(`- Image ${attrib_src}`);
+    if (!attrib_src) {
+        console.warn('<img> has no src attribute');
+        return;
+    }
+    if (attrib_src.startsWith('data:')) {
+        // Data URI image
+        // TODO: try to compress it
+        return;
+    }
+    if (!isLocal(attrib_src)) {
+        // Image not local, don't touch it
+        return;
+    }
+    /*
+     * Attribute 'loading'
+     */
+    const attr_loading = img.attr('loading');
+    switch (attr_loading) {
+        case undefined:
+            // Go lazy by default
+            img.attr('loading', 'lazy');
+            break;
+        case 'eager':
+            img.removeAttr('loading');
+            break;
+        case 'lazy':
+            // Don't touch it
+            break;
+        default:
+            console.warn(`Invalid loading attribute ${attr_loading}`);
+    }
+    /*
+     * Attribute 'decoding'
+     */
+    img.attr('decoding', 'async');
+    /*
+     * Loading image
+     */
+    const absoluteImgPath = translateSrc(dir, path.dirname(file), attrib_src);
+    // file exists?
+    try {
+        const stats = await fs.stat(absoluteImgPath);
+    }
+    catch (e) {
+        console.error(`Missing img ${absoluteImgPath}`);
+        return;
+    }
+    const sharpFile = sharp(absoluteImgPath);
+    const meta = await sharpFile.metadata();
+    const originalData = await fs.readFile(absoluteImgPath);
+    /*
+     * Embed small images
+     *
+     * Note: This check is done pre-compression so more opportunities could
+     * be done if done post compression.
+     */
+    let isEmbed = false;
+    if (originalData.length <= options.image.embed_size) {
+        let datauri = undefined;
+        switch (meta.format) {
+            case 'svg':
+                const compressedData = await compressImage(originalData, {});
+                const svgEmbed = (compressedData && compressedData.length < originalData.length) ? compressedData : originalData;
+                datauri = svgToMiniDataURI(svgEmbed.toString());
+                break;
+            case 'jpg':
+            case 'jpeg':
+            case 'png':
+            case 'webp':
+            case 'gif':
+                // TODO
+                break;
+        }
+        if (datauri) {
+            img.attr('src', datauri);
+            isEmbed = true;
+            img.removeAttr('loading');
+            img.removeAttr('decoding');
+        }
+    }
+    if (isEmbed) {
+        // Image is embed, no need for more processing
+        return;
+    }
+    /*
+     * Attribute 'width' & 'height'
+     */
+    const [w, h] = setImageSize(img, meta);
+    if (w < 0 || h < 0) {
+        console.warn(`Unexpected error in image size calculation - some optimizations can't be done`);
+        return;
+    }
+    /*
+     * Compress image
+     */
+    if (compressedImages.includes(absoluteImgPath)) {
+        // Image already compressed. Skip.
+        return;
+    }
+    const fileWidth = meta.width;
+    const fileHeight = meta.height;
+    const newImage = await compressImage(originalData, { width: w, height: h });
+    if (newImage && newImage.length < originalData.length) {
+        fs.writeFile(absoluteImgPath, newImage);
+        compressedImages.push(absoluteImgPath);
+        compressedResults.push({ file: absoluteImgPath, originalSize: originalData.length, compressedSize: newImage.length });
+    }
+    const attr_srcset = img.attr('srcset');
+    if (attr_srcset) {
+        // If srcset is set, don't touch it
+    }
+    else {
+        // Generate image set
+    }
+}
+function setImageSize(img, meta) {
+    let width = img.attr('width');
+    let height = img.attr('height');
+    let width_new = undefined;
+    let height_new = undefined;
+    // Check valid values
+    if (width !== undefined) {
+        if (!isNumeric(width)) {
+            console.warn(`Invalid width attribute "${width}" - overriding`);
+            width = undefined;
+        }
+    }
+    if (height !== undefined) {
+        if (!isNumeric(height)) {
+            console.warn(`Invalid width attribute "${height}" - overriding`);
+            height = undefined;
+        }
+    }
+    // If we don't have the metadata, we can't do much more
+    if (meta.width === undefined || meta.height === undefined) {
+        return [-1, -1];
+    }
+    const originalRatio = meta.width / meta.height;
+    if (width !== undefined && height !== undefined) {
+        // Both are provided
+        const w = parseInt(width, 10);
+        const h = parseInt(height, 10);
+        // Is ratio equal?
+        const providedRatio = Math.round(w / h * 10) / 10;
+        const imageRatio = Math.round(originalRatio * 10) / 10;
+        if (providedRatio !== imageRatio) {
+            console.warn(`Image aspect ratio in HTML (${providedRatio}) differs from image aspect ratio (${imageRatio}) - fix width and height or let jampack fill them.`);
+        }
+        return [w, h];
+    }
+    else if (width !== undefined && height === undefined) {
+        // Width is provided
+        width_new = parseInt(width, 10);
+        height_new = width_new / originalRatio;
+    }
+    else if (width === undefined && height !== undefined) {
+        // Height is provided
+        height_new = parseInt(height, 10);
+        width_new = height_new * originalRatio;
+    }
+    else {
+        // No width or height provided - set both to image size
+        width_new = meta.width;
+        height_new = meta.height;
+    }
+    // New sizes
+    if (width_new !== undefined && height_new !== undefined) {
+        img.attr('width', width_new.toFixed(0));
+        img.attr('height', height_new.toFixed(0));
+        return [Math.round(width_new), Math.round(height_new)];
+    }
+    // Something when wrong
+    throw new Error('Unexpected issue when resolving image sizes');
+}
+export async function optimize(dir) {
+    const paths = await globby('**/*.{htm,html}', { cwd: dir });
+    // Sequential async
+    await paths.reduce(async (previousPromise, item) => {
+        await previousPromise;
+        return analyse(dir, item);
+    }, Promise.resolve());
+    return compressedResults;
+}

package/dist/options.d.ts

@@ -0,0 +1,9 @@
+export declare type Options = {
+    image: {
+        embed_size: number;
+        srcset_min_width: number;
+        srcset_max_width: number;
+    };
+};
+declare const default_options: Options;
+export default default_options;

package/dist/options.js

@@ -0,0 +1,8 @@
+const default_options = {
+    image: {
+        embed_size: 800,
+        srcset_min_width: 640 * 2,
+        srcset_max_width: 5120
+    }
+};
+export default default_options;

package/dist/types.d.ts

@@ -0,0 +1,5 @@
+export declare type Result = {
+    file: string;
+    originalSize: number;
+    compressedSize: number;
+};

package/dist/types.js

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

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function formatBytes(bytes: number, decimals?: number): string;
+export declare function isLocal(src: string): boolean;
+export declare function translateSrc(projectRoot: string, htmlRelativePath: string, src: string): string;
+export declare function isNumeric(value: string): boolean;

package/dist/utils.js

@@ -0,0 +1,25 @@
+import * as url from 'url';
+import * as path from 'path';
+export function formatBytes(bytes, decimals = 2) {
+    if (!+bytes)
+        return '0 Bytes';
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
+}
+export function isLocal(src) {
+    const u = url.parse(src);
+    return !u.host;
+}
+export function translateSrc(projectRoot, htmlRelativePath, src) {
+    if (!isLocal(src)) {
+        throw new Error('Source should be local');
+    }
+    const srcAbsolutePath = path.join(projectRoot, src.startsWith('/') ? '' : htmlRelativePath, src);
+    return srcAbsolutePath;
+}
+export function isNumeric(value) {
+    return /^\d+$/.test(value);
+}

package/package.json

@@ -1,43 +1,56 @@
 {
   "name": "@divriots/jampack",
-  "version": "0.0.9",
-  "description": "",
-  "keywords": [],
-  "main": "./dist/index.js",
+  "version": "0.1.1",
+  "description": "Packer for static websites",
+  "author": "Georges Gomes @georges-gomes",
   "bin": {
-    "jampack": "./dist/jampack.js"
+    "jampack": "dist/index.js"
   },
+  "homepage": "https://github.com/divriots/jampack",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "type": "module",
+  "repository": "divriots/jampack",
   "files": [
-    "dist"
+    "/bin",
+    "/dist"
   ],
-  "engines": {
-    "node": ">=10.0.0"
+  "dependencies": {
+    "@swc/core": "^1.3.3",
+    "@types/cheerio": "^0.22.31",
+    "@types/commander": "^2.12.2",
+    "@types/csso": "^5.0.0",
+    "@types/html-minifier-terser": "^7.0.0",
+    "@types/sharp": "^0.31.0",
+    "@types/svgo": "^2.6.4",
+    "@types/table": "^6.3.2",
+    "cheerio": "0.22.0",
+    "commander": "^9.4.0",
+    "csso": "^5.0.5",
+    "globby": "^13.1.2",
+    "html-minifier-terser": "^7.0.0",
+    "mini-svg-data-uri": "^1.4.4",
+    "sharp": "^0.31.0",
+    "svgo": "^2.8.0",
+    "table": "^6.8.0"
+  },
+  "devDependencies": {
+    "@types/node": "^16.9.4",
+    "shx": "^0.3.3",
+    "ts-node": "^10.2.1",
+    "tslib": "^2.3.1",
+    "typescript": "^4.4.3"
   },
   "scripts": {
-    "build": "tsc --project ./tsconfig.json",
-    "watch": "tsc --project ./tsconfig.json --watch",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "watch": "pnpm build --watch",
+    "try": "shx rm -fr demo && cp -R demo_ref demo && node ./dist/index.js",
+    "build": "shx rm -rf dist && tsc -b",
+    "lint": "eslint . --ext .ts --config .eslintrc"
   },
-  "author": "",
-  "license": "ISC",
-  "devDependencies": {
-    "@types/node": "^14.0.5",
-    "typescript": "^3.9.3"
+  "engines": {
+    "node": ">=14.0.0"
   },
-  "dependencies": {
-    "@open-wc/rollup-plugin-html": "^1.1.0",
-    "@rollup/plugin-node-resolve": "^10.0.0",
-    "@types/commander": "^2.12.2",
-    "@types/parse5": "^5.0.3",
-    "commander": "^5.1.0",
-    "es-dev-server": "^1.54.0",
-    "fast-glob": "^3.2.2",
-    "htmlparser2": "^4.1.0",
-    "posthtml": "^0.13.0",
-    "posthtml-collect-styles": "0.0.1",
-    "posthtml-link-noreferrer": "^1.0.7",
-    "posthtml-minifier": "^0.1.0",
-    "rollup": "^2.11.2",
-    "rollup-plugin-terser": "^6.1.0"
-  }
+  "bugs": "https://github.com/divriots/jampack/issues",
+  "keywords": [],
+  "types": "dist/index.d.ts"
 }

package/dist/11ty/index.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const transformNodeResolve_1 = require("./transformNodeResolve");
-module.exports = function (eleventyConfig, pluginNamespace) {
-    console.log("Loading jampack " + require("../../package.json").version);
-    eleventyConfig.namespace(pluginNamespace, () => {
-        eleventyConfig.addTransform("html", transformNodeResolve_1.transformNodeResolve);
-    });
-};

package/dist/11ty/transformNodeResolve.js

@@ -1,73 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformNodeResolve = void 0;
-const rollup_plugin_html_1 = __importDefault(require("@open-wc/rollup-plugin-html"));
-const plugin_node_resolve_1 = __importDefault(require("@rollup/plugin-node-resolve"));
-const rollup = __importStar(require("rollup"));
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const tools_1 = require("../tools");
-async function transformNodeResolve(content, outputPath) {
-    if (!outputPath.endsWith(".html"))
-        return content;
-    if (!tools_1.hasScriptModules(content))
-        return content;
-    const filename = path_1.default.basename(outputPath);
-    const outputDir = path_1.default.dirname(outputPath);
-    const inputOptions = {
-        plugins: [
-            rollup_plugin_html_1.default({
-                rootDir: outputDir,
-                name: filename,
-                html: content,
-                minify: false,
-            }),
-            plugin_node_resolve_1.default({
-                customResolveOptions: {
-                    basedir: process.cwd(),
-                },
-            }),
-        ],
-    };
-    const outputOptions = {
-        format: "esm",
-        dir: outputDir,
-    };
-    const bundle = await rollup.rollup(inputOptions);
-    // Generate
-    const { output } = await bundle.generate(outputOptions);
-    const indexhtml = output.find((asset) => asset.fileName === filename).source;
-    // Write the rest of the modules
-    output
-        .filter((asset) => asset.type === "chunk")
-        .forEach((asset) => {
-        if (asset.code !== undefined) {
-            fs_1.default.mkdirSync(outputDir, { recursive: true });
-            fs_1.default.writeFileSync(path_1.default.join(outputDir, asset.fileName), asset.code);
-        }
-    });
-    return indexhtml;
-}
-exports.transformNodeResolve = transformNodeResolve;

package/dist/cmd-bake.js

@@ -1,24 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const packer_1 = require("./packer");
-const fast_glob_1 = __importDefault(require("fast-glob"));
-const chalk_1 = __importDefault(require("chalk"));
-async function bake(config, options) {
-    const isProduction = !options.quick;
-    if (isProduction)
-        process.env.NODE_ENV = "production";
-    const entries = await fast_glob_1.default(["**/index.html"], {
-        cwd: config.rootDir,
-        followSymbolicLinks: false,
-    });
-    if (entries.length <= 0) {
-        throw new Error("No index.html found in " + config.rootDir);
-    }
-    console.log("Targeting:");
-    entries.forEach((f) => console.log(chalk_1.default.gray("> " + f)));
-    await packer_1.pack(config.rootDir, entries, isProduction, config);
-}
-exports.default = bake;

package/dist/cmd-serve.js

@@ -1,41 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const es_dev_server_1 = require("es-dev-server");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-function createSymlinkToNodeModules(config) {
-    const rootNodeModules = path_1.default.join(config.rootDir, "node_modules");
-    try {
-        fs_1.default.unlinkSync(rootNodeModules);
-    }
-    catch (e) {
-        // No problem
-    }
-    try {
-        fs_1.default.symlinkSync(path_1.default.join(process.cwd(), config.modulesDir), rootNodeModules);
-    }
-    catch (e) {
-        // Let's assume it's all good
-        console.error("Error creating symlink to node_modules", e);
-    }
-    return rootNodeModules;
-}
-function serve(config) {
-    // Set development mode
-    process.env.NODE_ENV = "development";
-    const rootNodeModules = createSymlinkToNodeModules(config);
-    es_dev_server_1.startServer(es_dev_server_1.createConfig({
-        port: config.servePort,
-        rootDir: config.rootDir,
-        logStartup: true,
-        logErrorsToBrowser: true,
-        watch: true,
-        nodeResolve: true,
-        moduleDirs: [rootNodeModules],
-        preserveSymlinks: true,
-    }));
-}
-exports.default = serve;

package/dist/default.config.js

@@ -1,62 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadConfig = void 0;
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const defaultConfig = {
-    // Source folder
-    rootDir: "./dist",
-    // Where to start resolving node_modules from
-    modulesDir: "./",
-    // jampack serve listening port
-    servePort: 8080,
-    // Processors
-    proc_html_minifier: {
-        collapseWhitespace: true,
-        minifyCSS: true,
-        removeComments: true,
-        removeRedundantAttributes: true,
-        minifyJS: true,
-        sortAttributes: true,
-        sortClassName: true,
-    },
-    proc_html_link_noreferrer: true,
-};
-const configFileName = path_1.default.join(process.cwd(), "./.jampack.config.js");
-async function loadConfig() {
-    let config = defaultConfig;
-    if (fs_1.default.existsSync(configFileName)) {
-        const localConfig = await Promise.resolve().then(() => __importStar(require(configFileName)));
-        config = Object.assign(defaultConfig, localConfig);
-    }
-    else {
-        console.log("No config file - Using default config\n");
-    }
-    console.log("Using config:");
-    console.log(config);
-    console.log("");
-    return config;
-}
-exports.loadConfig = loadConfig;

package/dist/jampack.js

@@ -1,32 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const commander_1 = __importDefault(require("commander"));
-const cmd_serve_js_1 = __importDefault(require("./cmd-serve.js"));
-const cmd_bake_js_1 = __importDefault(require("./cmd-bake.js"));
-const package_json_1 = __importDefault(require("../package.json"));
-const default_config_js_1 = require("./default.config.js");
-commander_1.default.version(package_json_1.default.version, "-v, --version");
-commander_1.default
-    .command("bake")
-    .description("Optimize site for production")
-    .option("--quick", "Fast optimisation (for development)")
-    .action(async function (options) {
-    cmd_bake_js_1.default(await default_config_js_1.loadConfig(), options);
-});
-commander_1.default
-    .command("serve")
-    .description("Serves website for development - resolves bare import on demand")
-    .action(async function (options) {
-    cmd_serve_js_1.default(await default_config_js_1.loadConfig());
-});
-commander_1.default.parse(process.argv);
-["exit", "SIGINT"].forEach((event) => {
-    // @ts-ignore
-    process.on(event, () => {
-        process.exit(0);
-    });
-});

package/dist/packer.js

@@ -1,132 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pack = void 0;
-const rollup = __importStar(require("rollup"));
-const rollup_plugin_terser_1 = require("rollup-plugin-terser");
-const rollup_plugin_html_1 = __importDefault(require("@open-wc/rollup-plugin-html"));
-const plugin_node_resolve_1 = __importDefault(require("@rollup/plugin-node-resolve"));
-const path_1 = __importDefault(require("path"));
-const chalk_1 = __importDefault(require("chalk"));
-const tools_1 = require("./tools");
-const posthtml_1 = __importDefault(require("posthtml"));
-const posthtml_minifier_1 = __importDefault(require("posthtml-minifier"));
-const posthtml_link_noreferrer_1 = __importDefault(require("posthtml-link-noreferrer"));
-const posthtml_collect_styles_1 = __importDefault(require("posthtml-collect-styles"));
-const fs_1 = __importDefault(require("fs"));
-async function processJSModules(rootDir, files, isProduction, config) {
-    const htmlfiles = Object.entries(files)
-        .filter(([, content]) => tools_1.hasScriptModules(content))
-        .map(([name, content]) => {
-        return {
-            name: name,
-            html: content,
-        };
-    });
-    const htmlplugin = rollup_plugin_html_1.default({
-        rootDir,
-        html: htmlfiles,
-        minify: false,
-    });
-    if (htmlfiles.length < 1) {
-        // Nothing to do here
-        return;
-    }
-    const plugins = [htmlplugin];
-    plugins.push(plugin_node_resolve_1.default({
-        customResolveOptions: {
-            basedir: config.modulesDir,
-        },
-    }));
-    if (isProduction)
-        plugins.push(rollup_plugin_terser_1.terser());
-    const inputOptions = {
-        plugins,
-    };
-    const outputOptions = {
-        format: "esm",
-        dir: rootDir,
-    };
-    const bundle = await rollup.rollup(inputOptions);
-    const { output } = await bundle.generate(outputOptions);
-    // Write the rest of the modules
-    output.forEach((asset) => {
-        files[asset.fileName] = asset.code || asset.source;
-    });
-}
-async function processHTML(rootDir, files, isProduction, config) {
-    const htmlTransform = async (html) => {
-        let ph = posthtml_1.default();
-        if (config.proc_html_link_noreferrer === true) {
-            ph = ph.use(posthtml_link_noreferrer_1.default());
-        }
-        if (true) {
-            ph = ph.use(posthtml_collect_styles_1.default());
-        }
-        if (config.proc_html_minifier !== false) {
-            ph = ph.use(posthtml_minifier_1.default(config.proc_html_minifier));
-        }
-        return ph.process(html).then(function (result) {
-            return result.html;
-        });
-    };
-    const tasks = Object.entries(files).map(async ([name, data]) => {
-        if (name.endsWith(".html"))
-            files[name] = await htmlTransform(data);
-    });
-    return Promise.all(tasks);
-}
-async function pack(rootDir, entries, isProduction, config) {
-    if (entries.length < 1) {
-        throw new Error("No entry files to process");
-    }
-    // Load entries
-    const originalFiles = {};
-    entries.forEach((e) => {
-        const name = e;
-        const content = fs_1.default.readFileSync(path_1.default.join(rootDir, name)).toString();
-        originalFiles[name] = content;
-    });
-    const processedFiles = Object.assign({}, originalFiles);
-    console.log(chalk_1.default.green("Packing..."));
-    const start_pack = Date.now();
-    await processJSModules(rootDir, processedFiles, isProduction, config);
-    if (isProduction) {
-        await processHTML(rootDir, processedFiles, isProduction, config);
-    }
-    // Packing done
-    const end_pack = Date.now();
-    console.log(chalk_1.default.green("Packed in " + (end_pack - start_pack) + "ms"));
-    // Writing files
-    Object.entries(processedFiles).forEach(([name, content]) => {
-        if (!originalFiles[name] || originalFiles[name] !== content) {
-            console.log("Writing: " + name);
-            fs_1.default.writeFile(path_1.default.join(rootDir, name), content, (err) => {
-                if (err)
-                    throw err;
-            });
-        }
-    });
-}
-exports.pack = pack;

package/dist/tools.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasScriptModules = void 0;
-const htmlparser2_1 = require("htmlparser2");
-function hasScriptModules(content) {
-    let hasmodule = false;
-    const parser = new htmlparser2_1.Parser({
-        onopentag(name, attribs) {
-            if (name === "script" && attribs.type === "module") {
-                hasmodule = true;
-                parser.done();
-            }
-        },
-    });
-    parser.write(content);
-    parser.end();
-    return hasmodule;
-}
-exports.hasScriptModules = hasScriptModules;