jlto 1.4.2 → 1.5.2

package/.nvmrc

@@ -1 +1 @@
-v16
+v24.13.1

package/README.md

@@ -1,13 +1,3 @@
-# Support Ukraine 🇺🇦
-
-- Via United24 platform (the initiative of the President of Ukraine):
-  - [One click donation (credit card, bank transfer or crypto)](https://u24.gov.ua/)
-- Via National Bank of Ukraine:
-  - [Ukrainian army](https://bank.gov.ua/en/about/support-the-armed-forces)
-  - [Humanitarian aid to Ukraine](https://bank.gov.ua/en/about/humanitarian-aid-to-ukraine)
-
-[#StandWithUkraine](https://twitter.com/hashtag/StandWithUkraine)
-
 # JLTO
 
 [![CircleCI](https://circleci.com/gh/dmytro-krekota/jlto.svg?style=svg)](https://app.circleci.com/pipelines/github/dmytro-krekota/jlto)
@@ -17,6 +7,9 @@
 
 > Jinja Like Templates Optimizer (JLTO) is a Nodejs-based tool for optimizing Jinja like templates.
 
+If you are thinking about contributing to open source, this article is a good read:
+[Why You Should Write Open Source Code and How It Helps Your Career](https://explainme.online/article/why-you-should-write-open-source-code-and-how-it-helps-your-career).
+
 **Gulp tool for JLTO:**
 
 [gulp-jlto](https://www.npmjs.com/package/gulp-jlto)
@@ -44,11 +37,13 @@
 - cleanupBlocks - flag for optimize blocks
 - cleanupExpressions - flag for optimize expressions
 - removeComments - flag for removing comments
-- minifyHtml - flag for minifying html code with [html-minifier](https://www.npmjs.com/package/html-minifier)
-- minifyHtmlOptions - options for html-minifier
+- minifyHtml - flag for minifying html code with [html-minifier-next](https://www.npmjs.com/package/html-minifier-next)
+- minifyHtmlOptions - options for html-minifier-next
 
 See default values for above options [here](https://github.com/dmytro-krekota/jlto/blob/master/lib/core/default.js).
 
+`optimizeString` always returns a Promise, so use `await` (or `.then(...)`) for all calls.
+
 ## Usage
 
 **Simple example:**
@@ -60,13 +55,14 @@ let template = `
 {{   "<John   &   Paul> ?"     | escape   }}
 {{ '2.7'   | round }}{%  if  product  %}Product exists.{%  endif  %}
 `;
-let optimizedTemplate = jlto.optimizeString(template);
-// optimizedTemplate:
-// `
-//{{hello}}
-//{{"<John   &   Paul> ?"|escape}}
-//{{'2.7'|round}}{%if product%}Product exists.{%endif%}
-// `
+jlto.optimizeString(template).then((optimizedTemplate) => {
+  // optimizedTemplate:
+  // `
+  //{{hello}}
+  //{{"<John   &   Paul> ?"|escape}}
+  //{{'2.7'|round}}{%if product%}Product exists.{%endif%}
+  // `
+});
 ```
 
 **Example of using minifyHtml option:**
@@ -81,38 +77,76 @@ let template = `
     {% endfor %}
   </div>
 </div>`;
-let optimizedTemplate = jlto.optimizeString(template, {minifyHtml: true});
-// optimizedTemplate:
-// `<div {%if id%} id="{{id|escape('html_attr')}}" {%endif%} class="section-container {{classes|join(' ')|html_attribute}}"><div class="section-writables"> {%for writable in writables%} {{writable|write|raw}} {%endfor%} </div></div>`
+jlto.optimizeString(template, {minifyHtml: true}).then((optimizedTemplate) => {
+  // optimizedTemplate:
+  // `<div {%if id%} id="{{id|escape('html_attr')}}" {%endif%} class="section-container {{classes|join(' ')|html_attribute}}"><div class="section-writables"> {%for writable in writables%} {{writable|write|raw}} {%endfor%} </div></div>`
+});
 ```
 
 **Example of "nunjucks" templates minification with the custom GruntJS task:**
 
 ```js
 module.exports = (grunt) => {
-  grunt.registerTask('min-nunjucks', 'Min nunjucks templates', () => {
+  grunt.registerTask('min-nunjucks', 'Min nunjucks templates', function () {
     let jlto = require('jlto');
     let fs = require('fs');
-    let glob = require('glob');
+    let {glob} = require('glob');
     let done = this.async();
-    glob('./**/*.nunjucks.html', (error, files) => {
-      files.forEach((filePath) => {
+    (async () => {
+      let files = await glob('./**/*.nunjucks.html');
+      for (const filePath of files) {
         let fileContent;
         fileContent = fs.readFileSync(filePath).toString();
         try {
-          fileContent = jlto.optimizeString(fileContent, {minifyHtml: true});
+          fileContent = await jlto.optimizeString(fileContent, {minifyHtml: true});
           fs.writeFileSync(filePath, fileContent);
         } catch (ignored) {}
-      });
+      }
       return done();
-    });
+    })().catch(() => done());
   });
 };
 ```
 
+**Example of "nunjucks" templates minification with the custom webpack plugin:**
+
+```js
+let jlto = require('jlto');
+let webpack = require('webpack');
+
+class MinNunjucksPlugin {
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap('MinNunjucksPlugin', (compilation) => {
+      compilation.hooks.processAssets.tapPromise(
+        {
+          name: 'MinNunjucksPlugin',
+          stage: webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE,
+        },
+        async (assets) => {
+          for (const filePath of Object.keys(assets)) {
+            if (!filePath.endsWith('.nunjucks.html')) {
+              continue;
+            }
+            let fileContent = compilation.getAsset(filePath).source.source().toString();
+            try {
+              fileContent = await jlto.optimizeString(fileContent, {minifyHtml: true});
+              compilation.updateAsset(filePath, new webpack.sources.RawSource(fileContent));
+            } catch (ignored) {}
+          }
+        },
+      );
+    });
+  }
+}
+
+module.exports = {
+  plugins: [new MinNunjucksPlugin()],
+};
+```
+
 ## Tests
 
-Unit tests are written using Mocha and Chai. To run, invoke `npm test`.
+Tests are written using Jest and Node's `assert` module. To run them, invoke `npm test`.
 
 ## License
 

package/eslint.config.js

@@ -0,0 +1,72 @@
+const js = require('@eslint/js');
+const globals = require('globals');
+const eslintPluginPrettierRecommended = require('eslint-plugin-prettier/recommended');
+
+module.exports = [
+  {
+    ignores: ['coverage/**', 'node_modules/**'],
+  },
+  js.configs.recommended,
+  eslintPluginPrettierRecommended,
+  {
+    languageOptions: {
+      ecmaVersion: 'latest',
+      sourceType: 'commonjs',
+      globals: {
+        ...globals.node,
+        ...globals.mocha,
+      },
+    },
+    rules: {
+      semi: 1,
+      'no-mixed-spaces-and-tabs': 1,
+      'no-trailing-spaces': 1,
+      'space-infix-ops': 1,
+      quotes: [
+        1,
+        'single',
+        {
+          allowTemplateLiterals: true,
+          avoidEscape: true,
+        },
+      ],
+      'no-unused-vars': 1,
+      'one-var': [1, 'never'],
+      'vars-on-top': 1,
+      'no-undef': 1,
+      'no-use-before-define': 1,
+      'no-console': 0,
+      'keyword-spacing': 1,
+      'key-spacing': 1,
+      'space-before-blocks': 1,
+      'space-in-parens': 1,
+      indent: [1, 2],
+      camelcase: [
+        1,
+        {
+          properties: 'always',
+        },
+      ],
+      'comma-spacing': [
+        1,
+        {
+          before: false,
+          after: true,
+        },
+      ],
+      'comma-style': [1, 'last'],
+      'newline-before-return': 1,
+      'object-curly-spacing': [1, 'never'],
+      'semi-spacing': [
+        1,
+        {
+          before: false,
+          after: true,
+        },
+      ],
+      eqeqeq: 1,
+      'linebreak-style': [1, 'unix'],
+      'prettier/prettier': ['error'],
+    },
+  },
+];

package/lib/helpers/blocksHelper.js

@@ -1,73 +1,20 @@
+let spaceCleanupHelper = require('./spaceCleanupHelper');
+
 /**
  * @class BlocksHelper
  */
 class BlocksHelper {
   constructor(options) {
     this.options = options;
-    this.utils = require('./../core/utils');
-  }
-
-  getBlockWithoutExtraSpaces(expression) {
-    let body = expression.slice(this.options.blockStart.length).slice(0, -this.options.blockEnd.length);
-    let resultBody = '';
-    let i;
-    let waitForChar;
-
-    body = body.trim();
-    for (i = 0; i < body.length; i++) {
-      if (waitForChar && body[i] !== waitForChar) {
-        resultBody += body[i];
-        continue;
-      }
-      if (body[i] === '"' || body[i] === "'") {
-        if (!waitForChar) {
-          waitForChar = body[i];
-        } else {
-          waitForChar = null;
-        }
-      }
-      if (this.options.specialChars.indexOf(body[i]) >= 0) {
-        resultBody = resultBody.trim();
-      }
-      if (this.options.specialChars.indexOf(resultBody[resultBody.length - 1]) >= 0 && body[i] === ' ') {
-        continue;
-      }
-      if (resultBody[resultBody.length - 1] === ' ' && body[i] === ' ') {
-        continue;
-      }
-      if (body[i] !== '\n') {
-        resultBody += body[i];
-      }
-    }
-
-    return this.options.blockStart + resultBody + this.options.blockEnd;
   }
 
   clearExtraSpaces(template) {
-    let i;
-    let startIndex = null;
-    let tempSubstring;
-    let resultString = '';
-
-    for (i = 0; i < template.length + 1; i++) {
-      if (!this.utils.isNull(startIndex)) {
-        tempSubstring = template.substring(i - this.options.blockEnd.length, i);
-        if (tempSubstring === this.options.blockEnd) {
-          resultString += this.getBlockWithoutExtraSpaces(template.substring(startIndex, i));
-          startIndex = null;
-        }
-      }
-      if (this.utils.isNull(startIndex)) {
-        tempSubstring = template.substring(i, i + this.options.blockStart.length);
-        if (tempSubstring === this.options.blockStart) {
-          startIndex = i;
-        } else if (!this.utils.isUndefined(template[i])) {
-          resultString += template[i];
-        }
-      }
-    }
-
-    return resultString;
+    return spaceCleanupHelper.clearTemplateExtraSpaces(
+      template,
+      this.options.blockStart,
+      this.options.blockEnd,
+      this.options.specialChars,
+    );
   }
 }
 

package/lib/helpers/expressionsHelper.js

@@ -1,73 +1,20 @@
+let spaceCleanupHelper = require('./spaceCleanupHelper');
+
 /**
  * @class ExpressionsHelper
  */
 class ExpressionsHelper {
   constructor(options) {
     this.options = options;
-    this.utils = require('./../core/utils');
-  }
-
-  getExpressionWithoutExtraSpaces(expression) {
-    let body = expression.slice(this.options.expressionStart.length).slice(0, -this.options.expressionEnd.length);
-    let resultBody = '';
-    let i;
-    let waitForChar;
-
-    body = body.trim();
-    for (i = 0; i < body.length; i++) {
-      if (waitForChar && body[i] !== waitForChar) {
-        resultBody += body[i];
-        continue;
-      }
-      if (body[i] === '"' || body[i] === "'") {
-        if (!waitForChar) {
-          waitForChar = body[i];
-        } else {
-          waitForChar = null;
-        }
-      }
-      if (this.options.specialChars.indexOf(body[i]) >= 0) {
-        resultBody = resultBody.trim();
-      }
-      if (this.options.specialChars.indexOf(resultBody[resultBody.length - 1]) >= 0 && body[i] === ' ') {
-        continue;
-      }
-      if (resultBody[resultBody.length - 1] === ' ' && body[i] === ' ') {
-        continue;
-      }
-      if (body[i] !== '\n') {
-        resultBody += body[i];
-      }
-    }
-
-    return this.options.expressionStart + resultBody + this.options.expressionEnd;
   }
 
   clearExtraSpaces(template) {
-    let i;
-    let startIndex = null;
-    let tempSubstring;
-    let resultString = '';
-
-    for (i = 0; i < template.length + 1; i++) {
-      if (!this.utils.isNull(startIndex)) {
-        tempSubstring = template.substring(i - this.options.expressionEnd.length, i);
-        if (tempSubstring === this.options.expressionEnd) {
-          resultString += this.getExpressionWithoutExtraSpaces(template.substring(startIndex, i));
-          startIndex = null;
-        }
-      }
-      if (this.utils.isNull(startIndex)) {
-        tempSubstring = template.substring(i, i + this.options.expressionStart.length);
-        if (tempSubstring === this.options.expressionStart) {
-          startIndex = i;
-        } else if (!this.utils.isUndefined(template[i])) {
-          resultString += template[i];
-        }
-      }
-    }
-
-    return resultString;
+    return spaceCleanupHelper.clearTemplateExtraSpaces(
+      template,
+      this.options.expressionStart,
+      this.options.expressionEnd,
+      this.options.specialChars,
+    );
   }
 }
 

package/lib/helpers/spaceCleanupHelper.js

@@ -0,0 +1,85 @@
+let isEscaped = (text, index) => {
+  let backslashCount = 0;
+  let i;
+
+  for (i = index - 1; i >= 0 && text[i] === '\\'; i--) {
+    backslashCount++;
+  }
+
+  return backslashCount % 2 === 1;
+};
+
+let getTagWithoutExtraSpaces = (tag, startDelimiter, endDelimiter, specialChars) => {
+  let body = tag.slice(startDelimiter.length).slice(0, -endDelimiter.length);
+  let resultBody = '';
+  let i;
+  let waitForChar = null;
+  let specialCharSet = new Set(specialChars);
+
+  body = body.trim();
+  for (i = 0; i < body.length; i++) {
+    if (waitForChar && body[i] !== waitForChar) {
+      resultBody += body[i];
+      continue;
+    }
+
+    if (body[i] === '"' || body[i] === "'") {
+      if (!waitForChar) {
+        waitForChar = body[i];
+      } else if (waitForChar === body[i] && !isEscaped(body, i)) {
+        waitForChar = null;
+      }
+    }
+
+    if (specialCharSet.has(body[i])) {
+      resultBody = resultBody.trim();
+    }
+    if (specialCharSet.has(resultBody[resultBody.length - 1]) && body[i] === ' ') {
+      continue;
+    }
+    if (resultBody[resultBody.length - 1] === ' ' && body[i] === ' ') {
+      continue;
+    }
+    if (body[i] !== '\n') {
+      resultBody += body[i];
+    }
+  }
+
+  return startDelimiter + resultBody + endDelimiter;
+};
+
+let clearTemplateExtraSpaces = (template, startDelimiter, endDelimiter, specialChars) => {
+  let i;
+  let startIndex = null;
+  let tempSubstring;
+  let resultString = '';
+
+  for (i = 0; i < template.length + 1; i++) {
+    if (startIndex !== null) {
+      tempSubstring = template.substring(i - endDelimiter.length, i);
+      if (tempSubstring === endDelimiter) {
+        resultString += getTagWithoutExtraSpaces(
+          template.substring(startIndex, i),
+          startDelimiter,
+          endDelimiter,
+          specialChars,
+        );
+        startIndex = null;
+      }
+    }
+    if (startIndex === null) {
+      tempSubstring = template.substring(i, i + startDelimiter.length);
+      if (tempSubstring === startDelimiter) {
+        startIndex = i;
+      } else if (template[i] !== undefined) {
+        resultString += template[i];
+      }
+    }
+  }
+
+  return resultString;
+};
+
+module.exports = {
+  clearTemplateExtraSpaces,
+};

package/lib/jlto.js

@@ -1,37 +1,37 @@
+let Default = require('./core/default');
+let ExpressionsHelper = require('./helpers/expressionsHelper');
+let BlocksHelper = require('./helpers/blocksHelper');
+let CommentsHelper = require('./helpers/commentsHelper');
+let minify = require('html-minifier-next').minify;
+
 /**
  * @class JLTO
  * @classdesc JLTO - Jinja Like Templates Optimizer.
  */
 class JLTO {
   constructor() {
-    this.defaultOptions = new (require('./core/default'))().options;
+    this.defaultOptions = new Default().options;
   }
 
-  optimizeString(string, options = {}) {
-    let expressionsHelper;
-    let blocksHelper;
-    let commentsHelper;
-    this.options = {...this.defaultOptions, ...options};
-    expressionsHelper = new (require('./helpers/expressionsHelper'))(this.options);
-    blocksHelper = new (require('./helpers/blocksHelper'))(this.options);
-    commentsHelper = new (require('./helpers/commentsHelper'))(this.options);
+  async optimizeString(string, options = {}) {
+    let resolvedOptions = {...this.defaultOptions, ...options};
 
-    if (this.options.removeComments) {
-      string = commentsHelper.removeComments(string);
+    if (resolvedOptions.removeComments) {
+      string = new CommentsHelper(resolvedOptions).removeComments(string);
     }
-    if (this.options.cleanupExpressions) {
-      string = expressionsHelper.clearExtraSpaces(string);
+    if (resolvedOptions.cleanupExpressions) {
+      string = new ExpressionsHelper(resolvedOptions).clearExtraSpaces(string);
     }
-    if (this.options.cleanupBlocks) {
-      string = blocksHelper.clearExtraSpaces(string);
+    if (resolvedOptions.cleanupBlocks) {
+      string = new BlocksHelper(resolvedOptions).clearExtraSpaces(string);
     }
-    if (this.options.minifyHtml) {
-      let minify = require('html-minifier').minify;
-      this.options.minifyHtmlOptions = {
+    if (resolvedOptions.minifyHtml) {
+      let minifyHtmlOptions = {
         ...this.defaultOptions.minifyHtmlOptions,
         ...(options.minifyHtmlOptions || {}),
       };
-      string = minify(string, this.options.minifyHtmlOptions);
+
+      return minify(string, minifyHtmlOptions);
     }
 
     return string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jlto",
-  "version": "1.4.2",
+  "version": "1.5.2",
   "description": "Nodejs-based tool for optimizing Jinja like templates",
   "keywords": [
     "jinja",
@@ -32,17 +32,15 @@
   "license": "MIT",
   "main": "index.js",
   "scripts": {
-    "lint": "eslint test lib --max-warnings=0 --fix",
+    "lint": "eslint test lib --max-warnings=0",
+    "lint:fix": "eslint test lib --max-warnings=0 --fix",
     "test": "npm run lint && jest --coverage",
     "ci-testing": "jest --coverage && cat ./coverage/lcov.info | coveralls",
     "prettier": "prettier \"{test,lib}/**/*.js\" --write"
   },
-  "engines": {
-    "node": ">=16"
-  },
   "pre-commit": [
     "prettier",
-    "lint"
+    "lint:fix"
   ],
   "jest": {
     "testEnvironment": "node",
@@ -54,19 +52,23 @@
     ]
   },
   "devDependencies": {
-    "chai": "4.3.6",
-    "coveralls": "3.1.1",
-    "eslint": "8.21.0",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-prettier": "^4.2.1",
-    "jest": "28.1.3",
-    "liquid": "5.1.1",
-    "nunjucks": "3.2.3",
-    "pre-commit": "1.2.2",
-    "prettier": "2.7.1",
-    "twig": "1.15.4"
+    "@eslint/js": "^9.39.3",
+    "coveralls": "^3.1.1",
+    "eslint": "^9.39.3",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.5",
+    "glob": "^13.0.6",
+    "globals": "^17.3.0",
+    "grunt": "^1.6.1",
+    "jest": "^30.2.0",
+    "liquid": "^5.1.1",
+    "nunjucks": "^3.2.4",
+    "pre-commit": "^1.2.2",
+    "prettier": "^3.8.1",
+    "twig": "^3.0.0",
+    "webpack": "^5.105.4"
   },
   "dependencies": {
-    "html-minifier": "4.0.0"
+    "html-minifier-next": "^4.19.1"
   }
 }