@mlut/core 2.0.0 → 2.1.0

package/dist/jit/JitEngine.d.ts

@@ -13,7 +13,7 @@ export declare class JitEngine {
     updateSassConfig(content: string): Promise<void>;
     generateCss(): Promise<string>;
     private extractUtils;
-    private normalizeClassNameStr;
+    private filterAndProcessClassStr;
     private extractUserSassConfig;
     private loadUtils;
 }

package/dist/jit/JitEngine.js

@@ -14,16 +14,23 @@ export class JitEngine {
     defaultSassConfig = '@use "sass:map";\n @use "../sass/tools/settings" as ml;';
     utilsByFile = new Map();
     utilsRegexps = {
-        quotedContent: /"\n?[^"]*?[A-Z][^"\n]*\n?"/g,
-        singleQuotedContent: /'\n?[^']*?[A-Z][^'\n]*\n?'/g,
+        quotedContent: /"\n?[^"]*[^"\n]*\n?"/g,
+        singleQuotedContent: /'\n?[^']*[^'\n]*\n?'/g,
+        backtickQuotedContent: /`\n?[^`]*[^`\n]*\n?`/g,
         tooMoreSpaces: /\s{2,}|\n/g,
+        escapedQuotes: /\\['"`]/g,
         utilName: /^-?[A-Z]{1}[a-zA-Z]*/,
+        uppercaseLetter: /[A-Z]/,
+        contextUtil: /-Ctx([\d\-#]|$)/,
     };
     configRegexps = {
         userSettings: /@use ['"][^'"]*(tools|mlut|core)['"](\s*as\s+[\w]+)?\s+with\s*\(([^;]+)\);/s,
         sassModuleName: /@use ['"][^'"]*(tools|mlut|core)['"]\s*;/s,
     };
     async init([inputPath, inputContent] = ['', '']) {
+        if (this.utils.size) {
+            return;
+        }
         let sassConfig = this.defaultSassConfig;
         if (inputPath && inputContent) {
             this.inputFileDir = path.dirname(path.resolve(process.cwd(), inputPath));
@@ -59,39 +66,39 @@ export class JitEngine {
         }
         const allUniqueUtils = [...new Set([...this.utilsByFile.values()].flat())];
         const applyStr = `\n@include ${this.sassModuleName}.apply(${JSON.stringify(allUniqueUtils)},(),true);`;
-        // `compileStringAsync` is almost always faster than `compile` in sass-embedded
         return sass.compileStringAsync(this.inputFileCache + applyStr, { loadPaths: [this.inputFileDir, 'node_modules'] }).then(({ css }) => css, (e) => (logger.error('Sass compilation error.', e), ''));
     }
     extractUtils(content) {
-        const allClassNames = [];
-        const quotedClassNames = content
+        let fixedContent = content.replace(this.utilsRegexps.escapedQuotes, '');
+        const allClassNames = fixedContent
             .match(this.utilsRegexps.quotedContent)
-            //eslint-disable-next-line
-            ?.map(this.normalizeClassNameStr, this);
-        const singleQuotedClassNames = content
-            .replace(this.utilsRegexps.quotedContent, '')
+            ?.reduce(this.filterAndProcessClassStr, []) ?? [];
+        fixedContent = fixedContent.replace(this.utilsRegexps.quotedContent, '');
+        fixedContent
             .match(this.utilsRegexps.singleQuotedContent)
-            //eslint-disable-next-line
-            ?.map(this.normalizeClassNameStr, this);
-        for (const item of [quotedClassNames, singleQuotedClassNames]) {
-            if (item instanceof Array) {
-                allClassNames.push(...item);
-            }
-        }
+            ?.reduce(this.filterAndProcessClassStr, allClassNames);
+        fixedContent
+            .replace(this.utilsRegexps.singleQuotedContent, '')
+            .match(this.utilsRegexps.backtickQuotedContent)
+            ?.reduce(this.filterAndProcessClassStr, allClassNames);
         return [...allClassNames.join(' ').split(' ').reduce((acc, cssClass) => {
                 const utility = cssClass.split('_').find((str) => (this.utilsRegexps.utilName.test(str)));
                 if (utility) {
                     const utilName = utility.match(this.utilsRegexps.utilName)?.[0];
-                    if (this.utils.has(utilName) || utilName[0] === '-') {
+                    if (this.utils.has(utilName) ||
+                        (utilName[0] === '-' && !this.utilsRegexps.contextUtil.test(utilName))) {
                         acc.add(cssClass);
                     }
                 }
                 return acc;
             }, new Set())];
     }
-    normalizeClassNameStr(str) {
-        return str.replace(this.utilsRegexps.tooMoreSpaces, ' ').slice(1, -1);
-    }
+    filterAndProcessClassStr = (acc, str) => {
+        if (this.utilsRegexps.uppercaseLetter.test(str)) {
+            acc.push(str.replace(this.utilsRegexps.tooMoreSpaces, ' ').slice(1, -1));
+        }
+        return acc;
+    };
     extractUserSassConfig(content) {
         let matchResult = content.match(this.configRegexps.userSettings);
         if (matchResult != null) {

package/dist/sass/tools/settings/base/_utils.scss

@@ -474,6 +474,8 @@ $utils-cfg: (
 			'rdo': ':read-only',
 			'rdw': ':read-write',
 			't': ':target',
+			'ui': ':user-invalid',
+			'uv': ':user-valid',
 			'v': ':visited',
 			'vl': ':valid',
 		),

package/dist/sass/tools/settings/common/_utils.scss

@@ -1591,6 +1591,18 @@ $utils-db: (
 					'nn': none,
 				),
 			),
+			'Coi': (
+				'properties': counter-increment,
+				'conversion': 'num-length',
+			),
+			'Cor': (
+				'properties': counter-reset,
+				'conversion': 'num-length',
+			),
+			'Cos': (
+				'properties': counter-set,
+				'conversion': 'num-length',
+			),
 
 			// SVG
 			'Fi': (

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@mlut/core",
-	"version": "2.0.0",
+	"version": "2.1.0",
 	"description": "Atomic CSS toolkit with Sass and ergonomics for creating styles of any complexity",
 	"author": "mr150",
 	"type": "module",