@nlabs/lex 1.51.1 → 1.51.2

package/lib/utils/postcss/postcss-for.d.ts

@@ -0,0 +1,11 @@
+interface PostcssForOptions {
+    nested?: boolean;
+}
+declare const postcssFor: {
+    (opts?: PostcssForOptions): {
+        postcssPlugin: string;
+        Once(root: any): void;
+    };
+    postcss: boolean;
+};
+export default postcssFor;

package/lib/utils/postcss/postcss-for.js

@@ -0,0 +1,136 @@
+/**
+ * Copyright (c) 2025-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ *
+ * PostCSS 8-compatible version of postcss-for plugin
+ * Original: https://github.com/antyakushev/postcss-for
+ */ import postcssSimpleVars from 'postcss-simple-vars';
+const postcssFor = (opts = {})=>{
+    const options = {
+        nested: opts.nested !== false
+    };
+    const iterStack = [];
+    const parentsHaveIterator = (rule, param)=>{
+        if (rule.parent == null) {
+            return false;
+        }
+        if (rule.parent.type === 'root') {
+            return false;
+        }
+        if (rule.parent.type !== 'atrule' || !rule.parent.params) {
+            return false;
+        }
+        const parentIterVar = rule.parent.params.split(/\s+/)[0];
+        if (!parentIterVar) {
+            return false;
+        }
+        if (parentIterVar === param) {
+            return true;
+        }
+        if (iterStack.indexOf(param) !== -1) {
+            return true;
+        }
+        return parentsHaveIterator(rule.parent, param);
+    };
+    const manageIterStack = (rule)=>{
+        if (rule.parent && rule.parent.type !== 'root') {
+            const parentIterVar = rule.parent.type === 'atrule' && rule.parent.params ? rule.parent.params.split(/\s+/)[0] : null;
+            if (parentIterVar && iterStack.indexOf(parentIterVar) === -1) {
+                iterStack.splice(0, iterStack.length);
+            } else if (parentIterVar) {
+                const parentIndex = iterStack.indexOf(parentIterVar);
+                if (parentIndex !== -1) {
+                    iterStack.splice(parentIndex + 1, iterStack.length - parentIndex - 1);
+                }
+            }
+        } else {
+            iterStack.splice(0, iterStack.length);
+        }
+        const currentIterVar = rule.params.split(/\s+/)[0];
+        if (currentIterVar) {
+            iterStack.push(currentIterVar);
+        }
+    };
+    const checkNumber = (rule)=>{
+        return (param)=>{
+            if (isNaN(parseInt(param, 10)) || !param.match(/^-?\d+\.?\d*$/)) {
+                if (param.indexOf('$') !== -1) {
+                    if (!parentsHaveIterator(rule, param)) {
+                        throw rule.error('External variable (not from a parent for loop) cannot be used as a range parameter', {
+                            plugin: 'postcss-for'
+                        });
+                    }
+                } else {
+                    throw rule.error('Range parameter should be a number', {
+                        plugin: 'postcss-for'
+                    });
+                }
+            }
+        };
+    };
+    const checkParams = (rule, params)=>{
+        if (!params[0]?.match(/(^|[^\w])\$([\w\d-_]+)/) || params[1] !== 'from' || params[3] !== 'to' || params[5] !== 'by' && params[5] !== undefined) {
+            throw rule.error('Wrong loop syntax', {
+                plugin: 'postcss-for'
+            });
+        }
+        [
+            params[2],
+            params[4],
+            params[6] || '0'
+        ].forEach(checkNumber(rule));
+    };
+    const unrollLoop = (rule)=>{
+        const params = rule.params.split(/\s+/);
+        checkParams(rule, params);
+        const iterator = params[0].slice(1);
+        const index = +params[2];
+        const top = +params[4];
+        const dir = top < index ? -1 : 1;
+        const by = +(params[6] || 1) * dir;
+        const value = {};
+        for(let i = index; i * dir <= top * dir; i = i + by){
+            const content = rule.clone();
+            value[iterator] = i;
+            postcssSimpleVars({
+                only: value
+            })(content);
+            if (options.nested) {
+                processLoops(content);
+            }
+            if (rule.parent) {
+                rule.parent.insertBefore(rule, content.nodes);
+            }
+        }
+        if (rule.parent) {
+            rule.remove();
+        }
+    };
+    const processLoops = (css)=>{
+        css.walkAtRules((rule)=>{
+            if (rule.name === 'for') {
+                unrollLoop(rule);
+            }
+        });
+    };
+    const processOriginalLoops = (css)=>{
+        css.walkAtRules((rule)=>{
+            if (rule.name === 'for') {
+                if (rule.parent) {
+                    manageIterStack(rule);
+                }
+                unrollLoop(rule);
+            }
+        });
+    };
+    return {
+        postcssPlugin: 'postcss-for',
+        Once (root) {
+            processOriginalLoops(root);
+        }
+    };
+};
+postcssFor.postcss = true;
+export default postcssFor;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/utils/postcss/postcss-for.ts"],"sourcesContent":["/**\n * Copyright (c) 2025-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n *\n * PostCSS 8-compatible version of postcss-for plugin\n * Original: https://github.com/antyakushev/postcss-for\n */\nimport postcss from 'postcss';\nimport postcssSimpleVars from 'postcss-simple-vars';\n\ninterface PostcssForOptions {\n  nested?: boolean;\n}\n\nconst postcssFor = (opts: PostcssForOptions = {}) => {\n  const options = {\n    nested: opts.nested !== false\n  };\n\n  const iterStack: string[] = [];\n\n  const parentsHaveIterator = (rule: postcss.AtRule, param: string): boolean => {\n    if (rule.parent == null) {\n      return false;\n    }\n    if (rule.parent.type === 'root') {\n      return false;\n    }\n    if (rule.parent.type !== 'atrule' || !rule.parent.params) {\n      return false;\n    }\n\n    const parentIterVar = rule.parent.params.split(/\\s+/)[0];\n    if (!parentIterVar) {\n      return false;\n    }\n    if (parentIterVar === param) {\n      return true;\n    }\n    if (iterStack.indexOf(param) !== -1) {\n      return true;\n    }\n    return parentsHaveIterator(rule.parent as postcss.AtRule, param);\n  };\n\n  const manageIterStack = (rule: postcss.AtRule) => {\n    if (rule.parent && rule.parent.type !== 'root') {\n      const parentIterVar = rule.parent.type === 'atrule' && rule.parent.params\n        ? rule.parent.params.split(/\\s+/)[0]\n        : null;\n      if (parentIterVar && iterStack.indexOf(parentIterVar) === -1) {\n        iterStack.splice(0, iterStack.length);\n      } else if (parentIterVar) {\n        const parentIndex = iterStack.indexOf(parentIterVar);\n        if (parentIndex !== -1) {\n          iterStack.splice(parentIndex + 1, iterStack.length - parentIndex - 1);\n        }\n      }\n    } else {\n      iterStack.splice(0, iterStack.length);\n    }\n    const currentIterVar = rule.params.split(/\\s+/)[0];\n    if (currentIterVar) {\n      iterStack.push(currentIterVar);\n    }\n  };\n\n  const checkNumber = (rule: postcss.AtRule) => {\n    return (param: string) => {\n      if (isNaN(parseInt(param, 10)) || !param.match(/^-?\\d+\\.?\\d*$/)) {\n        if (param.indexOf('$') !== -1) {\n          if (!parentsHaveIterator(rule, param)) {\n            throw rule.error('External variable (not from a parent for loop) cannot be used as a range parameter', {\n              plugin: 'postcss-for'\n            });\n          }\n        } else {\n          throw rule.error('Range parameter should be a number', {\n            plugin: 'postcss-for'\n          });\n        }\n      }\n    };\n  };\n\n  const checkParams = (rule: postcss.AtRule, params: string[]) => {\n    if (\n      !params[0]?.match(/(^|[^\\w])\\$([\\w\\d-_]+)/) ||\n      params[1] !== 'from' ||\n      params[3] !== 'to' ||\n      (params[5] !== 'by' && params[5] !== undefined)\n    ) {\n      throw rule.error('Wrong loop syntax', {\n        plugin: 'postcss-for'\n      });\n    }\n\n    [params[2], params[4], params[6] || '0'].forEach(checkNumber(rule));\n  };\n\n  const unrollLoop = (rule: postcss.AtRule) => {\n    const params = rule.params.split(/\\s+/);\n\n    checkParams(rule, params);\n\n    const iterator = params[0].slice(1);\n    const index = +params[2];\n    const top = +params[4];\n    const dir = top < index ? -1 : 1;\n    const by = (+(params[6] || 1)) * dir;\n\n    const value: Record<string, number> = {};\n    for (let i = index; i * dir <= top * dir; i = i + by) {\n      const content = rule.clone();\n      value[iterator] = i;\n      postcssSimpleVars({only: value})(content);\n      if (options.nested) {\n        processLoops(content);\n      }\n      if (rule.parent) {\n        rule.parent.insertBefore(rule, content.nodes);\n      }\n    }\n    if (rule.parent) {\n      rule.remove();\n    }\n  };\n\n  const processLoops = (css: postcss.Container) => {\n    css.walkAtRules((rule) => {\n      if (rule.name === 'for') {\n        unrollLoop(rule);\n      }\n    });\n  };\n\n  const processOriginalLoops = (css: postcss.Root) => {\n    css.walkAtRules((rule) => {\n      if (rule.name === 'for') {\n        if (rule.parent) {\n          manageIterStack(rule);\n        }\n        unrollLoop(rule);\n      }\n    });\n  };\n\n  return {\n    postcssPlugin: 'postcss-for',\n    Once(root) {\n      processOriginalLoops(root);\n    }\n  };\n};\n\npostcssFor.postcss = true;\n\nexport default postcssFor;\n\n"],"names":["postcssSimpleVars","postcssFor","opts","options","nested","iterStack","parentsHaveIterator","rule","param","parent","type","params","parentIterVar","split","indexOf","manageIterStack","splice","length","parentIndex","currentIterVar","push","checkNumber","isNaN","parseInt","match","error","plugin","checkParams","undefined","forEach","unrollLoop","iterator","slice","index","top","dir","by","value","i","content","clone","only","processLoops","insertBefore","nodes","remove","css","walkAtRules","name","processOriginalLoops","postcssPlugin","Once","root","postcss"],"mappings":"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"}

