@kosatyi/ejs 0.0.106 → 0.0.108

package/dist/cjs/bundler.js

@@ -1,60 +1,96 @@
 'use strict';
 
-var node_fs = require('node:fs');
-var node_path = require('node:path');
-var glob = require('glob');
+var fs = require('node:fs/promises');
 var globWatch = require('glob-watcher');
+var glob = require('glob');
+var node_path = require('node:path');
 var index_js = require('./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 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);
+        }
+    }
 };
 
-const Bundler = (params = {}, ejsParams = {}) => {
-    const config = {
+class Bundler {
+    #templates = {}
+    #bundlerOptions = {
         target: [],
         umd: true,
-        minify: true
-    };
-    const ejs = index_js.create();
-    const ejsConfig = ejs.configure(ejsParams);
-    const templates = {};
-    extend(config, params || {});
-    const stageRead = (path) => {
-        return node_fs.promises
-            .readFile(node_path.join(ejsConfig.path, path))
+        minify: true,
+    }
+    #compile
+    #ejsOptions
+    #buildInProgress
+    static exports = ['build', 'watch', 'concat', 'output']
+    constructor(bundlerOptions = {}, ejsOptions = {}) {
+        bindContext(this, this.constructor.exports);
+        const { compile, configure } = index_js.create(ejsOptions);
+        Object.assign(this.#bundlerOptions, bundlerOptions);
+        this.#compile = compile;
+        this.#ejsOptions = configure();
+        this.#buildInProgress = false;
+        this.#templates = {};
+    }
+    async #stageRead(path) {
+        return fs
+            .readFile(node_path.join(this.#ejsOptions.path, path))
             .then((response) => response.toString())
-    };
-    const stageCompile = (content, name) => {
-        return ejs.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){');
             out.push(
-                'typeof exports === "object" && typeof module !== "undefined" ?'
+                'typeof exports === "object" && typeof module !== "undefined" ?',
             );
             out.push('module.exports = factory():');
             out.push(
-                'typeof define === "function" && define.amd ? define(factory):'
+                'typeof define === "function" && define.amd ? define(factory):',
             );
             out.push(
-                '(global = typeof globalThis !== "undefined" ? globalThis:'
+                '(global = typeof globalThis !== "undefined" ? globalThis:',
             );
             out.push(`global || self,global["${module}"] = factory())`);
             out.push('})(this,(function(){');
         }
         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}`);
@@ -65,87 +101,83 @@ 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.glob(pattern, { cwd: ejsConfig.path });
+    }
+    async concat() {
+        const pattern = '**/*.'.concat(this.#ejsOptions.extension);
+        const list = await glob.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 = node_path.dirname(file);
-            const folderExists = await node_fs.promises
+            const folderExists = await fs
                 .stat(folderPath)
                 .then(() => true)
                 .catch(() => false);
             if (folderExists === false) {
-                await node_fs.promises.mkdir(folderPath, { recursive: true });
+                await fs.mkdir(folderPath, { recursive: true });
             }
-            await node_fs.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();
+        },
     }
 };
 
 exports.Bundler = Bundler;
-exports.ejsBundler = ejsBundler;
+exports.bundler = bundler;
+exports.ejsRollupBundler = ejsRollupBundler;

package/dist/cjs/element.js

@@ -1,88 +1,53 @@
 'use strict';
 
-var isUndefined = function isUndefined(v) {
-  return typeof v === 'undefined';
-};
-
-Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';
-var symbolEntities = {
+const symbolEntities = {
   "'": "'",
   '\\': '\\',
   '\r': 'r',
   '\n': 'n',
   '\t': 't',
-  "\u2028": 'u2028',
-  "\u2029": 'u2029'
+  '\u2028': 'u2028',
+  '\u2029': 'u2029'
 };
-var htmlEntities = {
+const htmlEntities = {
   '&': '&',
   '<': '&lt;',
   '>': '&gt;',
   '"': '&quot;',
   "'": '&#x27;'
 };
-var regexKeys = function regexKeys(obj) {
-  return new RegExp(['[', Object.keys(obj).join(''), ']'].join(''), 'g');
-};
-var htmlEntitiesMatch = regexKeys(htmlEntities);
+const regexKeys = obj => new RegExp(['[', Object.keys(obj).join(''), ']'].join(''), 'g');
+const htmlEntitiesMatch = regexKeys(htmlEntities);
 regexKeys(symbolEntities);
-var entities = function entities() {
-  var string = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
-  return ('' + string).replace(htmlEntitiesMatch, function (match) {
-    return htmlEntities[match];
-  });
+const entities = function () {
+  let string = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return ('' + string).replace(htmlEntitiesMatch, match => htmlEntities[match]);
 };
-var safeValue = function safeValue(value, escape) {
-  var check = value;
+const safeValue = (value, escape) => {
+  const check = value;
   return check == null ? '' : Boolean(escape) === true ? entities(check) : check;
 };
-var each = function each(object, callback) {
-  var prop;
-  for (prop in object) {
-    if (hasProp(object, prop)) {
-      callback(object[prop], prop, object);
-    }
-  }
-};
-var map = function map(object, callback, context) {
-  var result = [];
-  each(object, function (value, key, object) {
-    var item = callback(value, key, object);
-    if (isUndefined(item) === false) {
-      result.push(item);
-    }
-  });
-  return result;
-};
 
-/**
- *
- * @param object
- * @param prop
- * @return {boolean}
- */
-var hasProp = function hasProp(object, prop) {
-  return object && object.hasOwnProperty(prop);
+const selfClosed = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
+const space = ' ';
+const quote = '"';
+const equal = '=';
+const slash = '/';
+const lt = '<';
+const gt = '>';
+const eachAttribute = _ref => {
+  let [key, value] = _ref;
+  if (value !== null && value !== undefined) {
+    return [entities(key), [quote, entities(value), quote].join('')].join(equal);
+  }
 };
-
-var selfClosed = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
-var space = ' ';
-var quote = '"';
-var equal = '=';
-var slash = '/';
-var lt = '<';
-var gt = '>';
-var element = function element(tag, attrs, content) {
-  var result = [];
-  var hasClosedTag = selfClosed.indexOf(tag) === -1;
-  var attributes = map(attrs, function (value, key) {
-    if (value !== null && value !== undefined) {
-      return [entities(key), [quote, entities(value), quote].join('')].join(equal);
-    }
-  }).join(space);
+const element = (tag, attrs, content) => {
+  const result = [];
+  const hasClosedTag = selfClosed.indexOf(tag) === -1;
+  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(''));