@rollup-extras/plugin-html 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Konstantin Shutkin
+
+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,208 @@
+# Plugin Html
+
+Rollup plugin to inject assets names into html template.
+
+Points:
+
+- Inject file names with hashes
+- Watch on a template file and trigger rebuild if it is changed
+- Provides minimalistic template by default, so you are ready to start without configuration
+- Support mutliple rollup configs (will trigger only when last output generated)
+- Extensible through API so you can plug in something for html processing or generate new types of html elements
+
+Uses [`@niceties/logger`](https://github.com/kshutkin/niceties/blob/main/logger/README.md) to log messages, can be configured through `@niceties/logger` API.
+
+[Changlelog](./CHANGELOG.md)
+
+## Installation
+
+Using npm:
+```
+npm install --save-dev @rollup-extras/plugin-html
+```
+
+## Usage
+
+```javascript
+import html from '@rollup-extras/plugin-html';
+
+export default {
+    input: 'src/index.js',
+
+    output: {
+        format: 'es',
+        dir: 'dest'
+    },
+
+    plugins: [html()],
+} 
+```
+
+## Providing options
+
+Just pass options to the plugin function. Returned object is the plugin instance which can be passed to rollup.
+
+```javascript
+html({option: value, option2: value2})
+```
+
+For additional plugin instances (in case of multiple configs) please use: `firstInstance.api.addInstance()`
+
+## Options
+
+### pluginName
+
+Optional, string.
+
+For debugging purposes, so many instances of a plugin can be differenciated in debugging output.
+
+### outputFile
+
+Optional, string, default: `'index.html'`.
+
+Use to override output file name. If file name with the same name exits in pipeline it will be removed or overwritten in the process but its content by default will be used as an input for this plugin. In the following example file emitted by copy plugin will be used as an input for this plugin:
+
+```javascript
+import copy from '@rollup-extras/plugin-copy';
+import html from '@rollup-extras/plugin-html';
+
+export default {
+    input: 'src/index.js',
+
+    output: {
+        format: 'es',
+        dir: 'dest'
+    },
+
+    plugins: [copy('src/index.html'), html()],
+};
+```
+
+### template
+
+Optional, string, default: `'<!DOCTYPE html><html><head></head><body></body></html>'`.
+
+Default template string or template file name. If it is a template string it should contain `</head>` and `</body>` substrings to be useful by default template factory.
+
+### watch
+
+Optional, boolean, default: true.
+
+If plugin found a template file name this option defines if plugin need to watch it or not.
+
+### emitFile
+
+Optional, boolean, default: true.
+
+Defines if plugin should use this.emitFile or should just write it to disk. Option can be ignored in setup with mutliple rollup configs.
+
+### useEmittedTemplate
+
+Optional, boolean, default: true.
+
+Defines what plugin does if it finds a file with expected file name in bundle. By default it will be used as a template. Template provided through template option should be of higher priority to the plugin.
+
+### conditionalLoading
+
+Optional, boolean, default: undefined.
+
+Defines if plugin adds `nomodule` attribute for non modular js chunks. By default it is done only if we have `es` outputs in one of the bundles processed by plugin. Also plugin values `iife` outputs higher than `umd` and if we have both filters out `umd` ones. This can be changes only by providing custom `assetFactory`.
+
+### injectIntoHead
+
+Optional, RegExp | function | boolean, default: `(fileName: string) => fileName.endsWith(cssExtention)`.
+
+Option to customize what assets should be injected into head element of a template.
+
+### ignore
+
+Optional, RegExp | function | boolean, default: false.
+
+Option to customize what assets should be ignored in process.
+
+### verbose
+
+Optional, boolean, default: false.
+
+Option to print more debug information into console (with default appender).
+
+### useWriteBundle
+
+Optional, boolean, default: false.
+
+Option to use `writeBundle` hook instead of `generateBundle`.
+
+### assetsFactory
+
+Optional, function (please check type in configuration section).
+
+To process additional types of assets / enchance default behavior. If known asset processed by factory (it returned an object, string or promise) plugin skips default processing for this asset.
+
+Example (adds integrity attribute to a css file):
+```javascript
+import copy from '@rollup-extras/plugin-copy';
+import html from '@rollup-extras/plugin-html';
+import crypto from 'crypto';
+
+export default {
+    input: 'src/index.js',
+
+    output: {
+        format: 'es',
+        dir: 'dest'
+    },
+
+    plugins: [copy('src/test.css'), html({
+        assetsFactory: (fileName, content) => {
+            if (fileName.endsWith('.css')) {
+                const data = crypto
+                    .createHash('sha384')
+                    .update(content);
+                return `<link rel="stylesheet" href="${fileName}" integrity="sha384-${data.digest('base64')}" type="text/css">`;
+            }
+            return undefined;
+        }
+    })],
+};
+```
+
+### templateFactory
+
+Optional, function (please check type in configuration section).
+
+Use to customize template with external libraries.
+
+Example (pretty print html):
+
+```javascript
+import html from '@rollup-extras/plugin-html';
+import sb from 'simply-beautiful';
+
+export default {
+    input: 'src/index.js',
+
+    output: {
+        format: 'es',
+        dir: 'dest'
+    },
+
+    plugins: [html({
+        templateFactory: (template, assets, defaultFactory) => sb.html(defaultFactory(template, assets))
+    })],
+};
+```
+
+## Configuration
+
+[Definition of config typings in typescript](./src/types.ts)
+
+## Prior Art
+
+- https://github.com/haifeng2013/rollup-plugin-bundle-html
+- https://github.com/rollup/plugins/tree/master/packages/html
+- https://github.com/modernweb-dev/web/tree/master/packages/rollup-plugin-html
+- https://github.com/posthtml/posthtml#rollup
+
+# License
+
+[MIT](./LICENSE)

package/dist/index.cjs

@@ -0,0 +1,334 @@
+'use strict';
+
+var fs = require('fs/promises');
+var oldStyleFs = require('fs');
+var path = require('path');
+var logger = require('@niceties/logger');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var oldStyleFs__default = /*#__PURE__*/_interopDefaultLegacy(oldStyleFs);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+
+const defaultTemplate = '<!DOCTYPE html><html><head></head><body></body></html>';
+const headClosingElement = '</head>';
+const bodyClosingElement = '</body>';
+const cssExtention = '.css';
+function index (options = {}) {
+    const { pluginName, outputFile, template, watch, emitFile, conditionalLoading, logger, useWriteBundle, logLevel, useEmittedTemplate, injectIntoHead, ignore, assetsFactory, templateFactory } = normalizeOptions(options), hasCustomTemplateFactory = 'templateFactory' in options;
+    let templateString = defaultTemplate, hasTemplateFile = false;
+    if (template) {
+        if (isUsableByDefaultTemplateFactory(template)) {
+            templateString = template;
+        }
+        else {
+            if (watch) {
+                try {
+                    // using sync fs call because we need to return plugin object immidiately
+                    useNewTemplate(oldStyleFs__default["default"].readFileSync(template, { encoding: 'utf8' }));
+                    hasTemplateFile = true;
+                }
+                catch (e) {
+                    handleTemplateReadError(e);
+                }
+            }
+            else {
+                templateString = new Promise(resolve => {
+                    fs__default["default"].readFile(template, { encoding: 'utf8' })
+                        .then((newTemplateString) => {
+                        if (!isUsableByDefaultTemplateFactory(newTemplateString) && !hasCustomTemplateFactory) {
+                            warnAboutUsingDefaultTemplate();
+                            resolve(defaultTemplate);
+                        }
+                        else {
+                            resolve(newTemplateString);
+                        }
+                    })
+                        .catch(handleTemplateReadError);
+                });
+            }
+        }
+    }
+    let remainingOutputsCount = 0, configsCount = 0, initialDir = '', fileNameInInitialDir, assets = freshAssets();
+    const configs = new Set(), finalHook = useWriteBundle ? 'writeBundle' : 'generateBundle', processedFiles = new Set();
+    const instance = {
+        name: pluginName,
+        renderStart: (options) => {
+            logger('started collecting information', logLevel);
+            initialDir = options.dir || '';
+            fileNameInInitialDir = path__default["default"].join(initialDir, outputFile);
+            return renderStart();
+        },
+        [finalHook]: generateBundle,
+        api: { addInstance }
+    };
+    if (hasTemplateFile && watch) {
+        instance.buildStart = async function () {
+            try {
+                useNewTemplate(await fs__default["default"].readFile(template, { encoding: 'utf8' }));
+            }
+            catch (e) {
+                handleTemplateReadError(e);
+            }
+            await buildStart.apply(this);
+        };
+    }
+    return instance;
+    function freshAssets() {
+        return {
+            asset: [],
+            es: [],
+            iife: [],
+            umd: []
+        };
+    }
+    function useNewTemplate(newTemplateString) {
+        if (!isUsableByDefaultTemplateFactory(newTemplateString) && !hasCustomTemplateFactory) {
+            warnAboutUsingDefaultTemplate();
+        }
+        else {
+            templateString = newTemplateString;
+        }
+    }
+    function handleTemplateReadError(e) {
+        var _a;
+        if (((_a = e) === null || _a === void 0 ? void 0 : _a.code) === 'ENOENT') {
+            logger('template nor a file or string', 2 /* warn */, e);
+        }
+        else {
+            logger(`error reading template\n${e}`, 2 /* warn */, e);
+        }
+    }
+    function warnAboutUsingDefaultTemplate() {
+        logger('template is unusable by default template factory, using default one', 2 /* warn */);
+    }
+    function addInstance() {
+        const configId = ++configsCount;
+        configs.add(configId);
+        const instance = {
+            name: `${pluginName}#${configId}`,
+            renderStart: () => {
+                configs.delete(configId);
+                return renderStart();
+            },
+            [finalHook]: generateBundle
+        };
+        if (hasTemplateFile && watch) {
+            instance.buildStart = buildStart;
+        }
+        return instance;
+    }
+    async function buildStart() {
+        this.addWatchFile('src/index.html');
+    }
+    function renderStart() {
+        ++remainingOutputsCount;
+    }
+    async function generateBundle(options, bundle) {
+        --remainingOutputsCount;
+        await getAssets(options, bundle);
+        const statistics = Object.keys(assets)
+            .map(key => ({ key, count: assets[key].length }))
+            .filter(item => item.count)
+            .map(({ key, count }) => `${key}: ${count}`)
+            .join(', ');
+        logger(`assets collected: [${statistics}], remaining: ${remainingOutputsCount} outputs, ${configs.size} configs`, logLevel);
+        const dir = options.dir || '', fileName = path__default["default"].relative(dir, fileNameInInitialDir);
+        if (fileName in bundle) {
+            if (useEmittedTemplate) {
+                logger(`using exiting emitted ${fileName} as an input for out templateFactory`, logLevel);
+                const source = bundle[fileName].type === 'asset' ? bundle[fileName].source.toString() : bundle[fileName].code;
+                useNewTemplate(source);
+            }
+            else {
+                logger(`removing exiting emitted ${fileName}`, logLevel);
+            }
+            if (configs.size === 0 && emitFile && !useWriteBundle) {
+                delete bundle[fileName];
+            }
+        }
+        if (configs.size === 0 && remainingOutputsCount === 0) {
+            logger.start('generating html', logLevel);
+            try {
+                const depromisifiedTemplateString = await templateString, source = await templateFactory(depromisifiedTemplateString, assets, defaultTemplateFactory);
+                if (!emitFile || fileName.startsWith('..') || useWriteBundle) {
+                    if (emitFile && emitFile !== 'auto') {
+                        logger('cannot emitFile because it is outside of current output.dir, using writeFile instead', logLevel);
+                    }
+                    await fs__default["default"].mkdir(path__default["default"].dirname(fileNameInInitialDir), { recursive: true });
+                    await fs__default["default"].writeFile(fileNameInInitialDir, source);
+                }
+                else {
+                    this.emitFile({
+                        type: 'asset',
+                        fileName,
+                        source
+                    });
+                }
+                // reset assets and configs for next iteration
+                assets = freshAssets();
+                for (let i = configsCount; i > 0; --i) {
+                    configs.add(i);
+                }
+                processedFiles.clear();
+                logger.finish('html file generated');
+            }
+            catch (e) {
+                logger(`error generating html file\n${e}`, 3 /* error */, e);
+                logger.finish('html generation failed', 3 /* error */);
+            }
+        }
+    }
+    async function getAssets(options, bundle) {
+        const dir = options.dir || '';
+        for (const fileName of Object.keys(bundle)) {
+            const relativeToRootAssetPath = path__default["default"].join(dir, fileName);
+            if (ignore(relativeToRootAssetPath) || processedFiles.has(relativeToRootAssetPath)) {
+                continue;
+            }
+            processedFiles.add(relativeToRootAssetPath);
+            if (bundle[fileName].type == 'asset') {
+                if (await useAssetFactory(fileName, relativeToRootAssetPath, bundle[fileName].source, 'asset')) {
+                    continue;
+                }
+                if (fileName.endsWith(cssExtention)) {
+                    const assetPath = path__default["default"].relative(initialDir, relativeToRootAssetPath);
+                    assets.asset.push({
+                        html: getLinkElement(assetPath),
+                        head: injectIntoHead(relativeToRootAssetPath),
+                        type: 'asset'
+                    });
+                    continue;
+                }
+            }
+            else if (bundle[fileName].type == 'chunk') {
+                const chunk = bundle[fileName];
+                if (chunk.isEntry) {
+                    if (await useAssetFactory(fileName, relativeToRootAssetPath, chunk.code, options.format)) {
+                        continue;
+                    }
+                    if (options.format === 'es' || options.format === 'iife' || options.format === 'umd') {
+                        const assetPath = path__default["default"].relative(initialDir, relativeToRootAssetPath);
+                        assets[options.format].push({
+                            html: (assets) => {
+                                let useConditionalLoading = conditionalLoading;
+                                useConditionalLoading !== null && useConditionalLoading !== void 0 ? useConditionalLoading : (useConditionalLoading = !!((assets.iife.length
+                                    || assets.umd.length)
+                                    && assets.es.length));
+                                return (options.format === 'iife' || options.format === 'umd') ? getNonModuleScriptElement(assetPath, useConditionalLoading) : getModuleScriptElement(assetPath);
+                            },
+                            head: injectIntoHead(relativeToRootAssetPath),
+                            type: 'asset'
+                        });
+                    }
+                }
+            }
+        }
+    }
+    async function useAssetFactory(fileName, relativeToRootAssetPath, source, format) {
+        if (assetsFactory) {
+            try {
+                let asset = await assetsFactory(fileName, source, format);
+                if (asset) {
+                    if (typeof asset === 'string') {
+                        asset = {
+                            html: asset,
+                            head: injectIntoHead(relativeToRootAssetPath),
+                            type: format
+                        };
+                    }
+                    if (!assets[asset.type]) {
+                        assets[asset.type] = [];
+                    }
+                    assets[asset.type].push(asset);
+                    return true;
+                }
+            }
+            catch (e) {
+                logger(`exception in assetFactory:${e}`, 2 /* warn */, e);
+            }
+        }
+        return false;
+    }
+}
+function isUsableByDefaultTemplateFactory(template) {
+    return template.indexOf(headClosingElement) >= 0 && template.indexOf(bodyClosingElement) >= 0;
+}
+function getLinkElement(fileName) {
+    return `<link rel="stylesheet" href="${fileName}" type="text/css">`;
+}
+function getNonModuleScriptElement(fileName, conditionalLoading) {
+    return `<script src="${fileName}" type="text/javascript"${conditionalLoading ? ' nomodule' : ''}></script>`;
+}
+function getModuleScriptElement(fileName) {
+    return `<script src="${fileName}" type="module"></script>`;
+}
+function normalizeOptions(userOptions) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const options = {
+        pluginName: (_a = userOptions.pluginName) !== null && _a !== void 0 ? _a : '@rollup-extras/plugin-html',
+        template: userOptions.template,
+        outputFile: (_b = userOptions.outputFile) !== null && _b !== void 0 ? _b : 'index.html',
+        watch: (_c = userOptions.watch) !== null && _c !== void 0 ? _c : true,
+        useWriteBundle: (_d = userOptions.useWriteBundle) !== null && _d !== void 0 ? _d : false,
+        useEmittedTemplate: (_e = userOptions.useEmittedTemplate) !== null && _e !== void 0 ? _e : !('template' in userOptions),
+        emitFile: (_f = userOptions.emitFile) !== null && _f !== void 0 ? _f : 'auto',
+        logLevel: userOptions.verbose ? 1 /* info */ : 0 /* verbose */,
+        conditionalLoading: userOptions.conditionalLoading,
+        injectIntoHead: (fileName) => fileName.endsWith(cssExtention),
+        ignore: toAssetPredicate(false),
+        assetsFactory: userOptions.assetsFactory,
+        templateFactory: (_g = userOptions.templateFactory) !== null && _g !== void 0 ? _g : ((template, assets, defaultTemplateFactory) => defaultTemplateFactory(template, assets)),
+    }, logger$1 = options.logger = logger.createLogger(options.pluginName), optionIgnoredText = 'option ignored because it is not a function, RegExp or boolean';
+    if (userOptions.injectIntoHead != null) {
+        const predicate = toAssetPredicate(userOptions.injectIntoHead);
+        if (predicate) {
+            options.injectIntoHead = predicate;
+        }
+        else {
+            logger$1(`injectIntoHead ${optionIgnoredText}`, 2 /* warn */);
+        }
+    }
+    if (userOptions.ignore != null) {
+        const predicate = toAssetPredicate(userOptions.ignore);
+        if (predicate) {
+            options.ignore = predicate;
+        }
+        else {
+            logger$1(`ignore ${optionIgnoredText}`, 2 /* warn */);
+        }
+    }
+    return options;
+}
+function toAssetPredicate(sourceOption) {
+    if (typeof sourceOption === 'boolean') {
+        return () => sourceOption;
+    }
+    else if (typeof sourceOption === 'function') {
+        return sourceOption;
+    }
+    else if (sourceOption instanceof RegExp) {
+        return (fileName) => sourceOption.test(fileName);
+    }
+    return undefined;
+}
+function defaultTemplateFactory(template, assets) {
+    const assetsAsArray = assets.asset
+        .concat((assets.iife.length ? assets.iife : assets.umd))
+        .concat(assets.es)
+        .map((asset) => {
+        if (typeof asset.html === 'function') {
+            asset.html = asset.html(assets);
+        }
+        return asset;
+    });
+    const headElements = assetsAsArray.filter(asset => asset.head).map(asset => asset.html);
+    const bodyElements = assetsAsArray.filter(asset => !asset.head).map(asset => asset.html);
+    const headIndex = template.toLowerCase().indexOf(headClosingElement);
+    template = `${template.substring(0, headIndex)}${headElements.join('')}${template.substring(headIndex)}`;
+    const bodyIndex = template.toLowerCase().indexOf(bodyClosingElement);
+    return `${template.substring(0, bodyIndex)}${bodyElements.join('')}${template.substring(bodyIndex)}`;
+}
+
+module.exports = index;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { PluginHooks } from 'rollup';
+import { HtmlPluginOptions } from './types';
+export default function (options?: HtmlPluginOptions): Partial<PluginHooks>;