package/lib/utils/postcss/postcss-percentage.d.ts

@@ -0,0 +1,15 @@
+interface PostcssPercentageOptions {
+    floor?: boolean;
+    precision?: number;
+    trimTrailingZero?: boolean;
+}
+declare const postcssPercentage: {
+    (opts?: PostcssPercentageOptions): {
+        postcssPlugin: string;
+        Once(root: any, { result }: {
+            result: any;
+        }): void;
+    };
+    postcss: boolean;
+};
+export default postcssPercentage;

package/lib/utils/postcss/postcss-percentage.js

@@ -0,0 +1,65 @@
+/**
+ * Copyright (c) 2025-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ *
+ * PostCSS 8-compatible version of postcss-percentage plugin
+ * Original: https://github.com/antyakushev/postcss-percentage
+ */ import parser from 'postcss-value-parser';
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const evaluator = require('math-expression-evaluator');
+const transformPercentage = (value, precision, floor, trimTrailingZero)=>{
+    return parser(value).walk((node)=>{
+        if (node.type !== 'function' || node.value !== 'percentage') {
+            return;
+        }
+        let result = evaluator.eval(parser.stringify(node.nodes)) * 100;
+        let resultStr;
+        if (result === 0) {
+            resultStr = '0';
+        } else if (floor) {
+            const resultString = result.toString();
+            const index = resultString.indexOf('.');
+            resultStr = index === -1 ? resultString : resultString.substring(0, index + 1 + precision);
+        } else {
+            resultStr = result.toFixed(precision);
+        }
+        if (trimTrailingZero) {
+            resultStr = resultStr.replace(/\.0+$/, '').replace(/(\.\d*[1-9])0+$/, '$1');
+        }
+        resultStr += '%';
+        Object.assign(node, {
+            type: 'word',
+            value: resultStr
+        });
+    }).toString();
+};
+const postcssPercentage = (opts = {})=>{
+    const options = {
+        precision: opts.precision == null || opts.precision > 20 || opts.precision < 0 ? 6 : opts.precision,
+        trimTrailingZero: opts.trimTrailingZero == null ? true : opts.trimTrailingZero,
+        floor: opts.floor
+    };
+    return {
+        postcssPlugin: 'postcss-percentage',
+        Once (root, { result }) {
+            root.walkDecls((decl)=>{
+                if (!decl.value || !/percentage\s*\(/.test(decl.value)) {
+                    return;
+                }
+                try {
+                    decl.value = transformPercentage(decl.value, options.precision, options.floor, options.trimTrailingZero);
+                } catch (e) {
+                    const error = e;
+                    decl.warn(result, error.message, {
+                        word: decl.value,
+                        index: decl.index
+                    });
+                }
+            });
+        }
+    };
+};
+postcssPercentage.postcss = true;
+export default postcssPercentage;
+
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nlabs/lex",
-  "version": "1.51.1",
+  "version": "1.51.2",
   "description": "Lex",
   "license": "MIT",
   "type": "module",

package/postcss.config.js

@@ -7,19 +7,20 @@ import cssnano from 'cssnano';
 import postcssBrowserReporter from 'postcss-browser-reporter';
 import postcssCustomProperties from 'postcss-custom-properties';
 import postcssFlexbugsFixes from 'postcss-flexbugs-fixes';
-import postcssFor from 'postcss-for';
 import postcssHash from 'postcss-hash';
 import postcssImport from 'postcss-import';
 import postcssNesting from 'postcss-nesting';
 import tailwindcss from '@tailwindcss/postcss';
 import tailwindNesting from '@tailwindcss/nesting';
-import postcssPercentage from 'postcss-percentage';
 import postcssPresetEnv from 'postcss-preset-env';
 import postcssSimpleVars from 'postcss-simple-vars';
 import postcssSvgo from 'postcss-svgo';
 import postcssUrl from 'postcss-url';
 import {default as webpack} from 'webpack';
 
+import postcssFor from './lib/utils/postcss/postcss-for.js';
+import postcssPercentage from './lib/utils/postcss/postcss-percentage.js';
+
 const config = {
   plugins: [
     postcssImport({addDependencyTo: webpack}),

package/webpack.config.js

@@ -19,10 +19,8 @@ import {resolve as pathResolve} from 'path';
 import postcssBrowserReporter from 'postcss-browser-reporter';
 import postcssCustomProperties from 'postcss-custom-properties';
 import postcssFlexbugsFixes from 'postcss-flexbugs-fixes';
-import postcssFor from 'postcss-for';
 import postcssImport from 'postcss-import';
 import postcssNesting from 'postcss-nesting';
-import postcssPercentage from 'postcss-percentage';
 import postcssPresetEnv from 'postcss-preset-env';
 import postcssUrl from 'postcss-url';
 import SVGSpriteMapPlugin from 'svg-spritemap-webpack-plugin';
@@ -35,6 +33,8 @@ import {WebpackPluginServe} from 'webpack-plugin-serve';
 
 import {relativeFilePath, relativeNodePath} from './lib/utils/file.js';
 import {LexConfig} from './lib/LexConfig.js';
+import postcssFor from './lib/utils/postcss/postcss-for.js';
+import postcssPercentage from './lib/utils/postcss/postcss-percentage.js';
 
 const {ProgressPlugin, ProvidePlugin} = webpack;
 const isProduction = process.env.NODE_ENV === 'production';