@kosatyi/ejs 0.0.107 → 0.0.109

package/dist/esm/bundler.js

@@ -1,39 +1,75 @@
+import fs from 'node:fs/promises';
 import globWatch from 'glob-watcher';
-import { promises } from 'node:fs';
-import { dirname, join } from 'node:path';
 import { glob } from 'glob';
+import { join, dirname } from 'node:path';
 import { create } from './index.js';
 
-const isPlainObject = function (obj) {
-    return Object.prototype.toString.call(obj) === '[object Object]'
+const symbolEntities = {
+    "'": "'",
+    '\\': '\\',
+    '\r': 'r',
+    '\n': 'n',
+    '\t': 't',
+    '\u2028': 'u2028',
+    '\u2029': 'u2029',
 };
 
-const extend = (target, ...sources) => {
-    return Object.assign(target, ...sources.filter(isPlainObject))
+const htmlEntities = {
+    '&': '&',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#x27;',
 };
 
-const Bundler = (params = {}, ejsParams = {}) => {
-    const config = {
+const regexKeys = (obj) =>
+    new RegExp(['[', Object.keys(obj).join(''), ']'].join(''), 'g');
+
+regexKeys(htmlEntities);
+
+regexKeys(symbolEntities);
+
+const bindContext = (object, methods = []) => {
+    for (let i = 0, len = methods.length; i < len; i++) {
+        const name = methods[i];
+        if (name in object) {
+            object[name] = object[name].bind(object);
+        }
+    }
+};
+
+class Bundler {
+    #templates = {}
+    #bundlerOptions = {
         target: [],
         umd: true,
         minify: true,
-    };
-    const { compile, configure } = create();
-    const ejsConfig = configure(ejsParams);
-    const templates = {};
-    extend(config, params || {});
-    const stageRead = (path) => {
-        return promises
-            .readFile(join(ejsConfig.path, path))
+    }
+    #compile
+    #ejsOptions
+    #buildInProgress
+    static exports = ['build', 'watch', 'concat', 'output']
+    constructor(bundlerOptions = {}, ejsOptions = {}) {
+        bindContext(this, this.constructor.exports);
+        const { compile, configure } = create(ejsOptions);
+        Object.assign(this.#bundlerOptions, bundlerOptions);
+        this.#compile = compile;
+        this.#ejsOptions = configure();
+        this.#buildInProgress = false;
+        this.#templates = {};
+    }
+    async #stageRead(path) {
+        return fs
+            .readFile(join(this.#ejsOptions.path, path))
             .then((response) => response.toString())
-    };
-    const stageCompile = (content, name) => {
-        return compile(content, name).source
-    };
-    const getBundle = () => {
-        const umd = config.umd;
-        const strict = ejsConfig.withObject === false;
-        const module = ejsConfig.export;
+    }
+    #stageCompile(content, name) {
+        return this.#compile(content, name).source
+    }
+    #getBundle() {
+        const umd = this.#bundlerOptions.umd;
+        const strict = this.#ejsOptions.strict;
+        const module = this.#ejsOptions.precompiled;
         const out = [];
         if (umd) {
             out.push('(function(global,factory){');
@@ -52,7 +88,7 @@ const Bundler = (params = {}, ejsParams = {}) => {
         }
         if (strict) out.push(`'use strict'`);
         out.push('const templates = {}');
-        Object.entries(templates).forEach(([name, content]) => {
+        Object.entries(this.#templates).forEach(([name, content]) => {
             name = JSON.stringify(name);
             content = String(content);
             out.push(`templates[${name}] = ${content}`);
@@ -63,79 +99,81 @@ const Bundler = (params = {}, ejsParams = {}) => {
             out.push('export default templates');
         }
         return out.join('\n')
-    };
-    const watch = async () => {
-        console.log('🔍', 'watch directory:', ejsConfig.path);
-        const pattern = '**/*.'.concat(ejsConfig.extension);
-        const watcher = globWatch(pattern, { cwd: ejsConfig.path });
+    }
+    async build() {
+        if (this.#buildInProgress === true) return false
+        this.#buildInProgress = true;
+        await this.concat().catch(console.error);
+        await this.output().catch(console.error);
+        console.log('✅', 'bundle complete:', this.#bundlerOptions.target);
+        this.#buildInProgress = false;
+    }
+    async watch() {
+        console.log('🔍', 'watch directory:', this.#ejsOptions.path);
+        const pattern = '**/*.'.concat(this.#ejsOptions.extension);
+        const watcher = globWatch(pattern, { cwd: this.#ejsOptions.path });
         const state = { build: null };
         watcher.on('change', (path) => {
             if (state.build) return
             console.log('⟳', 'file change:', path);
-            state.build = build().then(() => {
+            state.build = this.build().then(() => {
                 state.build = null;
             });
         });
         watcher.on('add', (path) => {
             if (state.build) return
             console.log('+', 'file added:', path);
-            state.build = build().then(() => {
+            state.build = this.build().then(() => {
                 state.build = null;
             });
         });
-    };
-    const concat = async () => {
-        const pattern = '**/*.'.concat(ejsConfig.extension);
-        const list = await glob(pattern, { cwd: ejsConfig.path });
+    }
+    async concat() {
+        const pattern = '**/*.'.concat(this.#ejsOptions.extension);
+        const list = await glob(
+            pattern,
+            { cwd: this.#ejsOptions.path },
+            () => {},
+        );
         for (let template of list) {
             let content = '';
-            content = await stageRead(template);
-            content = await stageCompile(content, template);
-            templates[template] = content;
+            content = await this.#stageRead(template);
+            content = await this.#stageCompile(content, template);
+            this.#templates[template] = content;
         }
-    };
-    const build = async () => {
-        if (config.buildInProgress === true) return false
-        config.buildInProgress = true;
-        await concat().catch(console.error);
-        await output().catch(console.error);
-        console.log('✅', 'bundle complete:', config.target);
-        config.buildInProgress = false;
-    };
-    const output = async () => {
-        const target = [].concat(config.target);
-        const content = getBundle();
-        for (let file of target) {
+    }
+    async output() {
+        const target = [].concat(this.#bundlerOptions.target);
+        const content = this.#getBundle();
+        for (const file of target) {
             const folderPath = dirname(file);
-            const folderExists = await promises
+            const folderExists = await fs
                 .stat(folderPath)
                 .then(() => true)
                 .catch(() => false);
             if (folderExists === false) {
-                await promises.mkdir(folderPath, { recursive: true });
+                await fs.mkdir(folderPath, { recursive: true });
             }
-            await promises.writeFile(file, content);
+            await fs.writeFile(file, content);
         }
-    };
-    return {
-        build,
-        watch,
-        concat,
-        output,
     }
+}
+
+const bundler = (bundlerOptions = {}, ejsOptions = {}) => {
+    return new Bundler(bundlerOptions, ejsOptions)
 };
 
-const ejsBundler = (options, config) => {
-    const bundler = new Bundler(options, config);
+const ejsRollupBundler = (bundlerOptions, ejsOptions) => {
+    const bundle = new Bundler(bundlerOptions, ejsOptions);
     return {
         name: 'ejs-bundler',
         async buildStart() {
-            await bundler.concat();
+            await bundle.concat();
         },
         async buildEnd() {
-            await bundler.output();
+            await bundle.output();
         },
     }
 };
 
-export { Bundler, ejsBundler };
+export { Bundler, bundler, ejsRollupBundler };

package/dist/esm/element.js

@@ -1,9 +1,3 @@
-const isUndefined = (v) => typeof v === 'undefined';
-
-Object.prototype.toString.call(
-        typeof process !== 'undefined' ? process : 0,
-    ) === '[object process]';
-
 const symbolEntities = {
     "'": "'",
     '\\': '\\',
@@ -45,38 +39,6 @@ const safeValue = (value, escape) => {
           : check
 };
 
-const each = (object, callback) => {
-    let prop;
-    for (prop in object) {
-        if (hasProp(object, prop)) {
-            callback(object[prop], prop, object);
-        }
-    }
-};
-
-const map = (object, callback, context) => {
-    const result = [];
-    each(
-        object,
-        (value, key, object) => {
-            let item = callback(value, key, object);
-            if (isUndefined(item) === false) {
-                result.push(item);
-            }
-        });
-    return result
-};
-
-/**
- *
- * @param object
- * @param prop
- * @return {boolean}
- */
-const hasProp = (object, prop) => {
-    return object && object.hasOwnProperty(prop)
-};
-
 const selfClosed = [
     'area',
     'base',
@@ -101,20 +63,24 @@ const slash = '/';
 const lt = '<';
 const gt = '>';
 
+const eachAttribute = ([key, value]) => {
+    if (value !== null && value !== undefined) {
+        return [entities(key), [quote, entities(value), quote].join('')].join(
+            equal,
+        )
+    }
+};
+
 const element = (tag, attrs, content) => {
     const result = [];
     const hasClosedTag = selfClosed.indexOf(tag) === -1;
-    const attributes = map(attrs, (value, key) => {
-        if (value !== null && value !== undefined) {
-            return [
-                entities(key),
-                [quote, entities(value), quote].join(''),
-            ].join(equal)
-        }
-    }).join(space);
+    const attributes = Object.entries(attrs ?? {})
+        .map(eachAttribute)
+        .filter((e) => e)
+        .join(space);
     result.push([lt, tag, space, attributes, gt].join(''));
     if (content && hasClosedTag) {
-        result.push(content instanceof Array ? content.join('') : content);
+        result.push(Array.isArray(content) ? content.join('') : content);
     }
     if (hasClosedTag) {
         result.push([lt, slash, tag, gt].join(''));