package/dist/index.mjs

@@ -0,0 +1,326 @@
+import fs from 'fs/promises';
+import oldStyleFs from 'fs';
+import path from 'path';
+import { createLogger } from '@niceties/logger';
+
+const defaultTemplate = '<!DOCTYPE html><html><head></head><body></body></html>';
+const headClosingElement = '</head>';
+const bodyClosingElement = '</body>';
+const cssExtention = '.css';
+function index (options = {}) {
+    const { pluginName, outputFile, template, watch, emitFile, conditionalLoading, logger, useWriteBundle, logLevel, useEmittedTemplate, injectIntoHead, ignore, assetsFactory, templateFactory } = normalizeOptions(options), hasCustomTemplateFactory = 'templateFactory' in options;
+    let templateString = defaultTemplate, hasTemplateFile = false;
+    if (template) {
+        if (isUsableByDefaultTemplateFactory(template)) {
+            templateString = template;
+        }
+        else {
+            if (watch) {
+                try {
+                    // using sync fs call because we need to return plugin object immidiately
+                    useNewTemplate(oldStyleFs.readFileSync(template, { encoding: 'utf8' }));
+                    hasTemplateFile = true;
+                }
+                catch (e) {
+                    handleTemplateReadError(e);
+                }
+            }
+            else {
+                templateString = new Promise(resolve => {
+                    fs.readFile(template, { encoding: 'utf8' })
+                        .then((newTemplateString) => {
+                        if (!isUsableByDefaultTemplateFactory(newTemplateString) && !hasCustomTemplateFactory) {
+                            warnAboutUsingDefaultTemplate();
+                            resolve(defaultTemplate);
+                        }
+                        else {
+                            resolve(newTemplateString);
+                        }
+                    })
+                        .catch(handleTemplateReadError);
+                });
+            }
+        }
+    }
+    let remainingOutputsCount = 0, configsCount = 0, initialDir = '', fileNameInInitialDir, assets = freshAssets();
+    const configs = new Set(), finalHook = useWriteBundle ? 'writeBundle' : 'generateBundle', processedFiles = new Set();
+    const instance = {
+        name: pluginName,
+        renderStart: (options) => {
+            logger('started collecting information', logLevel);
+            initialDir = options.dir || '';
+            fileNameInInitialDir = path.join(initialDir, outputFile);
+            return renderStart();
+        },
+        [finalHook]: generateBundle,
+        api: { addInstance }
+    };
+    if (hasTemplateFile && watch) {
+        instance.buildStart = async function () {
+            try {
+                useNewTemplate(await fs.readFile(template, { encoding: 'utf8' }));
+            }
+            catch (e) {
+                handleTemplateReadError(e);
+            }
+            await buildStart.apply(this);
+        };
+    }
+    return instance;
+    function freshAssets() {
+        return {
+            asset: [],
+            es: [],
+            iife: [],
+            umd: []
+        };
+    }
+    function useNewTemplate(newTemplateString) {
+        if (!isUsableByDefaultTemplateFactory(newTemplateString) && !hasCustomTemplateFactory) {
+            warnAboutUsingDefaultTemplate();
+        }
+        else {
+            templateString = newTemplateString;
+        }
+    }
+    function handleTemplateReadError(e) {
+        var _a;
+        if (((_a = e) === null || _a === void 0 ? void 0 : _a.code) === 'ENOENT') {
+            logger('template nor a file or string', 2 /* warn */, e);
+        }
+        else {
+            logger(`error reading template\n${e}`, 2 /* warn */, e);
+        }
+    }
+    function warnAboutUsingDefaultTemplate() {
+        logger('template is unusable by default template factory, using default one', 2 /* warn */);
+    }
+    function addInstance() {
+        const configId = ++configsCount;
+        configs.add(configId);
+        const instance = {
+            name: `${pluginName}#${configId}`,
+            renderStart: () => {
+                configs.delete(configId);
+                return renderStart();
+            },
+            [finalHook]: generateBundle
+        };
+        if (hasTemplateFile && watch) {
+            instance.buildStart = buildStart;
+        }
+        return instance;
+    }
+    async function buildStart() {
+        this.addWatchFile('src/index.html');
+    }
+    function renderStart() {
+        ++remainingOutputsCount;
+    }
+    async function generateBundle(options, bundle) {
+        --remainingOutputsCount;
+        await getAssets(options, bundle);
+        const statistics = Object.keys(assets)
+            .map(key => ({ key, count: assets[key].length }))
+            .filter(item => item.count)
+            .map(({ key, count }) => `${key}: ${count}`)
+            .join(', ');
+        logger(`assets collected: [${statistics}], remaining: ${remainingOutputsCount} outputs, ${configs.size} configs`, logLevel);
+        const dir = options.dir || '', fileName = path.relative(dir, fileNameInInitialDir);
+        if (fileName in bundle) {
+            if (useEmittedTemplate) {
+                logger(`using exiting emitted ${fileName} as an input for out templateFactory`, logLevel);
+                const source = bundle[fileName].type === 'asset' ? bundle[fileName].source.toString() : bundle[fileName].code;
+                useNewTemplate(source);
+            }
+            else {
+                logger(`removing exiting emitted ${fileName}`, logLevel);
+            }
+            if (configs.size === 0 && emitFile && !useWriteBundle) {
+                delete bundle[fileName];
+            }
+        }
+        if (configs.size === 0 && remainingOutputsCount === 0) {
+            logger.start('generating html', logLevel);
+            try {
+                const depromisifiedTemplateString = await templateString, source = await templateFactory(depromisifiedTemplateString, assets, defaultTemplateFactory);
+                if (!emitFile || fileName.startsWith('..') || useWriteBundle) {
+                    if (emitFile && emitFile !== 'auto') {
+                        logger('cannot emitFile because it is outside of current output.dir, using writeFile instead', logLevel);
+                    }
+                    await fs.mkdir(path.dirname(fileNameInInitialDir), { recursive: true });
+                    await fs.writeFile(fileNameInInitialDir, source);
+                }
+                else {
+                    this.emitFile({
+                        type: 'asset',
+                        fileName,
+                        source
+                    });
+                }
+                // reset assets and configs for next iteration
+                assets = freshAssets();
+                for (let i = configsCount; i > 0; --i) {
+                    configs.add(i);
+                }
+                processedFiles.clear();
+                logger.finish('html file generated');
+            }
+            catch (e) {
+                logger(`error generating html file\n${e}`, 3 /* error */, e);
+                logger.finish('html generation failed', 3 /* error */);
+            }
+        }
+    }
+    async function getAssets(options, bundle) {
+        const dir = options.dir || '';
+        for (const fileName of Object.keys(bundle)) {
+            const relativeToRootAssetPath = path.join(dir, fileName);
+            if (ignore(relativeToRootAssetPath) || processedFiles.has(relativeToRootAssetPath)) {
+                continue;
+            }
+            processedFiles.add(relativeToRootAssetPath);
+            if (bundle[fileName].type == 'asset') {
+                if (await useAssetFactory(fileName, relativeToRootAssetPath, bundle[fileName].source, 'asset')) {
+                    continue;
+                }
+                if (fileName.endsWith(cssExtention)) {
+                    const assetPath = path.relative(initialDir, relativeToRootAssetPath);
+                    assets.asset.push({
+                        html: getLinkElement(assetPath),
+                        head: injectIntoHead(relativeToRootAssetPath),
+                        type: 'asset'
+                    });
+                    continue;
+                }
+            }
+            else if (bundle[fileName].type == 'chunk') {
+                const chunk = bundle[fileName];
+                if (chunk.isEntry) {
+                    if (await useAssetFactory(fileName, relativeToRootAssetPath, chunk.code, options.format)) {
+                        continue;
+                    }
+                    if (options.format === 'es' || options.format === 'iife' || options.format === 'umd') {
+                        const assetPath = path.relative(initialDir, relativeToRootAssetPath);
+                        assets[options.format].push({
+                            html: (assets) => {
+                                let useConditionalLoading = conditionalLoading;
+                                useConditionalLoading !== null && useConditionalLoading !== void 0 ? useConditionalLoading : (useConditionalLoading = !!((assets.iife.length
+                                    || assets.umd.length)
+                                    && assets.es.length));
+                                return (options.format === 'iife' || options.format === 'umd') ? getNonModuleScriptElement(assetPath, useConditionalLoading) : getModuleScriptElement(assetPath);
+                            },
+                            head: injectIntoHead(relativeToRootAssetPath),
+                            type: 'asset'
+                        });
+                    }
+                }
+            }
+        }
+    }
+    async function useAssetFactory(fileName, relativeToRootAssetPath, source, format) {
+        if (assetsFactory) {
+            try {
+                let asset = await assetsFactory(fileName, source, format);
+                if (asset) {
+                    if (typeof asset === 'string') {
+                        asset = {
+                            html: asset,
+                            head: injectIntoHead(relativeToRootAssetPath),
+                            type: format
+                        };
+                    }
+                    if (!assets[asset.type]) {
+                        assets[asset.type] = [];
+                    }
+                    assets[asset.type].push(asset);
+                    return true;
+                }
+            }
+            catch (e) {
+                logger(`exception in assetFactory:${e}`, 2 /* warn */, e);
+            }
+        }
+        return false;
+    }
+}
+function isUsableByDefaultTemplateFactory(template) {
+    return template.indexOf(headClosingElement) >= 0 && template.indexOf(bodyClosingElement) >= 0;
+}
+function getLinkElement(fileName) {
+    return `<link rel="stylesheet" href="${fileName}" type="text/css">`;
+}
+function getNonModuleScriptElement(fileName, conditionalLoading) {
+    return `<script src="${fileName}" type="text/javascript"${conditionalLoading ? ' nomodule' : ''}></script>`;
+}
+function getModuleScriptElement(fileName) {
+    return `<script src="${fileName}" type="module"></script>`;
+}
+function normalizeOptions(userOptions) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const options = {
+        pluginName: (_a = userOptions.pluginName) !== null && _a !== void 0 ? _a : '@rollup-extras/plugin-html',
+        template: userOptions.template,
+        outputFile: (_b = userOptions.outputFile) !== null && _b !== void 0 ? _b : 'index.html',
+        watch: (_c = userOptions.watch) !== null && _c !== void 0 ? _c : true,
+        useWriteBundle: (_d = userOptions.useWriteBundle) !== null && _d !== void 0 ? _d : false,
+        useEmittedTemplate: (_e = userOptions.useEmittedTemplate) !== null && _e !== void 0 ? _e : !('template' in userOptions),
+        emitFile: (_f = userOptions.emitFile) !== null && _f !== void 0 ? _f : 'auto',
+        logLevel: userOptions.verbose ? 1 /* info */ : 0 /* verbose */,
+        conditionalLoading: userOptions.conditionalLoading,
+        injectIntoHead: (fileName) => fileName.endsWith(cssExtention),
+        ignore: toAssetPredicate(false),
+        assetsFactory: userOptions.assetsFactory,
+        templateFactory: (_g = userOptions.templateFactory) !== null && _g !== void 0 ? _g : ((template, assets, defaultTemplateFactory) => defaultTemplateFactory(template, assets)),
+    }, logger = options.logger = createLogger(options.pluginName), optionIgnoredText = 'option ignored because it is not a function, RegExp or boolean';
+    if (userOptions.injectIntoHead != null) {
+        const predicate = toAssetPredicate(userOptions.injectIntoHead);
+        if (predicate) {
+            options.injectIntoHead = predicate;
+        }
+        else {
+            logger(`injectIntoHead ${optionIgnoredText}`, 2 /* warn */);
+        }
+    }
+    if (userOptions.ignore != null) {
+        const predicate = toAssetPredicate(userOptions.ignore);
+        if (predicate) {
+            options.ignore = predicate;
+        }
+        else {
+            logger(`ignore ${optionIgnoredText}`, 2 /* warn */);
+        }
+    }
+    return options;
+}
+function toAssetPredicate(sourceOption) {
+    if (typeof sourceOption === 'boolean') {
+        return () => sourceOption;
+    }
+    else if (typeof sourceOption === 'function') {
+        return sourceOption;
+    }
+    else if (sourceOption instanceof RegExp) {
+        return (fileName) => sourceOption.test(fileName);
+    }
+    return undefined;
+}
+function defaultTemplateFactory(template, assets) {
+    const assetsAsArray = assets.asset
+        .concat((assets.iife.length ? assets.iife : assets.umd))
+        .concat(assets.es)
+        .map((asset) => {
+        if (typeof asset.html === 'function') {
+            asset.html = asset.html(assets);
+        }
+        return asset;
+    });
+    const headElements = assetsAsArray.filter(asset => asset.head).map(asset => asset.html);
+    const bodyElements = assetsAsArray.filter(asset => !asset.head).map(asset => asset.html);
+    const headIndex = template.toLowerCase().indexOf(headClosingElement);
+    template = `${template.substring(0, headIndex)}${headElements.join('')}${template.substring(headIndex)}`;
+    const bodyIndex = template.toLowerCase().indexOf(bodyClosingElement);
+    return `${template.substring(0, bodyIndex)}${bodyElements.join('')}${template.substring(bodyIndex)}`;
+}
+
+export { index as default };

