@nlabs/lex 1.55.2 → 1.56.1

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

@@ -11,16 +11,17 @@ const postcssFor = (opts = {})=>{
     };
     const iterStack = [];
     const parentsHaveIterator = (rule, param)=>{
-        if (rule.parent === null) {
+        const parent = rule.parent;
+        if (parent === null || parent === undefined) {
             return false;
         }
-        if (rule.parent.type === 'root') {
+        if (parent.type === 'root') {
             return false;
         }
-        if (rule.parent.type !== 'atrule' || !rule.parent.params) {
+        if (parent.type !== 'atrule') {
             return false;
         }
-        const parentIterVar = rule.parent.params.split(/\s+/)[0];
+        const parentIterVar = parent.params.split(/\s+/)[0];
         if (!parentIterVar) {
             return false;
         }
@@ -30,7 +31,7 @@ const postcssFor = (opts = {})=>{
         if (iterStack.indexOf(param) !== -1) {
             return true;
         }
-        return parentsHaveIterator(rule.parent, param);
+        return parentsHaveIterator(parent, param);
     };
     const manageIterStack = (rule)=>{
         if (rule.parent && rule.parent.type !== 'root') {
@@ -139,4 +140,4 @@ const postcssFor = (opts = {})=>{
 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) => (param: string) => {\n    if(isNaN(Number(param)) || !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  const checkParams = (rule: postcss.AtRule, params: string[]) => {\n    if(\n      !params[0]?.startsWith('$') ||\n      params[1] !== 'from' ||\n      params[3] !== 'to' ||\n      (params[5] && params[5] !== 'by')\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      const simpleVarsPlugin = postcssSimpleVars({only: value});\n      if(simpleVarsPlugin.prepare) {\n        const prepared = simpleVarsPlugin.prepare({} as any);\n        if(prepared.Once) {\n          prepared.Once(content, {} as any);\n        }\n      } else if(typeof simpleVarsPlugin === 'function') {\n        simpleVarsPlugin(content);\n      }\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    Once(root) {\n      processOriginalLoops(root);\n    },\n    postcssPlugin: 'postcss-for'\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","Number","match","error","plugin","checkParams","startsWith","forEach","unrollLoop","iterator","slice","index","top","dir","by","value","i","content","clone","simpleVarsPlugin","only","prepare","prepared","Once","processLoops","insertBefore","nodes","remove","css","walkAtRules","name","processOriginalLoops","root","postcssPlugin","postcss"],"mappings":"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"}
+//# 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    const parent = rule.parent;\n\n    if(parent === null || parent === undefined) {\n      return false;\n    }\n    if(parent.type === 'root') {\n      return false;\n    }\n    if(parent.type !== 'atrule') {\n      return false;\n    }\n\n    const parentIterVar = 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(parent, 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) => (param: string) => {\n    if(isNaN(Number(param)) || !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  const checkParams = (rule: postcss.AtRule, params: string[]) => {\n    if(\n      !params[0]?.startsWith('$') ||\n      params[1] !== 'from' ||\n      params[3] !== 'to' ||\n      (params[5] && params[5] !== 'by')\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      const simpleVarsPlugin = postcssSimpleVars({only: value});\n      if(simpleVarsPlugin.prepare) {\n        const prepared = simpleVarsPlugin.prepare({} as any);\n        if(prepared.Once) {\n          prepared.Once(content, {} as any);\n        }\n      } else if(typeof simpleVarsPlugin === 'function') {\n        simpleVarsPlugin(content);\n      }\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<postcss.ChildNode>) => {\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    Once(root: postcss.Root) {\n      processOriginalLoops(root);\n    },\n    postcssPlugin: 'postcss-for'\n  };\n};\n\npostcssFor.postcss = true;\n\nexport default postcssFor;\n"],"names":["postcssSimpleVars","postcssFor","opts","options","nested","iterStack","parentsHaveIterator","rule","param","parent","undefined","type","parentIterVar","params","split","indexOf","manageIterStack","splice","length","parentIndex","currentIterVar","push","checkNumber","isNaN","Number","match","error","plugin","checkParams","startsWith","forEach","unrollLoop","iterator","slice","index","top","dir","by","value","i","content","clone","simpleVarsPlugin","only","prepare","prepared","Once","processLoops","insertBefore","nodes","remove","css","walkAtRules","name","processOriginalLoops","root","postcssPlugin","postcss"],"mappings":"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"}

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

@@ -1,3 +1,4 @@
+import postcss from 'postcss';
 interface PostcssPercentageOptions {
     floor?: boolean;
     precision?: number;
@@ -5,8 +6,8 @@ interface PostcssPercentageOptions {
 }
 declare const postcssPercentage: {
     (opts?: PostcssPercentageOptions): {
-        Once(root: any, { result }: {
-            result: any;
+        Once(root: postcss.Root, { result }: {
+            result: postcss.Result;
         }): void;
         postcssPlugin: string;
     };

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

@@ -53,7 +53,6 @@ const postcssPercentage = (opts = {})=>{
                 } catch (e) {
                     const error = e;
                     decl.warn(result, error.message, {
-                        index: decl.index,
                         word: decl.value
                     });
                 }
@@ -65,4 +64,4 @@ const postcssPercentage = (opts = {})=>{
 postcssPercentage.postcss = true;
 export default postcssPercentage;
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/webpack/LexSvgSpritemapPlugin.d.ts

@@ -0,0 +1,20 @@
+import webpack from 'webpack';
+type IdentifierPrefix = false | string | ((filePath: string) => string);
+export interface LexSvgSpritemapPluginOptions {
+    readonly allowDuplicates?: boolean;
+    readonly filename?: string;
+    readonly optimize?: boolean;
+    readonly prefix?: IdentifierPrefix;
+}
+export declare class LexSvgSpritemapPlugin {
+    readonly patterns: string[];
+    readonly options: Required<LexSvgSpritemapPluginOptions>;
+    constructor(patterns: string | string[], options?: LexSvgSpritemapPluginOptions);
+    buildSpritemap(): {
+        content: string | null;
+        filePaths: string[];
+        warnings: webpack.WebpackError[];
+    };
+    apply(compiler: webpack.Compiler): void;
+}
+export default LexSvgSpritemapPlugin;

package/lib/utils/webpack/LexSvgSpritemapPlugin.js

@@ -0,0 +1,257 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { readFileSync } from 'fs';
+import { sync as globSync } from 'glob';
+import { basename as pathBasename, dirname as pathDirname, extname as pathExtname, resolve as pathResolve } from 'path';
+import { optimize } from 'svgo';
+import webpack from 'webpack';
+const DEFAULT_FILENAME = 'icons/icons.svg';
+const PLUGIN_NAME = 'LexSvgSpritemapPlugin';
+const ROOT_EXCLUDED_ATTRIBUTES = new Set([
+    'height',
+    'id',
+    'version',
+    'viewBox',
+    'width',
+    'xmlns'
+]);
+const escapeAttribute = (value)=>{
+    return value.replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+};
+const normalizeAssetFilename = (filename)=>{
+    return filename.replace(/^[./]+/, '');
+};
+const parseAttributes = (input)=>{
+    const attributes = {};
+    const attributeRegex = /([:@\w-]+)\s*=\s*("([^"]*)"|'([^']*)')/g;
+    let match = attributeRegex.exec(input);
+    while(match){
+        attributes[match[1]] = match[3] ?? match[4] ?? '';
+        match = attributeRegex.exec(input);
+    }
+    return attributes;
+};
+const parseSvg = (source)=>{
+    const svgMatch = source.replace(/<\?xml[\s\S]*?\?>/ig, '').replace(/<!doctype[\s\S]*?>/ig, '').match(/<svg\b([^>]*)>([\s\S]*?)<\/svg>/i);
+    if (!svgMatch) {
+        return null;
+    }
+    return {
+        attributes: parseAttributes(svgMatch[1] || ''),
+        content: svgMatch[2]?.trim() || ''
+    };
+};
+const buildAttributeString = (attributes)=>{
+    return Object.entries(attributes).map(([name, value])=>`${name}="${escapeAttribute(value)}"`).join(' ');
+};
+const sanitizeIdentifier = (value)=>{
+    const sanitizedValue = value.trim().replaceAll(/\s+/g, '-').replaceAll(/[^A-Za-z0-9_-]/g, '-').replaceAll(/-{2,}/g, '-').replaceAll(/^[-_]+|[-_]+$/g, '');
+    const safeValue = sanitizedValue || 'icon';
+    return /^[A-Za-z_]/.test(safeValue) ? safeValue : `icon-${safeValue}`;
+};
+const getPrefix = (filePath, prefix)=>{
+    if (prefix === false) {
+        return '';
+    }
+    if (typeof prefix === 'function') {
+        return prefix(filePath);
+    }
+    return prefix || '';
+};
+const optimizeSvg = (content, enabled)=>{
+    if (!enabled) {
+        return content;
+    }
+    return optimize(content, {
+        multipass: true,
+        plugins: [
+            {
+                name: 'preset-default',
+                params: {
+                    overrides: {
+                        cleanupIds: false
+                    }
+                }
+            }
+        ]
+    }).data;
+};
+const createSpriteSymbol = (filePath, usedIdentifiers, prefix, warnings)=>{
+    const source = readFileSync(filePath, 'utf8');
+    const parsedSvg = parseSvg(source);
+    if (!parsedSvg) {
+        warnings.push(new webpack.WebpackError(`Invalid SVG icon: ${filePath}`));
+        return null;
+    }
+    if (!parsedSvg.content) {
+        warnings.push(new webpack.WebpackError(`SVG icon is empty: ${filePath}`));
+        return null;
+    }
+    const rawIdentifier = `${getPrefix(filePath, prefix)}${pathBasename(filePath, pathExtname(filePath))}`;
+    const baseIdentifier = sanitizeIdentifier(rawIdentifier);
+    let identifier = baseIdentifier;
+    let duplicateIndex = 1;
+    while(usedIdentifiers.has(identifier)){
+        duplicateIndex += 1;
+        identifier = `${baseIdentifier}-${duplicateIndex}`;
+    }
+    if (identifier !== baseIdentifier) {
+        warnings.push(new webpack.WebpackError(`Duplicate SVG icon id "${baseIdentifier}" detected, using "${identifier}" for ${filePath}`));
+    }
+    usedIdentifiers.add(identifier);
+    const namespaceAttributes = Object.entries(parsedSvg.attributes).reduce((result, [name, value])=>{
+        if (name.toLowerCase().startsWith('xmlns:')) {
+            result[name] = value;
+        }
+        return result;
+    }, {});
+    const symbolAttributes = Object.entries(parsedSvg.attributes).reduce((result, [name, value])=>{
+        if (ROOT_EXCLUDED_ATTRIBUTES.has(name)) {
+            return result;
+        }
+        if (name.toLowerCase().startsWith('xmlns:')) {
+            return result;
+        }
+        result[name] = value;
+        return result;
+    }, {
+        id: identifier
+    });
+    if (parsedSvg.attributes.viewBox) {
+        symbolAttributes.viewBox = parsedSvg.attributes.viewBox;
+    } else {
+        const width = Number.parseFloat(parsedSvg.attributes.width || '');
+        const height = Number.parseFloat(parsedSvg.attributes.height || '');
+        if (Number.isFinite(width) && Number.isFinite(height)) {
+            symbolAttributes.viewBox = `0 0 ${width} ${height}`;
+        } else {
+            warnings.push(new webpack.WebpackError(`SVG icon is missing a viewBox and readable width/height: ${filePath}`));
+            return null;
+        }
+    }
+    return {
+        filePath,
+        namespaceAttributes,
+        symbol: `<symbol ${buildAttributeString(symbolAttributes)}>${parsedSvg.content}</symbol>`
+    };
+};
+const collectFiles = (patterns, allowDuplicates)=>{
+    const files = patterns.flatMap((pattern)=>{
+        return globSync(pattern, {
+            absolute: true,
+            dot: false,
+            nodir: true
+        });
+    }).map((filePath)=>pathResolve(filePath));
+    if (allowDuplicates) {
+        return files;
+    }
+    return [
+        ...new Set(files)
+    ];
+};
+export class LexSvgSpritemapPlugin {
+    buildSpritemap() {
+        const warnings = [];
+        const filePaths = collectFiles(this.patterns, this.options.allowDuplicates);
+        if (filePaths.length === 0) {
+            return {
+                content: null,
+                filePaths,
+                warnings
+            };
+        }
+        const namespaceAttributes = {};
+        const usedIdentifiers = new Set();
+        const symbols = filePaths.map((filePath)=>{
+            return createSpriteSymbol(filePath, usedIdentifiers, this.options.prefix, warnings);
+        }).filter((entry)=>entry !== null);
+        if (symbols.length === 0) {
+            return {
+                content: null,
+                filePaths,
+                warnings
+            };
+        }
+        for (const symbol of symbols){
+            for (const [name, value] of Object.entries(symbol.namespaceAttributes)){
+                namespaceAttributes[name] = value;
+            }
+        }
+        const rootAttributes = buildAttributeString({
+            xmlns: 'http://www.w3.org/2000/svg',
+            ...namespaceAttributes
+        });
+        const spriteContent = `<svg ${rootAttributes}>${symbols.map((symbol)=>symbol.symbol).join('')}</svg>`;
+        return {
+            content: optimizeSvg(spriteContent, this.options.optimize),
+            filePaths,
+            warnings
+        };
+    }
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation)=>{
+            const directories = new Set();
+            const spritemap = this.buildSpritemap();
+            for (const filePath of spritemap.filePaths){
+                compilation.fileDependencies.add(filePath);
+                directories.add(pathDirname(filePath));
+            }
+            for (const pattern of this.patterns){
+                const baseDirectory = pathResolve(pattern.replace(/\*.*$/, ''));
+                directories.add(baseDirectory);
+            }
+            for (const directory of directories){
+                compilation.contextDependencies.add(directory);
+            }
+            if (spritemap.warnings.length > 0) {
+                compilation.warnings.push(...spritemap.warnings);
+            }
+            compilation.hooks.processAssets.tap({
+                name: PLUGIN_NAME,
+                stage: webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
+            }, ()=>{
+                if (!spritemap.content) {
+                    return;
+                }
+                const assetName = this.options.filename;
+                const source = new webpack.sources.RawSource(spritemap.content);
+                if (compilation.getAsset(assetName)) {
+                    compilation.updateAsset(assetName, source);
+                    return;
+                }
+                compilation.emitAsset(assetName, source);
+            });
+        });
+    }
+    constructor(patterns, options = {}){
+        _define_property(this, "patterns", void 0);
+        _define_property(this, "options", void 0);
+        this.patterns = Array.isArray(patterns) ? patterns : [
+            patterns
+        ];
+        this.options = {
+            allowDuplicates: options.allowDuplicates ?? false,
+            filename: normalizeAssetFilename(options.filename || DEFAULT_FILENAME),
+            optimize: options.optimize ?? true,
+            prefix: options.prefix ?? false
+        };
+    }
+}
+export default LexSvgSpritemapPlugin;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/utils/webpack/LexSvgSpritemapPlugin.ts"],"sourcesContent":["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {readFileSync} from 'fs';\nimport {sync as globSync} from 'glob';\nimport {basename as pathBasename, dirname as pathDirname, extname as pathExtname, resolve as pathResolve} from 'path';\nimport {optimize} from 'svgo';\nimport webpack from 'webpack';\n\ntype IdentifierPrefix = false | string | ((filePath: string) => string);\n\nexport interface LexSvgSpritemapPluginOptions {\n  readonly allowDuplicates?: boolean;\n  readonly filename?: string;\n  readonly optimize?: boolean;\n  readonly prefix?: IdentifierPrefix;\n}\n\ninterface ParsedSvg {\n  readonly attributes: Record<string, string>;\n  readonly content: string;\n}\n\ninterface SpriteSymbol {\n  readonly filePath: string;\n  readonly namespaceAttributes: Record<string, string>;\n  readonly symbol: string;\n}\n\nconst DEFAULT_FILENAME = 'icons/icons.svg';\nconst PLUGIN_NAME = 'LexSvgSpritemapPlugin';\nconst ROOT_EXCLUDED_ATTRIBUTES = new Set([\n  'height',\n  'id',\n  'version',\n  'viewBox',\n  'width',\n  'xmlns'\n]);\n\nconst escapeAttribute = (value: string): string => {\n  return value\n    .replaceAll('&', '&amp;')\n    .replaceAll('\"', '&quot;')\n    .replaceAll('<', '&lt;')\n    .replaceAll('>', '&gt;');\n};\n\nconst normalizeAssetFilename = (filename: string): string => {\n  return filename.replace(/^[./]+/, '');\n};\n\nconst parseAttributes = (input: string): Record<string, string> => {\n  const attributes: Record<string, string> = {};\n  const attributeRegex = /([:@\\w-]+)\\s*=\\s*(\"([^\"]*)\"|'([^']*)')/g;\n\n  let match: RegExpExecArray | null = attributeRegex.exec(input);\n  while(match) {\n    attributes[match[1]] = match[3] ?? match[4] ?? '';\n    match = attributeRegex.exec(input);\n  }\n\n  return attributes;\n};\n\nconst parseSvg = (source: string): ParsedSvg | null => {\n  const svgMatch = source\n    .replace(/<\\?xml[\\s\\S]*?\\?>/ig, '')\n    .replace(/<!doctype[\\s\\S]*?>/ig, '')\n    .match(/<svg\\b([^>]*)>([\\s\\S]*?)<\\/svg>/i);\n\n  if(!svgMatch) {\n    return null;\n  }\n\n  return {\n    attributes: parseAttributes(svgMatch[1] || ''),\n    content: svgMatch[2]?.trim() || ''\n  };\n};\n\nconst buildAttributeString = (attributes: Record<string, string>): string => {\n  return Object.entries(attributes)\n    .map(([name, value]) => `${name}=\"${escapeAttribute(value)}\"`)\n    .join(' ');\n};\n\nconst sanitizeIdentifier = (value: string): string => {\n  const sanitizedValue = value\n    .trim()\n    .replaceAll(/\\s+/g, '-')\n    .replaceAll(/[^A-Za-z0-9_-]/g, '-')\n    .replaceAll(/-{2,}/g, '-')\n    .replaceAll(/^[-_]+|[-_]+$/g, '');\n\n  const safeValue = sanitizedValue || 'icon';\n\n  return /^[A-Za-z_]/.test(safeValue) ? safeValue : `icon-${safeValue}`;\n};\n\nconst getPrefix = (filePath: string, prefix: IdentifierPrefix): string => {\n  if(prefix === false) {\n    return '';\n  }\n\n  if(typeof prefix === 'function') {\n    return prefix(filePath);\n  }\n\n  return prefix || '';\n};\n\nconst optimizeSvg = (content: string, enabled: boolean): string => {\n  if(!enabled) {\n    return content;\n  }\n\n  return optimize(content, {\n    multipass: true,\n    plugins: [{\n      name: 'preset-default',\n      params: {\n        overrides: {\n          cleanupIds: false\n        }\n      }\n    }]\n  }).data;\n};\n\nconst createSpriteSymbol = (\n  filePath: string,\n  usedIdentifiers: Set<string>,\n  prefix: IdentifierPrefix,\n  warnings: webpack.WebpackError[]\n): SpriteSymbol | null => {\n  const source = readFileSync(filePath, 'utf8');\n  const parsedSvg = parseSvg(source);\n\n  if(!parsedSvg) {\n    warnings.push(new webpack.WebpackError(`Invalid SVG icon: ${filePath}`));\n    return null;\n  }\n\n  if(!parsedSvg.content) {\n    warnings.push(new webpack.WebpackError(`SVG icon is empty: ${filePath}`));\n    return null;\n  }\n\n  const rawIdentifier = `${getPrefix(filePath, prefix)}${pathBasename(filePath, pathExtname(filePath))}`;\n  const baseIdentifier = sanitizeIdentifier(rawIdentifier);\n\n  let identifier = baseIdentifier;\n  let duplicateIndex = 1;\n\n  while(usedIdentifiers.has(identifier)) {\n    duplicateIndex += 1;\n    identifier = `${baseIdentifier}-${duplicateIndex}`;\n  }\n\n  if(identifier !== baseIdentifier) {\n    warnings.push(new webpack.WebpackError(`Duplicate SVG icon id \"${baseIdentifier}\" detected, using \"${identifier}\" for ${filePath}`));\n  }\n\n  usedIdentifiers.add(identifier);\n\n  const namespaceAttributes = Object.entries(parsedSvg.attributes).reduce<Record<string, string>>((result, [name, value]) => {\n    if(name.toLowerCase().startsWith('xmlns:')) {\n      result[name] = value;\n    }\n\n    return result;\n  }, {});\n\n  const symbolAttributes = Object.entries(parsedSvg.attributes).reduce<Record<string, string>>((result, [name, value]) => {\n    if(ROOT_EXCLUDED_ATTRIBUTES.has(name)) {\n      return result;\n    }\n\n    if(name.toLowerCase().startsWith('xmlns:')) {\n      return result;\n    }\n\n    result[name] = value;\n\n    return result;\n  }, {\n    id: identifier\n  });\n\n  if(parsedSvg.attributes.viewBox) {\n    symbolAttributes.viewBox = parsedSvg.attributes.viewBox;\n  } else {\n    const width = Number.parseFloat(parsedSvg.attributes.width || '');\n    const height = Number.parseFloat(parsedSvg.attributes.height || '');\n\n    if(Number.isFinite(width) && Number.isFinite(height)) {\n      symbolAttributes.viewBox = `0 0 ${width} ${height}`;\n    } else {\n      warnings.push(new webpack.WebpackError(`SVG icon is missing a viewBox and readable width/height: ${filePath}`));\n      return null;\n    }\n  }\n\n  return {\n    filePath,\n    namespaceAttributes,\n    symbol: `<symbol ${buildAttributeString(symbolAttributes)}>${parsedSvg.content}</symbol>`\n  };\n};\n\nconst collectFiles = (patterns: readonly string[], allowDuplicates: boolean): string[] => {\n  const files = patterns.flatMap((pattern) => {\n    return globSync(pattern, {\n      absolute: true,\n      dot: false,\n      nodir: true\n    }) as string[];\n  }).map((filePath) => pathResolve(filePath));\n\n  if(allowDuplicates) {\n    return files;\n  }\n\n  return [...new Set(files)];\n};\n\nexport class LexSvgSpritemapPlugin {\n  readonly patterns: string[];\n  readonly options: Required<LexSvgSpritemapPluginOptions>;\n\n  constructor(patterns: string | string[], options: LexSvgSpritemapPluginOptions = {}) {\n    this.patterns = Array.isArray(patterns) ? patterns : [patterns];\n    this.options = {\n      allowDuplicates: options.allowDuplicates ?? false,\n      filename: normalizeAssetFilename(options.filename || DEFAULT_FILENAME),\n      optimize: options.optimize ?? true,\n      prefix: options.prefix ?? false\n    };\n  }\n\n  buildSpritemap(): {content: string | null; filePaths: string[]; warnings: webpack.WebpackError[]} {\n    const warnings: webpack.WebpackError[] = [];\n    const filePaths = collectFiles(this.patterns, this.options.allowDuplicates);\n\n    if(filePaths.length === 0) {\n      return {\n        content: null,\n        filePaths,\n        warnings\n      };\n    }\n\n    const namespaceAttributes: Record<string, string> = {};\n    const usedIdentifiers = new Set<string>();\n    const symbols = filePaths.map((filePath) => {\n      return createSpriteSymbol(filePath, usedIdentifiers, this.options.prefix, warnings);\n    }).filter((entry): entry is SpriteSymbol => entry !== null);\n\n    if(symbols.length === 0) {\n      return {\n        content: null,\n        filePaths,\n        warnings\n      };\n    }\n\n    for(const symbol of symbols) {\n      for(const [name, value] of Object.entries(symbol.namespaceAttributes)) {\n        namespaceAttributes[name] = value;\n      }\n    }\n\n    const rootAttributes = buildAttributeString({\n      xmlns: 'http://www.w3.org/2000/svg',\n      ...namespaceAttributes\n    });\n    const spriteContent = `<svg ${rootAttributes}>${symbols.map((symbol) => symbol.symbol).join('')}</svg>`;\n\n    return {\n      content: optimizeSvg(spriteContent, this.options.optimize),\n      filePaths,\n      warnings\n    };\n  }\n\n  apply(compiler: webpack.Compiler): void {\n    compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {\n      const directories = new Set<string>();\n      const spritemap = this.buildSpritemap();\n\n      for(const filePath of spritemap.filePaths) {\n        compilation.fileDependencies.add(filePath);\n        directories.add(pathDirname(filePath));\n      }\n\n      for(const pattern of this.patterns) {\n        const baseDirectory = pathResolve(pattern.replace(/\\*.*$/, ''));\n        directories.add(baseDirectory);\n      }\n\n      for(const directory of directories) {\n        compilation.contextDependencies.add(directory);\n      }\n\n      if(spritemap.warnings.length > 0) {\n        compilation.warnings.push(...spritemap.warnings);\n      }\n\n      compilation.hooks.processAssets.tap({\n        name: PLUGIN_NAME,\n        stage: webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL\n      }, () => {\n        if(!spritemap.content) {\n          return;\n        }\n\n        const assetName = this.options.filename;\n        const source = new webpack.sources.RawSource(spritemap.content);\n\n        if(compilation.getAsset(assetName)) {\n          compilation.updateAsset(assetName, source);\n          return;\n        }\n\n        compilation.emitAsset(assetName, source);\n      });\n    });\n  }\n}\n\nexport default LexSvgSpritemapPlugin;\n"],"names":["readFileSync","sync","globSync","basename","pathBasename","dirname","pathDirname","extname","pathExtname","resolve","pathResolve","optimize","webpack","DEFAULT_FILENAME","PLUGIN_NAME","ROOT_EXCLUDED_ATTRIBUTES","Set","escapeAttribute","value","replaceAll","normalizeAssetFilename","filename","replace","parseAttributes","input","attributes","attributeRegex","match","exec","parseSvg","source","svgMatch","content","trim","buildAttributeString","Object","entries","map","name","join","sanitizeIdentifier","sanitizedValue","safeValue","test","getPrefix","filePath","prefix","optimizeSvg","enabled","multipass","plugins","params","overrides","cleanupIds","data","createSpriteSymbol","usedIdentifiers","warnings","parsedSvg","push","WebpackError","rawIdentifier","baseIdentifier","identifier","duplicateIndex","has","add","namespaceAttributes","reduce","result","toLowerCase","startsWith","symbolAttributes","id","viewBox","width","Number","parseFloat","height","isFinite","symbol","collectFiles","patterns","allowDuplicates","files","flatMap","pattern","absolute","dot","nodir","LexSvgSpritemapPlugin","buildSpritemap","filePaths","options","length","symbols","filter","entry","rootAttributes","xmlns","spriteContent","apply","compiler","hooks","thisCompilation","tap","compilation","directories","spritemap","fileDependencies","baseDirectory","directory","contextDependencies","processAssets","stage","Compilation","PROCESS_ASSETS_STAGE_ADDITIONAL","assetName","sources","RawSource","getAsset","updateAsset","emitAsset","Array","isArray"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nlabs/lex",
-  "version": "1.55.2",
+  "version": "1.56.1",
   "description": "Lex",
   "license": "MIT",
   "type": "module",
@@ -83,40 +83,39 @@
   "dependencies": {
     "@mdx-js/loader": "^3.1.1",
     "@nlabs/webpack-plugin-static-site": "*",
-    "@storybook/addon-docs": "^10.2.17",
-    "@storybook/addon-links": "^10.2.17",
-    "@storybook/addon-postcss": "^2.0.0",
-    "@storybook/addon-styling-webpack": "^3.0.0",
-    "@storybook/addon-themes": "^10.2.17",
-    "@storybook/cli": "^10.2.17",
-    "@storybook/react": "^10.2.17",
-    "@storybook/react-webpack5": "^10.2.17",
-    "@swc/cli": "^0.8.0",
-    "@swc/core": "^1.15.18",
+    "@storybook/addon-docs": "^10.3.4",
+    "@storybook/addon-links": "^10.3.4",
+    "@storybook/addon-styling-webpack": "^3.0.2",
+    "@storybook/addon-themes": "^10.3.4",
+    "@storybook/cli": "^10.3.4",
+    "@storybook/react": "^10.3.4",
+    "@storybook/react-webpack5": "^10.3.4",
+    "@swc/cli": "^0.8.1",
+    "@swc/core": "^1.15.24",
     "@tailwindcss/forms": "^0.5.11",
     "@tailwindcss/nesting": "^0.0.0-insiders.565cd3e",
-    "@tailwindcss/postcss": "4.2.1",
+    "@tailwindcss/postcss": "4.2.2",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.2",
-    "@vitest/coverage-v8": "^4.0.18",
+    "@vitest/coverage-v8": "^4.1.2",
     "assert": "^2.1.0",
     "autoprefixer": "^10.4.27",
     "boxen": "8.0.1",
     "buffer": "^6.0.3",
-    "caniuse-lite": "1.0.30001777",
+    "caniuse-lite": "1.0.30001786",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "compare-versions": "^6.1.1",
     "compression-webpack-plugin": "^12.0.0",
     "copy-webpack-plugin": "^14.0.0",
-    "core-js": "^3.48.0",
+    "core-js": "^3.49.0",
     "crypto-js": "^4.2.0",
     "css-loader": "^7.1.4",
     "css-minimizer-webpack-plugin": "^8.0.0",
-    "cssnano": "^7.1.3",
+    "cssnano": "^7.1.4",
     "dotenv-webpack": "^9.0.0",
     "download-npm-package": "^3.1.12",
-    "eslint": "^10.0.3",
+    "eslint": "^10.2.0",
     "eslint-config-styleguidejs": "^5.0.4",
     "execa": "9.6.1",
     "expect": "^30.3.0",
@@ -125,20 +124,20 @@
     "find-file-up": "^2.0.1",
     "glob": "^13.0.6",
     "global": "^4.4.0",
-    "graphql": "^16.13.1",
+    "graphql": "^16.13.2",
     "graphql-tag": "^2.12.6",
     "html-loader": "^5.1.0",
     "html-webpack-plugin": "^5.6.6",
     "https-browserify": "^1.0.0",
     "image-webpack-loader": "^8.1.0",
-    "jsdom": "^28.1.0",
+    "jsdom": "^29.0.1",
     "latest-version": "9.0.0",
-    "lodash": "^4.17.23",
+    "lodash": "^4.18.1",
     "luxon": "^3.7.2",
     "math-expression-evaluator": "^2.0.7",
-    "mini-css-extract-plugin": "^2.10.1",
-    "npm-check-updates": "^19.6.3",
-    "openai": "^6.27.0",
+    "mini-css-extract-plugin": "^2.10.2",
+    "npm-check-updates": "^20.0.0",
+    "openai": "^6.33.0",
     "ora": "9.3.0",
     "os-browserify": "^0.3.0",
     "path-browserify": "^1.0.1",
@@ -147,12 +146,10 @@
     "postcss-cli": "^11.0.1",
     "postcss-custom-properties": "^15.0.1",
     "postcss-flexbugs-fixes": "^5.0.2",
-    "postcss-for": "^2.1.1",
     "postcss-hash": "^3.0.0",
     "postcss-import": "16.1.1",
     "postcss-loader": "^8.2.1",
     "postcss-nesting": "^14.0.0",
-    "postcss-percentage": "^0.0.0",
     "postcss-preset-env": "^11.2.0",
     "postcss-simple-vars": "^7.0.1",
     "postcss-svgo": "7.1.1",
@@ -167,37 +164,37 @@
     "rimraf": "^6.1.3",
     "semver": "^7.7.4",
     "source-map-loader": "^5.0.0",
-    "storybook": "^10.2.17",
+    "storybook": "^10.3.4",
     "stream-browserify": "^3.0.0",
     "stream-http": "^3.2.0",
     "style-loader": "^4.0.0",
-    "svg-spritemap-webpack-plugin": "^5.1.0",
     "svgo": "4.0.1",
     "swc-loader": "^0.2.7",
-    "tailwindcss": "^4.2.1",
+    "tailwindcss": "^4.2.2",
     "ts-node": "^10.9.2",
     "tsconfig-paths-webpack-plugin": "^4.2.0",
-    "typescript": "5.9.3",
+    "typescript": "^6.0.2",
     "util": "^0.12.5",
-    "vitest": "^4.0.18",
+    "vitest": "^4.1.2",
     "vm-browserify": "^1.1.2",
     "webpack": "5.105.4",
-    "webpack-bundle-analyzer": "^5.2.0",
-    "webpack-cli": "^6.0.1",
+    "webpack-bundle-analyzer": "^5.3.0",
+    "webpack-cli": "^7.0.2",
     "webpack-merge": "^6.0.1",
     "webpack-plugin-serve": "^1.6.0",
-    "ws": "^8.19.0"
+    "ws": "^8.20.0"
   },
   "devDependencies": {
     "@types/express": "^5.0.6",
     "@types/luxon": "^3.7.1",
-    "@types/node": "^25.4.0",
+    "@types/node": "^25.5.2",
     "@types/ora": "^3.2.0",
     "@types/react": "^19.2.14",
     "@types/webpack": "^5.28.5"
   },
   "overrides": {
     "cross-spawn": "^7.0.6",
+    "fast-xml-parser": "^5.5.10",
     "got": "^14.6.6",
     "http-proxy-middleware": "^3.0.5",
     "minimatch": ">=10.2.4",

package/tsconfig.json

@@ -21,6 +21,7 @@
     "pretty": true,
     "resolveJsonModule": true,
     "skipLibCheck": true,
+    "useUnknownInCatchVariables": false,
     "target": "ESNext",
     "types": [
       "vitest/globals",