@nlabs/lex 1.59.4 → 2.0.0

package/lib/utils/assets/LexSvgSpritemap.js

@@ -0,0 +1,219 @@
+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, extname as pathExtname, resolve as pathResolve } from 'path';
+import { optimize } from 'svgo';
+const DEFAULT_FILENAME = 'icons/icons.svg';
+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,
+                        removeHiddenElems: false
+                    }
+                }
+            }
+        ]
+    }).data;
+};
+const createSpriteSymbol = (filePath, usedIdentifiers, prefix, warnings)=>{
+    const source = readFileSync(filePath, 'utf8');
+    const parsedSvg = parseSvg(source);
+    if (!parsedSvg) {
+        warnings.push(new Error(`Invalid SVG icon: ${filePath}`));
+        return null;
+    }
+    if (!parsedSvg.content) {
+        warnings.push(new Error(`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 Error(`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 Error(`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 LexSvgSpritemap {
+    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
+        };
+    }
+    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 LexSvgSpritemap;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/utils/assets/LexSvgSpritemap.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, extname as pathExtname, resolve as pathResolve} from 'path';\nimport {optimize} from 'svgo';\n\ntype IdentifierPrefix = false | string | ((filePath: string) => string);\n\nexport interface LexSvgSpritemapOptions {\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 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          removeHiddenElems: false\n        }\n      }\n    }]\n  }).data;\n};\n\nconst createSpriteSymbol = (\n  filePath: string,\n  usedIdentifiers: Set<string>,\n  prefix: IdentifierPrefix,\n  warnings: Error[]\n): SpriteSymbol | null => {\n  const source = readFileSync(filePath, 'utf8');\n  const parsedSvg = parseSvg(source);\n\n  if(!parsedSvg) {\n    warnings.push(new Error(`Invalid SVG icon: ${filePath}`));\n    return null;\n  }\n\n  if(!parsedSvg.content) {\n    warnings.push(new Error(`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 Error(`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 Error(`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 LexSvgSpritemap {\n  readonly patterns: string[];\n  readonly options: Required<LexSvgSpritemapOptions>;\n\n  constructor(patterns: string | string[], options: LexSvgSpritemapOptions = {}) {\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: Error[]} {\n    const warnings: Error[] = [];\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}\n\nexport default LexSvgSpritemap;\n"],"names":["readFileSync","sync","globSync","basename","pathBasename","extname","pathExtname","resolve","pathResolve","optimize","DEFAULT_FILENAME","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","removeHiddenElems","data","createSpriteSymbol","usedIdentifiers","warnings","parsedSvg","push","Error","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","LexSvgSpritemap","buildSpritemap","filePaths","options","length","symbols","filter","entry","rootAttributes","xmlns","spriteContent","Array","isArray"],"mappings":"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"}

package/lib/utils/file.d.ts

@@ -4,7 +4,3 @@ export declare const relativeFilePath: (filename: string, dirPath?: string, back
 export declare const relativeNodePath: (packageName: string, dirPath?: string) => string;
 export declare const resolveBinaryPath: (binaryName: string, packageName?: string) => string;
 export declare const findTailwindCssPath: () => string;
-export declare const resolveWebpackPaths: (currentDirname: string) => {
-    webpackPath: string;
-    webpackConfig: string;
-};

package/lib/utils/file.js

@@ -5,45 +5,16 @@
 import { existsSync, readFileSync } from 'fs';
 import { sync as globSync } from 'glob';
 import { resolve as pathResolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import { LexConfig } from '../LexConfig.js';
-export const getDirName = ()=>{
-    try {
-        return eval('new URL(".", import.meta.url).pathname');
-    } catch  {
-        return process.cwd();
-    }
-};
+export const getDirName = ()=>dirname(fileURLToPath(import.meta.url));
 export const getLexPackageJsonPath = ()=>{
     const LEX_PACKAGE_NAME = '@nlabs/lex';
     const lexInNodeModules = pathResolve(process.cwd(), 'node_modules/@nlabs/lex/package.json');
     if (existsSync(lexInNodeModules)) {
         return lexInNodeModules;
     }
-    let startDir;
-    if (process.env.LEX_ROOT) {
-        startDir = process.env.LEX_ROOT;
-    } else {
-        try {
-            startDir = eval('new URL(".", import.meta.url).pathname');
-        } catch  {
-            try {
-                startDir = eval('__filename ? require("path").dirname(__filename) : null');
-                if (!startDir) {
-                    throw new Error('__filename not available');
-                }
-            } catch  {
-                try {
-                    if (process.argv[1] && !process.argv[1].includes('node')) {
-                        startDir = dirname(process.argv[1]);
-                    } else {
-                        throw new Error('process.argv[1] not suitable');
-                    }
-                } catch  {
-                    startDir = process.cwd();
-                }
-            }
-        }
-    }
+    const startDir = process.env.LEX_ROOT || getDirName();
     let dir = startDir;
     for(let i = 0; i < 8; i++){
         const pkgPath = pathResolve(dir, 'package.json');
@@ -158,72 +129,5 @@ export const findTailwindCssPath = ()=>{
     }
     return '';
 };
-export const resolveWebpackPaths = (currentDirname)=>{
-    const possibleWebpackPaths = [
-        pathResolve(process.cwd(), 'node_modules/webpack-cli/bin/cli.js'),
-        pathResolve(process.cwd(), 'node_modules/.bin/webpack'),
-        pathResolve(process.cwd(), 'node_modules/@nlabs/lex', 'node_modules/webpack-cli/bin/cli.js'),
-        pathResolve(process.cwd(), 'node_modules/@nlabs/lex', 'node_modules/.bin/webpack'),
-        pathResolve(currentDirname, 'node_modules/@nlabs/lex/node_modules/webpack-cli/bin/cli.js'),
-        pathResolve(currentDirname, 'node_modules/@nlabs/lex/node_modules/.bin/webpack'),
-        pathResolve(process.env.LEX_HOME || '/node_modules/@nlabs/lex', 'node_modules/webpack-cli/bin/cli.js'),
-        pathResolve(process.env.LEX_HOME || '/node_modules/@nlabs/lex', 'node_modules/.bin/webpack')
-    ];
-    let webpackPath = '';
-    for (const path of possibleWebpackPaths){
-        if (existsSync(path)) {
-            webpackPath = path;
-            break;
-        }
-    }
-    if (!webpackPath) {
-        try {
-            const lexPackagePath = getLexPackageJsonPath();
-            const lexPackageDir = dirname(lexPackagePath);
-            const lexWebpackCli = pathResolve(lexPackageDir, 'node_modules/webpack-cli/bin/cli.js');
-            const lexWebpackBin = pathResolve(lexPackageDir, 'node_modules/.bin/webpack');
-            if (existsSync(lexWebpackCli)) {
-                webpackPath = lexWebpackCli;
-            } else if (existsSync(lexWebpackBin)) {
-                webpackPath = lexWebpackBin;
-            } else {
-                webpackPath = 'npx';
-            }
-        } catch  {
-            webpackPath = 'npx';
-        }
-    }
-    const possibleWebpackConfigPaths = [
-        pathResolve(process.cwd(), 'webpack.config.js'),
-        pathResolve(process.cwd(), 'webpack.config.ts'),
-        pathResolve(process.cwd(), 'node_modules/@nlabs/lex/webpack.config.js'),
-        pathResolve(process.cwd(), 'node_modules/@nlabs/lex/webpack.config.ts'),
-        pathResolve(currentDirname, 'node_modules/@nlabs/lex/webpack.config.js'),
-        pathResolve(currentDirname, 'node_modules/@nlabs/lex/webpack.config.ts'),
-        pathResolve(process.env.LEX_HOME || '/node_modules/@nlabs/lex', 'webpack.config.js'),
-        pathResolve(process.env.LEX_HOME || '/node_modules/@nlabs/lex', 'webpack.config.ts')
-    ];
-    let webpackConfig = '';
-    for (const path of possibleWebpackConfigPaths){
-        if (existsSync(path)) {
-            webpackConfig = path;
-            break;
-        }
-    }
-    if (!webpackConfig) {
-        const lexPackagePath = getLexPackageJsonPath();
-        const lexPackageDir = dirname(lexPackagePath);
-        const lexWebpackConfig = pathResolve(lexPackageDir, 'webpack.config.js');
-        if (existsSync(lexWebpackConfig)) {
-            webpackConfig = lexWebpackConfig;
-        } else {
-            webpackConfig = pathResolve(currentDirname, '../../webpack.config.js');
-        }
-    }
-    return {
-        webpackConfig,
-        webpackPath
-    };
-};
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utils/file.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 findFileUp from 'find-file-up';\nimport {existsSync, readFileSync} from 'fs';\nimport {sync as globSync} from 'glob';\nimport {resolve as pathResolve, dirname} from 'path';\n\nimport {LexConfig} from '../LexConfig.js';\n\nexport const getDirName = (): string => {\n  try {\n    return eval('new URL(\".\", import.meta.url).pathname');\n  } catch{\n    return process.cwd();\n  }\n};\n\nexport const getLexPackageJsonPath = (): string => {\n  const LEX_PACKAGE_NAME = '@nlabs/lex';\n\n  const lexInNodeModules = pathResolve(process.cwd(), 'node_modules/@nlabs/lex/package.json');\n\n  if(existsSync(lexInNodeModules)) {\n    return lexInNodeModules;\n  }\n\n  let startDir: string;\n\n  if(process.env.LEX_ROOT) {\n    startDir = process.env.LEX_ROOT;\n  } else {\n    try {\n      startDir = eval('new URL(\".\", import.meta.url).pathname');\n    } catch{\n      try {\n        startDir = eval('__filename ? require(\"path\").dirname(__filename) : null');\n        if(!startDir) {\n          throw new Error('__filename not available');\n        }\n      } catch{\n        try {\n          if(process.argv[1] && !process.argv[1].includes('node')) {\n            startDir = dirname(process.argv[1]);\n          } else {\n            throw new Error('process.argv[1] not suitable');\n          }\n        } catch{\n          startDir = process.cwd();\n        }\n      }\n    }\n  }\n\n  let dir = startDir;\n  for(let i = 0; i < 8; i++) {\n    const pkgPath = pathResolve(dir, 'package.json');\n    if(existsSync(pkgPath)) {\n      try {\n        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));\n        if(pkg.name === LEX_PACKAGE_NAME) {\n          return pkgPath;\n        }\n      } catch{\n      }\n    }\n    const parent = dirname(dir);\n    if(parent === dir) {\n      break;\n    }\n    dir = parent;\n  }\n\n  return pathResolve(process.cwd(), 'package.json');\n};\n\nexport const relativeFilePath = (filename: string, dirPath: string = './', backUp: number = 0): string => {\n  const nestDepth: number = 10;\n\n  if(backUp) {\n    const filePath: string = findFileUp.sync(filename, dirPath, nestDepth);\n    const previousPath: string = Array(backUp).fill(null).map(() => '../').join('');\n    return pathResolve(filePath, previousPath);\n  }\n\n  return findFileUp.sync(filename, dirPath, nestDepth);\n};\n\nexport const relativeNodePath = (packageName: string, dirPath: string = process.cwd()): string => {\n  const nodePath = pathResolve(dirPath, 'node_modules', packageName);\n  if(existsSync(nodePath)) {\n    return nodePath;\n  }\n\n  // Check parent directories for node_modules\n  let checkDir = dirPath;\n  for(let i = 0; i < 10; i++) {\n    const checkPath = pathResolve(checkDir, 'node_modules', packageName);\n    if(existsSync(checkPath)) {\n      return checkPath;\n    }\n    const parentDir = pathResolve(checkDir, '..');\n    if(parentDir === checkDir) {\n      break;\n    }\n    checkDir = parentDir;\n  }\n\n  return '';\n};\n\nexport const resolveBinaryPath = (binaryName: string, packageName?: string): string => {\n  const lexDir = LexConfig.getLexDir();\n\n  const lexBinPath = pathResolve(lexDir, `node_modules/.bin/${binaryName}`);\n  if(existsSync(lexBinPath)) {\n    return lexBinPath;\n  }\n\n  if(packageName) {\n    const lexPackageBinPath = pathResolve(lexDir, `node_modules/${packageName}/bin/${binaryName}`);\n    if(existsSync(lexPackageBinPath)) {\n      return lexPackageBinPath;\n    }\n\n    const lexPackageBinJsPath = pathResolve(lexDir, `node_modules/${packageName}/bin/${binaryName}.js`);\n    if(existsSync(lexPackageBinJsPath)) {\n      return lexPackageBinJsPath;\n    }\n\n    const lexPackageBinCjsPath = pathResolve(lexDir, `node_modules/${packageName}/bin/${binaryName}.cjs`);\n    if(existsSync(lexPackageBinCjsPath)) {\n      return lexPackageBinCjsPath;\n    }\n  }\n\n  const checkBinUp = (startDir: string) => {\n    let checkDir = startDir;\n    for(let i = 0; i < 5; i++) {\n      const monorepoBinPath = pathResolve(checkDir, `node_modules/.bin/${binaryName}`);\n      if(existsSync(monorepoBinPath)) {\n        return monorepoBinPath;\n      }\n      const parentDir = pathResolve(checkDir, '..');\n      if(parentDir === checkDir) {\n        break;\n      }\n      checkDir = parentDir;\n    }\n    return '';\n  };\n\n  const fromCwd = checkBinUp(process.cwd());\n  if(fromCwd) {\n    return fromCwd;\n  }\n\n  const fromLex = checkBinUp(lexDir);\n  if(fromLex) {\n    return fromLex;\n  }\n\n  return '';\n};\n\nexport const findTailwindCssPath = (): string => {\n  const tailwindPatterns = ['**/tailwind.css'];\n\n  for(const pattern of tailwindPatterns) {\n    const files = globSync(pattern, {\n      cwd: process.cwd(),\n      ignore: ['**/node_modules/**', '**/dist/**', '**/lib/**', '**/build/**', '**/.storybook/**']\n    });\n\n    if(files.length > 0) {\n      return pathResolve(process.cwd(), files[0]);\n    }\n  }\n\n  return '';\n};\n\nexport const resolveWebpackPaths = (currentDirname: string): {webpackPath: string; webpackConfig: string} => {\n  const possibleWebpackPaths = [\n    pathResolve(process.cwd(), 'node_modules/webpack-cli/bin/cli.js'),\n    pathResolve(process.cwd(), 'node_modules/.bin/webpack'),\n    pathResolve(process.cwd(), 'node_modules/@nlabs/lex', 'node_modules/webpack-cli/bin/cli.js'),\n    pathResolve(process.cwd(), 'node_modules/@nlabs/lex', 'node_modules/.bin/webpack'),\n    pathResolve(currentDirname, 'node_modules/@nlabs/lex/node_modules/webpack-cli/bin/cli.js'),\n    pathResolve(currentDirname, 'node_modules/@nlabs/lex/node_modules/.bin/webpack'),\n    pathResolve(process.env.LEX_HOME || '/node_modules/@nlabs/lex', 'node_modules/webpack-cli/bin/cli.js'),\n    pathResolve(process.env.LEX_HOME || '/node_modules/@nlabs/lex', 'node_modules/.bin/webpack')\n  ];\n\n  let webpackPath = '';\n\n  for(const path of possibleWebpackPaths) {\n    if(existsSync(path)) {\n      webpackPath = path;\n      break;\n    }\n  }\n\n  if(!webpackPath) {\n    try {\n      const lexPackagePath = getLexPackageJsonPath();\n      const lexPackageDir = dirname(lexPackagePath);\n      const lexWebpackCli = pathResolve(lexPackageDir, 'node_modules/webpack-cli/bin/cli.js');\n      const lexWebpackBin = pathResolve(lexPackageDir, 'node_modules/.bin/webpack');\n\n      if(existsSync(lexWebpackCli)) {\n        webpackPath = lexWebpackCli;\n      } else if(existsSync(lexWebpackBin)) {\n        webpackPath = lexWebpackBin;\n      } else {\n        webpackPath = 'npx';\n      }\n    } catch{\n      webpackPath = 'npx';\n    }\n  }\n\n  const possibleWebpackConfigPaths = [\n    pathResolve(process.cwd(), 'webpack.config.js'),\n    pathResolve(process.cwd(), 'webpack.config.ts'),\n    pathResolve(process.cwd(), 'node_modules/@nlabs/lex/webpack.config.js'),\n    pathResolve(process.cwd(), 'node_modules/@nlabs/lex/webpack.config.ts'),\n    pathResolve(currentDirname, 'node_modules/@nlabs/lex/webpack.config.js'),\n    pathResolve(currentDirname, 'node_modules/@nlabs/lex/webpack.config.ts'),\n    pathResolve(process.env.LEX_HOME || '/node_modules/@nlabs/lex', 'webpack.config.js'),\n    pathResolve(process.env.LEX_HOME || '/node_modules/@nlabs/lex', 'webpack.config.ts')\n  ];\n\n  let webpackConfig = '';\n\n  for(const path of possibleWebpackConfigPaths) {\n    if(existsSync(path)) {\n      webpackConfig = path;\n      break;\n    }\n  }\n\n  if(!webpackConfig) {\n    const lexPackagePath = getLexPackageJsonPath();\n    const lexPackageDir = dirname(lexPackagePath);\n    const lexWebpackConfig = pathResolve(lexPackageDir, 'webpack.config.js');\n\n    if(existsSync(lexWebpackConfig)) {\n      webpackConfig = lexWebpackConfig;\n    } else {\n      webpackConfig = pathResolve(currentDirname, '../../webpack.config.js');\n    }\n  }\n\n  return {webpackConfig, webpackPath};\n};"],"names":["findFileUp","existsSync","readFileSync","sync","globSync","resolve","pathResolve","dirname","LexConfig","getDirName","eval","process","cwd","getLexPackageJsonPath","LEX_PACKAGE_NAME","lexInNodeModules","startDir","env","LEX_ROOT","Error","argv","includes","dir","i","pkgPath","pkg","JSON","parse","name","parent","relativeFilePath","filename","dirPath","backUp","nestDepth","filePath","previousPath","Array","fill","map","join","relativeNodePath","packageName","nodePath","checkDir","checkPath","parentDir","resolveBinaryPath","binaryName","lexDir","getLexDir","lexBinPath","lexPackageBinPath","lexPackageBinJsPath","lexPackageBinCjsPath","checkBinUp","monorepoBinPath","fromCwd","fromLex","findTailwindCssPath","tailwindPatterns","pattern","files","ignore","length","resolveWebpackPaths","currentDirname","possibleWebpackPaths","LEX_HOME","webpackPath","path","lexPackagePath","lexPackageDir","lexWebpackCli","lexWebpackBin","possibleWebpackConfigPaths","webpackConfig","lexWebpackConfig"],"mappings":"AAAA;;;CAGC,GACD,OAAOA,gBAAgB,eAAe;AACtC,SAAQC,UAAU,EAAEC,YAAY,QAAO,KAAK;AAC5C,SAAQC,QAAQC,QAAQ,QAAO,OAAO;AACtC,SAAQC,WAAWC,WAAW,EAAEC,OAAO,QAAO,OAAO;AAErD,SAAQC,SAAS,QAAO,kBAAkB;AAE1C,OAAO,MAAMC,aAAa;IACxB,IAAI;QACF,OAAOC,KAAK;IACd,EAAE,OAAK;QACL,OAAOC,QAAQC,GAAG;IACpB;AACF,EAAE;AAEF,OAAO,MAAMC,wBAAwB;IACnC,MAAMC,mBAAmB;IAEzB,MAAMC,mBAAmBT,YAAYK,QAAQC,GAAG,IAAI;IAEpD,IAAGX,WAAWc,mBAAmB;QAC/B,OAAOA;IACT;IAEA,IAAIC;IAEJ,IAAGL,QAAQM,GAAG,CAACC,QAAQ,EAAE;QACvBF,WAAWL,QAAQM,GAAG,CAACC,QAAQ;IACjC,OAAO;QACL,IAAI;YACFF,WAAWN,KAAK;QAClB,EAAE,OAAK;YACL,IAAI;gBACFM,WAAWN,KAAK;gBAChB,IAAG,CAACM,UAAU;oBACZ,MAAM,IAAIG,MAAM;gBAClB;YACF,EAAE,OAAK;gBACL,IAAI;oBACF,IAAGR,QAAQS,IAAI,CAAC,EAAE,IAAI,CAACT,QAAQS,IAAI,CAAC,EAAE,CAACC,QAAQ,CAAC,SAAS;wBACvDL,WAAWT,QAAQI,QAAQS,IAAI,CAAC,EAAE;oBACpC,OAAO;wBACL,MAAM,IAAID,MAAM;oBAClB;gBACF,EAAE,OAAK;oBACLH,WAAWL,QAAQC,GAAG;gBACxB;YACF;QACF;IACF;IAEA,IAAIU,MAAMN;IACV,IAAI,IAAIO,IAAI,GAAGA,IAAI,GAAGA,IAAK;QACzB,MAAMC,UAAUlB,YAAYgB,KAAK;QACjC,IAAGrB,WAAWuB,UAAU;YACtB,IAAI;gBACF,MAAMC,MAAMC,KAAKC,KAAK,CAACzB,aAAasB,SAAS;gBAC7C,IAAGC,IAAIG,IAAI,KAAKd,kBAAkB;oBAChC,OAAOU;gBACT;YACF,EAAE,OAAK,CACP;QACF;QACA,MAAMK,SAAStB,QAAQe;QACvB,IAAGO,WAAWP,KAAK;YACjB;QACF;QACAA,MAAMO;IACR;IAEA,OAAOvB,YAAYK,QAAQC,GAAG,IAAI;AACpC,EAAE;AAEF,OAAO,MAAMkB,mBAAmB,CAACC,UAAkBC,UAAkB,IAAI,EAAEC,SAAiB,CAAC;IAC3F,MAAMC,YAAoB;IAE1B,IAAGD,QAAQ;QACT,MAAME,WAAmBnC,WAAWG,IAAI,CAAC4B,UAAUC,SAASE;QAC5D,MAAME,eAAuBC,MAAMJ,QAAQK,IAAI,CAAC,MAAMC,GAAG,CAAC,IAAM,OAAOC,IAAI,CAAC;QAC5E,OAAOlC,YAAY6B,UAAUC;IAC/B;IAEA,OAAOpC,WAAWG,IAAI,CAAC4B,UAAUC,SAASE;AAC5C,EAAE;AAEF,OAAO,MAAMO,mBAAmB,CAACC,aAAqBV,UAAkBrB,QAAQC,GAAG,EAAE;IACnF,MAAM+B,WAAWrC,YAAY0B,SAAS,gBAAgBU;IACtD,IAAGzC,WAAW0C,WAAW;QACvB,OAAOA;IACT;IAEA,4CAA4C;IAC5C,IAAIC,WAAWZ;IACf,IAAI,IAAIT,IAAI,GAAGA,IAAI,IAAIA,IAAK;QAC1B,MAAMsB,YAAYvC,YAAYsC,UAAU,gBAAgBF;QACxD,IAAGzC,WAAW4C,YAAY;YACxB,OAAOA;QACT;QACA,MAAMC,YAAYxC,YAAYsC,UAAU;QACxC,IAAGE,cAAcF,UAAU;YACzB;QACF;QACAA,WAAWE;IACb;IAEA,OAAO;AACT,EAAE;AAEF,OAAO,MAAMC,oBAAoB,CAACC,YAAoBN;IACpD,MAAMO,SAASzC,UAAU0C,SAAS;IAElC,MAAMC,aAAa7C,YAAY2C,QAAQ,CAAC,kBAAkB,EAAED,YAAY;IACxE,IAAG/C,WAAWkD,aAAa;QACzB,OAAOA;IACT;IAEA,IAAGT,aAAa;QACd,MAAMU,oBAAoB9C,YAAY2C,QAAQ,CAAC,aAAa,EAAEP,YAAY,KAAK,EAAEM,YAAY;QAC7F,IAAG/C,WAAWmD,oBAAoB;YAChC,OAAOA;QACT;QAEA,MAAMC,sBAAsB/C,YAAY2C,QAAQ,CAAC,aAAa,EAAEP,YAAY,KAAK,EAAEM,WAAW,GAAG,CAAC;QAClG,IAAG/C,WAAWoD,sBAAsB;YAClC,OAAOA;QACT;QAEA,MAAMC,uBAAuBhD,YAAY2C,QAAQ,CAAC,aAAa,EAAEP,YAAY,KAAK,EAAEM,WAAW,IAAI,CAAC;QACpG,IAAG/C,WAAWqD,uBAAuB;YACnC,OAAOA;QACT;IACF;IAEA,MAAMC,aAAa,CAACvC;QAClB,IAAI4B,WAAW5B;QACf,IAAI,IAAIO,IAAI,GAAGA,IAAI,GAAGA,IAAK;YACzB,MAAMiC,kBAAkBlD,YAAYsC,UAAU,CAAC,kBAAkB,EAAEI,YAAY;YAC/E,IAAG/C,WAAWuD,kBAAkB;gBAC9B,OAAOA;YACT;YACA,MAAMV,YAAYxC,YAAYsC,UAAU;YACxC,IAAGE,cAAcF,UAAU;gBACzB;YACF;YACAA,WAAWE;QACb;QACA,OAAO;IACT;IAEA,MAAMW,UAAUF,WAAW5C,QAAQC,GAAG;IACtC,IAAG6C,SAAS;QACV,OAAOA;IACT;IAEA,MAAMC,UAAUH,WAAWN;IAC3B,IAAGS,SAAS;QACV,OAAOA;IACT;IAEA,OAAO;AACT,EAAE;AAEF,OAAO,MAAMC,sBAAsB;IACjC,MAAMC,mBAAmB;QAAC;KAAkB;IAE5C,KAAI,MAAMC,WAAWD,iBAAkB;QACrC,MAAME,QAAQ1D,SAASyD,SAAS;YAC9BjD,KAAKD,QAAQC,GAAG;YAChBmD,QAAQ;gBAAC;gBAAsB;gBAAc;gBAAa;gBAAe;aAAmB;QAC9F;QAEA,IAAGD,MAAME,MAAM,GAAG,GAAG;YACnB,OAAO1D,YAAYK,QAAQC,GAAG,IAAIkD,KAAK,CAAC,EAAE;QAC5C;IACF;IAEA,OAAO;AACT,EAAE;AAEF,OAAO,MAAMG,sBAAsB,CAACC;IAClC,MAAMC,uBAAuB;QAC3B7D,YAAYK,QAAQC,GAAG,IAAI;QAC3BN,YAAYK,QAAQC,GAAG,IAAI;QAC3BN,YAAYK,QAAQC,GAAG,IAAI,2BAA2B;QACtDN,YAAYK,QAAQC,GAAG,IAAI,2BAA2B;QACtDN,YAAY4D,gBAAgB;QAC5B5D,YAAY4D,gBAAgB;QAC5B5D,YAAYK,QAAQM,GAAG,CAACmD,QAAQ,IAAI,4BAA4B;QAChE9D,YAAYK,QAAQM,GAAG,CAACmD,QAAQ,IAAI,4BAA4B;KACjE;IAED,IAAIC,cAAc;IAElB,KAAI,MAAMC,QAAQH,qBAAsB;QACtC,IAAGlE,WAAWqE,OAAO;YACnBD,cAAcC;YACd;QACF;IACF;IAEA,IAAG,CAACD,aAAa;QACf,IAAI;YACF,MAAME,iBAAiB1D;YACvB,MAAM2D,gBAAgBjE,QAAQgE;YAC9B,MAAME,gBAAgBnE,YAAYkE,eAAe;YACjD,MAAME,gBAAgBpE,YAAYkE,eAAe;YAEjD,IAAGvE,WAAWwE,gBAAgB;gBAC5BJ,cAAcI;YAChB,OAAO,IAAGxE,WAAWyE,gBAAgB;gBACnCL,cAAcK;YAChB,OAAO;gBACLL,cAAc;YAChB;QACF,EAAE,OAAK;YACLA,cAAc;QAChB;IACF;IAEA,MAAMM,6BAA6B;QACjCrE,YAAYK,QAAQC,GAAG,IAAI;QAC3BN,YAAYK,QAAQC,GAAG,IAAI;QAC3BN,YAAYK,QAAQC,GAAG,IAAI;QAC3BN,YAAYK,QAAQC,GAAG,IAAI;QAC3BN,YAAY4D,gBAAgB;QAC5B5D,YAAY4D,gBAAgB;QAC5B5D,YAAYK,QAAQM,GAAG,CAACmD,QAAQ,IAAI,4BAA4B;QAChE9D,YAAYK,QAAQM,GAAG,CAACmD,QAAQ,IAAI,4BAA4B;KACjE;IAED,IAAIQ,gBAAgB;IAEpB,KAAI,MAAMN,QAAQK,2BAA4B;QAC5C,IAAG1E,WAAWqE,OAAO;YACnBM,gBAAgBN;YAChB;QACF;IACF;IAEA,IAAG,CAACM,eAAe;QACjB,MAAML,iBAAiB1D;QACvB,MAAM2D,gBAAgBjE,QAAQgE;QAC9B,MAAMM,mBAAmBvE,YAAYkE,eAAe;QAEpD,IAAGvE,WAAW4E,mBAAmB;YAC/BD,gBAAgBC;QAClB,OAAO;YACLD,gBAAgBtE,YAAY4D,gBAAgB;QAC9C;IACF;IAEA,OAAO;QAACU;QAAeP;IAAW;AACpC,EAAE"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utils/file.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 findFileUp from 'find-file-up';\nimport {existsSync, readFileSync} from 'fs';\nimport {sync as globSync} from 'glob';\nimport {resolve as pathResolve, dirname} from 'path';\nimport {fileURLToPath} from 'url';\n\nimport {LexConfig} from '../LexConfig.js';\n\nexport const getDirName = (): string => dirname(fileURLToPath(import.meta.url));\n\nexport const getLexPackageJsonPath = (): string => {\n  const LEX_PACKAGE_NAME = '@nlabs/lex';\n\n  const lexInNodeModules = pathResolve(process.cwd(), 'node_modules/@nlabs/lex/package.json');\n\n  if(existsSync(lexInNodeModules)) {\n    return lexInNodeModules;\n  }\n\n  const startDir = process.env.LEX_ROOT || getDirName();\n\n  let dir = startDir;\n  for(let i = 0; i < 8; i++) {\n    const pkgPath = pathResolve(dir, 'package.json');\n    if(existsSync(pkgPath)) {\n      try {\n        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));\n        if(pkg.name === LEX_PACKAGE_NAME) {\n          return pkgPath;\n        }\n      } catch{\n      }\n    }\n    const parent = dirname(dir);\n    if(parent === dir) {\n      break;\n    }\n    dir = parent;\n  }\n\n  return pathResolve(process.cwd(), 'package.json');\n};\n\nexport const relativeFilePath = (filename: string, dirPath: string = './', backUp: number = 0): string => {\n  const nestDepth: number = 10;\n\n  if(backUp) {\n    const filePath: string = findFileUp.sync(filename, dirPath, nestDepth);\n    const previousPath: string = Array(backUp).fill(null).map(() => '../').join('');\n    return pathResolve(filePath, previousPath);\n  }\n\n  return findFileUp.sync(filename, dirPath, nestDepth);\n};\n\nexport const relativeNodePath = (packageName: string, dirPath: string = process.cwd()): string => {\n  const nodePath = pathResolve(dirPath, 'node_modules', packageName);\n  if(existsSync(nodePath)) {\n    return nodePath;\n  }\n\n  // Check parent directories for node_modules\n  let checkDir = dirPath;\n  for(let i = 0; i < 10; i++) {\n    const checkPath = pathResolve(checkDir, 'node_modules', packageName);\n    if(existsSync(checkPath)) {\n      return checkPath;\n    }\n    const parentDir = pathResolve(checkDir, '..');\n    if(parentDir === checkDir) {\n      break;\n    }\n    checkDir = parentDir;\n  }\n\n  return '';\n};\n\nexport const resolveBinaryPath = (binaryName: string, packageName?: string): string => {\n  const lexDir = LexConfig.getLexDir();\n\n  const lexBinPath = pathResolve(lexDir, `node_modules/.bin/${binaryName}`);\n  if(existsSync(lexBinPath)) {\n    return lexBinPath;\n  }\n\n  if(packageName) {\n    const lexPackageBinPath = pathResolve(lexDir, `node_modules/${packageName}/bin/${binaryName}`);\n    if(existsSync(lexPackageBinPath)) {\n      return lexPackageBinPath;\n    }\n\n    const lexPackageBinJsPath = pathResolve(lexDir, `node_modules/${packageName}/bin/${binaryName}.js`);\n    if(existsSync(lexPackageBinJsPath)) {\n      return lexPackageBinJsPath;\n    }\n\n    const lexPackageBinCjsPath = pathResolve(lexDir, `node_modules/${packageName}/bin/${binaryName}.cjs`);\n    if(existsSync(lexPackageBinCjsPath)) {\n      return lexPackageBinCjsPath;\n    }\n  }\n\n  const checkBinUp = (startDir: string) => {\n    let checkDir = startDir;\n    for(let i = 0; i < 5; i++) {\n      const monorepoBinPath = pathResolve(checkDir, `node_modules/.bin/${binaryName}`);\n      if(existsSync(monorepoBinPath)) {\n        return monorepoBinPath;\n      }\n      const parentDir = pathResolve(checkDir, '..');\n      if(parentDir === checkDir) {\n        break;\n      }\n      checkDir = parentDir;\n    }\n    return '';\n  };\n\n  const fromCwd = checkBinUp(process.cwd());\n  if(fromCwd) {\n    return fromCwd;\n  }\n\n  const fromLex = checkBinUp(lexDir);\n  if(fromLex) {\n    return fromLex;\n  }\n\n  return '';\n};\n\nexport const findTailwindCssPath = (): string => {\n  const tailwindPatterns = ['**/tailwind.css'];\n\n  for(const pattern of tailwindPatterns) {\n    const files = globSync(pattern, {\n      cwd: process.cwd(),\n      ignore: ['**/node_modules/**', '**/dist/**', '**/lib/**', '**/build/**', '**/.storybook/**']\n    });\n\n    if(files.length > 0) {\n      return pathResolve(process.cwd(), files[0]);\n    }\n  }\n\n  return '';\n};\n"],"names":["findFileUp","existsSync","readFileSync","sync","globSync","resolve","pathResolve","dirname","fileURLToPath","LexConfig","getDirName","url","getLexPackageJsonPath","LEX_PACKAGE_NAME","lexInNodeModules","process","cwd","startDir","env","LEX_ROOT","dir","i","pkgPath","pkg","JSON","parse","name","parent","relativeFilePath","filename","dirPath","backUp","nestDepth","filePath","previousPath","Array","fill","map","join","relativeNodePath","packageName","nodePath","checkDir","checkPath","parentDir","resolveBinaryPath","binaryName","lexDir","getLexDir","lexBinPath","lexPackageBinPath","lexPackageBinJsPath","lexPackageBinCjsPath","checkBinUp","monorepoBinPath","fromCwd","fromLex","findTailwindCssPath","tailwindPatterns","pattern","files","ignore","length"],"mappings":"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"}

package/lib/utils/staticSite.d.ts

@@ -0,0 +1,15 @@
+export type StaticRenderOutput = Record<string, string> | string;
+export type StaticRender = ((locals: StaticRenderLocals) => Promise<StaticRenderOutput> | StaticRenderOutput) | ((locals: StaticRenderLocals, callback: (output: StaticRenderOutput) => void) => void);
+export interface StaticRenderLocals {
+    readonly assets: Record<string, string>;
+    readonly path: string;
+}
+export interface StaticSiteOptions {
+    readonly assets?: Record<string, string>;
+    readonly crawl?: boolean;
+    readonly outputPath: string;
+    readonly paths?: string[] | string;
+    readonly render: StaticRender;
+}
+export declare const relativePathsFromHtml: (currentPath: string, source: string) => string[];
+export declare const renderStaticSite: (options: StaticSiteOptions) => Promise<void>;

package/lib/utils/staticSite.js

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { posix as path, resolve } from 'path';
+const attributeValues = (html, element, attribute)=>{
+    const expression = new RegExp(`<${element}\\b[^>]*\\b${attribute}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s>]+))`, 'gi');
+    const values = [];
+    let match = expression.exec(html);
+    while(match){
+        values.push(match[1] ?? match[2] ?? match[3]);
+        match = expression.exec(html);
+    }
+    return values;
+};
+export const relativePathsFromHtml = (currentPath, source)=>[
+        ...attributeValues(source, 'a', 'href'),
+        ...attributeValues(source, 'iframe', 'src')
+    ].filter((reference)=>reference.length > 0 && !reference.startsWith('#') && !reference.startsWith('//') && !/^[a-z][a-z\d+.-]*:/i.test(reference)).map((reference)=>{
+        const resolved = new URL(reference, new URL(currentPath, 'https://lex.local'));
+        return `${resolved.pathname}${resolved.search}`;
+    });
+const pathToAssetName = (outputPath)=>{
+    let outputFileName = outputPath.replace(/^(\/|\\)/, '');
+    if (!/\.(html?)$/i.test(outputFileName)) {
+        outputFileName = path.join(outputFileName, 'index.html');
+    }
+    return outputFileName;
+};
+const invokeRender = async (render, locals)=>{
+    if (render.length < 2) {
+        return Promise.resolve(render(locals));
+    }
+    return new Promise((resolveOutput)=>{
+        render(locals, resolveOutput);
+    });
+};
+export const renderStaticSite = async (options)=>{
+    const { assets = {}, crawl = true, outputPath, paths = [
+        '/'
+    ], render } = options;
+    const pending = Array.isArray(paths) ? [
+        ...paths
+    ] : [
+        paths
+    ];
+    const renderedPaths = new Set();
+    while(pending.length > 0){
+        const currentPath = pending.shift();
+        if (!currentPath || renderedPaths.has(currentPath)) {
+            continue;
+        }
+        renderedPaths.add(currentPath);
+        const locals = {
+            assets,
+            path: currentPath
+        };
+        // Rendering is sequential because each page can enqueue newly discovered routes.
+        // eslint-disable-next-line no-await-in-loop
+        const output = await invokeRender(render, locals);
+        const outputByPath = typeof output === 'object' ? output : {
+            [currentPath]: output
+        };
+        for (const [renderedPath, html] of Object.entries(outputByPath)){
+            const assetName = pathToAssetName(renderedPath);
+            const filePath = resolve(outputPath, assetName);
+            if (!existsSync(filePath)) {
+                mkdirSync(resolve(filePath, '..'), {
+                    recursive: true
+                });
+                writeFileSync(filePath, html);
+            }
+            if (crawl) {
+                pending.push(...relativePathsFromHtml(renderedPath, html));
+            }
+        }
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utils/staticSite.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 {existsSync, mkdirSync, writeFileSync} from 'fs';\nimport {posix as path, resolve} from 'path';\n\nexport type StaticRenderOutput = Record<string, string> | string;\nexport type StaticRender = ((locals: StaticRenderLocals) => Promise<StaticRenderOutput> | StaticRenderOutput) |\n  ((locals: StaticRenderLocals, callback: (output: StaticRenderOutput) => void) => void);\n\nexport interface StaticRenderLocals {\n  readonly assets: Record<string, string>;\n  readonly path: string;\n}\n\nexport interface StaticSiteOptions {\n  readonly assets?: Record<string, string>;\n  readonly crawl?: boolean;\n  readonly outputPath: string;\n  readonly paths?: string[] | string;\n  readonly render: StaticRender;\n}\n\nconst attributeValues = (html: string, element: string, attribute: string): string[] => {\n  const expression = new RegExp(`<${element}\\\\b[^>]*\\\\b${attribute}\\\\s*=\\\\s*(?:\"([^\"]*)\"|'([^']*)'|([^\\\\s>]+))`, 'gi');\n  const values: string[] = [];\n  let match = expression.exec(html);\n\n  while(match) {\n    values.push(match[1] ?? match[2] ?? match[3]);\n    match = expression.exec(html);\n  }\n\n  return values;\n};\n\nexport const relativePathsFromHtml = (currentPath: string, source: string): string[] => [\n  ...attributeValues(source, 'a', 'href'),\n  ...attributeValues(source, 'iframe', 'src')\n]\n  .filter((reference) => reference.length > 0 && !reference.startsWith('#') && !reference.startsWith('//') && !/^[a-z][a-z\\d+.-]*:/i.test(reference))\n  .map((reference) => {\n    const resolved = new URL(reference, new URL(currentPath, 'https://lex.local'));\n    return `${resolved.pathname}${resolved.search}`;\n  });\n\nconst pathToAssetName = (outputPath: string): string => {\n  let outputFileName = outputPath.replace(/^(\\/|\\\\)/, '');\n  if(!/\\.(html?)$/i.test(outputFileName)) {\n    outputFileName = path.join(outputFileName, 'index.html');\n  }\n  return outputFileName;\n};\n\nconst invokeRender = async (render: StaticRender, locals: StaticRenderLocals): Promise<StaticRenderOutput> => {\n  if(render.length < 2) {\n    return Promise.resolve((render as (\n      renderLocals: StaticRenderLocals\n    ) => Promise<StaticRenderOutput> | StaticRenderOutput)(locals));\n  }\n\n  return new Promise<StaticRenderOutput>((resolveOutput) => {\n    (render as (\n      renderLocals: StaticRenderLocals,\n      callback: (value: StaticRenderOutput) => void\n    ) => void)(locals, resolveOutput);\n  });\n};\n\nexport const renderStaticSite = async (options: StaticSiteOptions): Promise<void> => {\n  const {assets = {}, crawl = true, outputPath, paths = ['/'], render} = options;\n  const pending = Array.isArray(paths) ? [...paths] : [paths];\n  const renderedPaths = new Set<string>();\n\n  while(pending.length > 0) {\n    const currentPath = pending.shift();\n    if(!currentPath || renderedPaths.has(currentPath)) {\n      continue;\n    }\n    renderedPaths.add(currentPath);\n\n    const locals = {assets, path: currentPath};\n    // Rendering is sequential because each page can enqueue newly discovered routes.\n    // eslint-disable-next-line no-await-in-loop\n    const output = await invokeRender(render, locals);\n    const outputByPath = typeof output === 'object' ? output : {[currentPath]: output};\n\n    for(const [renderedPath, html] of Object.entries(outputByPath)) {\n      const assetName = pathToAssetName(renderedPath);\n      const filePath = resolve(outputPath, assetName);\n      if(!existsSync(filePath)) {\n        mkdirSync(resolve(filePath, '..'), {recursive: true});\n        writeFileSync(filePath, html);\n      }\n\n      if(crawl) {\n        pending.push(...relativePathsFromHtml(renderedPath, html));\n      }\n    }\n  }\n};\n"],"names":["existsSync","mkdirSync","writeFileSync","posix","path","resolve","attributeValues","html","element","attribute","expression","RegExp","values","match","exec","push","relativePathsFromHtml","currentPath","source","filter","reference","length","startsWith","test","map","resolved","URL","pathname","search","pathToAssetName","outputPath","outputFileName","replace","join","invokeRender","render","locals","Promise","resolveOutput","renderStaticSite","options","assets","crawl","paths","pending","Array","isArray","renderedPaths","Set","shift","has","add","output","outputByPath","renderedPath","Object","entries","assetName","filePath","recursive"],"mappings":"AAAA;;;CAGC,GACD,SAAQA,UAAU,EAAEC,SAAS,EAAEC,aAAa,QAAO,KAAK;AACxD,SAAQC,SAASC,IAAI,EAAEC,OAAO,QAAO,OAAO;AAmB5C,MAAMC,kBAAkB,CAACC,MAAcC,SAAiBC;IACtD,MAAMC,aAAa,IAAIC,OAAO,CAAC,CAAC,EAAEH,QAAQ,WAAW,EAAEC,UAAU,2CAA2C,CAAC,EAAE;IAC/G,MAAMG,SAAmB,EAAE;IAC3B,IAAIC,QAAQH,WAAWI,IAAI,CAACP;IAE5B,MAAMM,MAAO;QACXD,OAAOG,IAAI,CAACF,KAAK,CAAC,EAAE,IAAIA,KAAK,CAAC,EAAE,IAAIA,KAAK,CAAC,EAAE;QAC5CA,QAAQH,WAAWI,IAAI,CAACP;IAC1B;IAEA,OAAOK;AACT;AAEA,OAAO,MAAMI,wBAAwB,CAACC,aAAqBC,SAA6B;WACnFZ,gBAAgBY,QAAQ,KAAK;WAC7BZ,gBAAgBY,QAAQ,UAAU;KACtC,CACEC,MAAM,CAAC,CAACC,YAAcA,UAAUC,MAAM,GAAG,KAAK,CAACD,UAAUE,UAAU,CAAC,QAAQ,CAACF,UAAUE,UAAU,CAAC,SAAS,CAAC,sBAAsBC,IAAI,CAACH,YACvII,GAAG,CAAC,CAACJ;QACJ,MAAMK,WAAW,IAAIC,IAAIN,WAAW,IAAIM,IAAIT,aAAa;QACzD,OAAO,GAAGQ,SAASE,QAAQ,GAAGF,SAASG,MAAM,EAAE;IACjD,GAAG;AAEL,MAAMC,kBAAkB,CAACC;IACvB,IAAIC,iBAAiBD,WAAWE,OAAO,CAAC,YAAY;IACpD,IAAG,CAAC,cAAcT,IAAI,CAACQ,iBAAiB;QACtCA,iBAAiB3B,KAAK6B,IAAI,CAACF,gBAAgB;IAC7C;IACA,OAAOA;AACT;AAEA,MAAMG,eAAe,OAAOC,QAAsBC;IAChD,IAAGD,OAAOd,MAAM,GAAG,GAAG;QACpB,OAAOgB,QAAQhC,OAAO,CAAC,AAAC8B,OAE+BC;IACzD;IAEA,OAAO,IAAIC,QAA4B,CAACC;QACrCH,OAGUC,QAAQE;IACrB;AACF;AAEA,OAAO,MAAMC,mBAAmB,OAAOC;IACrC,MAAM,EAACC,SAAS,CAAC,CAAC,EAAEC,QAAQ,IAAI,EAAEZ,UAAU,EAAEa,QAAQ;QAAC;KAAI,EAAER,MAAM,EAAC,GAAGK;IACvE,MAAMI,UAAUC,MAAMC,OAAO,CAACH,SAAS;WAAIA;KAAM,GAAG;QAACA;KAAM;IAC3D,MAAMI,gBAAgB,IAAIC;IAE1B,MAAMJ,QAAQvB,MAAM,GAAG,EAAG;QACxB,MAAMJ,cAAc2B,QAAQK,KAAK;QACjC,IAAG,CAAChC,eAAe8B,cAAcG,GAAG,CAACjC,cAAc;YACjD;QACF;QACA8B,cAAcI,GAAG,CAAClC;QAElB,MAAMmB,SAAS;YAACK;YAAQrC,MAAMa;QAAW;QACzC,iFAAiF;QACjF,4CAA4C;QAC5C,MAAMmC,SAAS,MAAMlB,aAAaC,QAAQC;QAC1C,MAAMiB,eAAe,OAAOD,WAAW,WAAWA,SAAS;YAAC,CAACnC,YAAY,EAAEmC;QAAM;QAEjF,KAAI,MAAM,CAACE,cAAc/C,KAAK,IAAIgD,OAAOC,OAAO,CAACH,cAAe;YAC9D,MAAMI,YAAY5B,gBAAgByB;YAClC,MAAMI,WAAWrD,QAAQyB,YAAY2B;YACrC,IAAG,CAACzD,WAAW0D,WAAW;gBACxBzD,UAAUI,QAAQqD,UAAU,OAAO;oBAACC,WAAW;gBAAI;gBACnDzD,cAAcwD,UAAUnD;YAC1B;YAEA,IAAGmC,OAAO;gBACRE,QAAQ7B,IAAI,IAAIC,sBAAsBsC,cAAc/C;YACtD;QACF;IACF;AACF,EAAE"}

package/lib/utils/vite/assets.d.ts

@@ -0,0 +1,19 @@
+import type { LexConfigType } from '../../LexConfig.js';
+interface GeneratedFavicons {
+    readonly files: ReadonlyArray<{
+        contents: string;
+        name: string;
+    }>;
+    readonly html: string[];
+    readonly images: ReadonlyArray<{
+        contents: Buffer;
+        name: string;
+    }>;
+}
+export declare const generateLexFavicons: (config: LexConfigType) => Promise<GeneratedFavicons | null>;
+export declare const copyLexWebAssets: (config: LexConfigType) => Promise<void>;
+export declare const optimizeLexWebAssets: (config: LexConfigType) => Promise<void>;
+export declare const compressLexWebAssets: (config: LexConfigType) => void;
+export declare const getDevAsset: (config: LexConfigType, requestPath: string) => Promise<Buffer | null>;
+export declare const getAssetRelativePath: (config: LexConfigType, filePath: string) => string;
+export {};