package/dist/types.d.ts

@@ -0,0 +1,34 @@
+import { InternalModuleFormat } from 'rollup';
+export declare type AssetType = 'asset' | InternalModuleFormat;
+export declare type Assets = {
+    [key in AssetType]?: AssetDescriptor[];
+};
+export declare type AssetPredicate = (fileName: string) => boolean;
+export declare type AssetDescriptor = {
+    html: string | ((assets: Assets, context?: unknown) => string | unknown);
+    head: boolean;
+    type: 'asset' | InternalModuleFormat;
+};
+export declare type SimpleAssetDescriptor = {
+    html: string;
+    head: boolean;
+    type: 'asset' | InternalModuleFormat;
+};
+export declare type AssetFactory = (fileName: string, content: string | Uint8Array, type: 'asset' | InternalModuleFormat) => AssetDescriptor | string | undefined | Promise<AssetDescriptor | string | undefined>;
+export declare type DefaultTemplateFactory = (initialTemplate: string, assets: Assets) => string;
+export declare type TemplateFactory = (initialTemplate: string, assets: Assets, defaultTemplateFactory: DefaultTemplateFactory) => string | Uint8Array | Promise<string | Uint8Array>;
+export declare type HtmlPluginOptions = {
+    pluginName?: string;
+    outputFile?: string;
+    template?: string;
+    watch?: boolean;
+    emitFile?: boolean;
+    verbose?: boolean;
+    useWriteBundle?: boolean;
+    useEmittedTemplate?: boolean;
+    conditionalLoading?: boolean;
+    injectIntoHead?: boolean | AssetPredicate | RegExp;
+    ignore?: boolean | AssetPredicate | RegExp;
+    assetsFactory?: AssetFactory;
+    templateFactory?: TemplateFactory;
+};

package/package.json

@@ -0,0 +1,77 @@
+{
+  "version": "1.0.0",
+  "license": "MIT",
+  "name": "@rollup-extras/plugin-html",
+  "author": {
+    "name": "Konstantin Shutkin"
+  },
+  "funding": "https://www.donationalerts.com/r/excitingcode",
+  "type": "module",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "typings": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=15"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kshutkin/rollup-extras.git"
+  },
+  "bugs": {
+    "url": "https://github.com/kshutkin/rollup-extras/issues"
+  },
+  "homepage": "https://github.com/kshutkin/rollup-extras/plugin-clean/README.md",
+  "keywords": [
+    "rollup-plugin"
+  ],
+  "scripts": {
+    "build": "rimraf ./dist && rollup -c",
+    "dev": "rimraf ./dist && rollup -c -w",
+    "test": "jest --collectCoverage",
+    "lint": "eslint ./src",
+    "semantic-release": "npx semantic-release"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "21.0.1",
+    "@rollup/plugin-node-resolve": "13.0.6",
+    "@semantic-release/changelog": "6.0.1",
+    "@semantic-release/commit-analyzer": "9.0.1",
+    "@semantic-release/git": "10.0.1",
+    "@semantic-release/npm": "8.0.2",
+    "@semantic-release/release-notes-generator": "10.0.2",
+    "@types/jest": "27.0.2",
+    "@typescript-eslint/eslint-plugin": "5.3.0",
+    "@typescript-eslint/parser": "5.3.0",
+    "conventional-changelog-angular": "5.0.13",
+    "eslint": "8.1.0",
+    "jest": "27.3.1",
+    "lodash": "4.17.21",
+    "rimraf": "3.0.2",
+    "is-builtin-module": "3.1.0",
+    "rollup": "2.60.1",
+    "rollup-plugin-terser": "7.0.2",
+    "rollup-plugin-typescript2": "0.31.1",
+    "rollup-plugin-preprocess": "0.0.4",
+    "semantic-release": "18.0.0",
+    "semantic-release-monorepo": "7.0.5",
+    "ts-jest": "27.0.7",
+    "typescript": "4.4.x",
+    "update-monorepo-package-json": "0.1.6"
+  },
+  "peerDependencies": {
+    "rollup": "^2.60.2"
+  },
+  "dependencies": {
+    "@niceties/logger": "^1.0.4"
+  },
+  "readme": "ERROR: No README data found!"
+}