@nlabs/lex 1.59.5 → 2.0.1

package/lib/utils/vite/assets.js

@@ -0,0 +1,249 @@
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { gzipSync } from 'zlib';
+import favicons from 'favicons';
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'fs';
+import { sync as globSync } from 'glob';
+import { extname, join, relative, resolve } from 'path';
+import sharp from 'sharp';
+import { optimize } from 'svgo';
+import { LexSvgSpritemap } from '../assets/LexSvgSpritemap.js';
+const COMPRESSIBLE_FILE = /\.(css|html|js|json|svg|txt|xml)$/i;
+const IMAGE_FILE = /\.(gif|jpe?g|png|svg|webp)$/i;
+const MINIMUM_GZIP_SIZE = 8192;
+const faviconCache = new Map();
+const copyDirectory = (source, destination, exclude)=>{
+    if (!existsSync(source)) return;
+    for (const entry of readdirSync(source, {
+        withFileTypes: true
+    })){
+        const sourcePath = join(source, entry.name);
+        const destinationPath = join(destination, entry.name);
+        if (exclude?.test(sourcePath)) continue;
+        if (entry.isDirectory()) {
+            copyDirectory(sourcePath, destinationPath, exclude);
+        } else {
+            mkdirSync(resolve(destinationPath, '..'), {
+                recursive: true
+            });
+            writeFileSync(destinationPath, readFileSync(sourcePath));
+        }
+    }
+};
+const getAssetDirectories = (config)=>{
+    const sourcePath = config.sourceFullPath || resolve(process.cwd(), config.sourcePath || './src');
+    const staticPath = config.vite?.staticPath || './src/static';
+    return [
+        {
+            destination: '',
+            source: resolve(process.cwd(), staticPath)
+        },
+        {
+            destination: 'images',
+            source: resolve(sourcePath, 'images')
+        },
+        {
+            destination: 'fonts',
+            source: resolve(sourcePath, 'fonts')
+        },
+        {
+            destination: 'docs',
+            source: resolve(sourcePath, 'docs')
+        },
+        {
+            destination: 'icons',
+            exclude: /\.svg$/i,
+            source: resolve(sourcePath, 'icons')
+        }
+    ];
+};
+export const generateLexFavicons = async (config)=>{
+    const sourcePath = config.sourceFullPath || resolve(process.cwd(), config.sourcePath || './src');
+    const logoPath = resolve(sourcePath, 'images/logo.png');
+    if (!existsSync(logoPath)) return null;
+    const modifiedAt = statSync(logoPath).mtimeMs;
+    const cached = faviconCache.get(logoPath);
+    if (cached?.modifiedAt === modifiedAt) return cached.response;
+    const generated = await favicons(logoPath, {
+        icons: {
+            android: true,
+            appleIcon: true,
+            appleStartup: false,
+            favicons: true,
+            windows: false,
+            yandex: false
+        },
+        path: '/'
+    });
+    const [openGraphImage, twitterImage] = await Promise.all([
+        sharp(logoPath).resize(1200, 630, {
+            fit: 'contain'
+        }).png().toBuffer(),
+        sharp(logoPath).resize(1200, 675, {
+            fit: 'contain'
+        }).png().toBuffer()
+    ]);
+    const response = {
+        ...generated,
+        html: [
+            ...generated.html,
+            '<meta property="og:image" content="/open-graph.png">',
+            '<meta name="twitter:image" content="/twitter.png">'
+        ],
+        images: [
+            ...generated.images,
+            {
+                contents: openGraphImage,
+                name: 'open-graph.png'
+            },
+            {
+                contents: twitterImage,
+                name: 'twitter.png'
+            }
+        ]
+    };
+    faviconCache.set(logoPath, {
+        modifiedAt,
+        response
+    });
+    return response;
+};
+export const copyLexWebAssets = async (config)=>{
+    const outputPath = config.outputFullPath || resolve(process.cwd(), config.outputPath || './lib');
+    for (const assetDirectory of getAssetDirectories(config)){
+        copyDirectory(assetDirectory.source, resolve(outputPath, assetDirectory.destination), assetDirectory.exclude);
+    }
+    const sourcePath = config.sourceFullPath || resolve(process.cwd(), config.sourcePath || './src');
+    const spritemap = new LexSvgSpritemap(resolve(sourcePath, 'icons/**/*.svg'), {
+        filename: 'icons/icons.svg',
+        prefix: false
+    }).buildSpritemap();
+    for (const warning of spritemap.warnings)console.warn(warning.message);
+    if (spritemap.content) {
+        const spritePath = resolve(outputPath, 'icons/icons.svg');
+        mkdirSync(resolve(spritePath, '..'), {
+            recursive: true
+        });
+        writeFileSync(spritePath, spritemap.content);
+    }
+    const generatedFavicons = await generateLexFavicons(config);
+    if (generatedFavicons) {
+        for (const image of generatedFavicons.images){
+            const imagePath = resolve(outputPath, image.name);
+            mkdirSync(resolve(imagePath, '..'), {
+                recursive: true
+            });
+            writeFileSync(imagePath, image.contents);
+        }
+        for (const file of generatedFavicons.files){
+            const filePath = resolve(outputPath, file.name);
+            mkdirSync(resolve(filePath, '..'), {
+                recursive: true
+            });
+            writeFileSync(filePath, file.contents);
+        }
+        const indexPath = resolve(outputPath, 'index.html');
+        if (existsSync(indexPath)) {
+            const html = readFileSync(indexPath, 'utf8');
+            const faviconHtml = generatedFavicons.html.join('\n    ');
+            writeFileSync(indexPath, html.replace('</head>', `    ${faviconHtml}\n  </head>`));
+        }
+    }
+};
+const optimizeImage = async (filePath)=>{
+    const extension = extname(filePath).toLowerCase();
+    const source = readFileSync(filePath);
+    if (extension === '.svg') {
+        const isSpritemap = filePath.endsWith('/icons/icons.svg');
+        const result = optimize(source.toString(), {
+            multipass: true,
+            path: filePath,
+            plugins: isSpritemap ? [
+                {
+                    name: 'preset-default',
+                    params: {
+                        overrides: {
+                            cleanupIds: false,
+                            removeHiddenElems: false
+                        }
+                    }
+                }
+            ] : [
+                'preset-default'
+            ]
+        });
+        writeFileSync(filePath, result.data);
+        return;
+    }
+    let image = sharp(source);
+    if (extension === '.jpg' || extension === '.jpeg') image = image.jpeg({
+        progressive: true,
+        quality: 65
+    });
+    if (extension === '.png') image = image.png({
+        quality: 90
+    });
+    if (extension === '.webp') image = image.webp({
+        quality: 75
+    });
+    if (extension === '.gif') image = image.gif();
+    const optimized = await image.toBuffer();
+    if (optimized.length < source.length) writeFileSync(filePath, optimized);
+};
+export const optimizeLexWebAssets = async (config)=>{
+    const outputPath = config.outputFullPath || resolve(process.cwd(), config.outputPath || './lib');
+    if (!existsSync(outputPath)) return;
+    const imageFiles = globSync('**/*.{gif,jpg,jpeg,png,svg,webp}', {
+        absolute: true,
+        cwd: outputPath,
+        nodir: true
+    });
+    await Promise.all(imageFiles.filter((filePath)=>IMAGE_FILE.test(filePath)).map(optimizeImage));
+};
+export const compressLexWebAssets = (config)=>{
+    const outputPath = config.outputFullPath || resolve(process.cwd(), config.outputPath || './lib');
+    if (!existsSync(outputPath)) return;
+    const files = globSync('**/*', {
+        absolute: true,
+        cwd: outputPath,
+        nodir: true
+    });
+    for (const filePath of files){
+        if (!COMPRESSIBLE_FILE.test(filePath) || statSync(filePath).size < MINIMUM_GZIP_SIZE) continue;
+        writeFileSync(`${filePath}.gz`, gzipSync(readFileSync(filePath)));
+    }
+};
+export const getDevAsset = async (config, requestPath)=>{
+    const normalizedPath = requestPath.split('?')[0].replace(/^\/+/, '');
+    if (normalizedPath.includes('..')) return null;
+    if (normalizedPath === 'icons/icons.svg') {
+        const sourcePath = config.sourceFullPath || resolve(process.cwd(), config.sourcePath || './src');
+        const spritemap = new LexSvgSpritemap(resolve(sourcePath, 'icons/**/*.svg'), {
+            prefix: false
+        }).buildSpritemap();
+        return spritemap.content ? Buffer.from(spritemap.content) : null;
+    }
+    const generatedFavicons = await generateLexFavicons(config);
+    const generatedImage = generatedFavicons?.images.find(({ name })=>name === normalizedPath);
+    if (generatedImage) return generatedImage.contents;
+    const generatedFile = generatedFavicons?.files.find(({ name })=>name === normalizedPath);
+    if (generatedFile) return Buffer.from(generatedFile.contents);
+    for (const assetDirectory of getAssetDirectories(config)){
+        const prefix = assetDirectory.destination ? `${assetDirectory.destination}/` : '';
+        if (!normalizedPath.startsWith(prefix)) continue;
+        const relativePath = normalizedPath.slice(prefix.length);
+        const filePath = resolve(assetDirectory.source, relativePath);
+        if (filePath.startsWith(resolve(assetDirectory.source)) && existsSync(filePath) && statSync(filePath).isFile()) {
+            if (assetDirectory.exclude?.test(filePath)) continue;
+            return readFileSync(filePath);
+        }
+    }
+    return null;
+};
+export const getAssetRelativePath = (config, filePath)=>{
+    const outputPath = config.outputFullPath || resolve(process.cwd(), config.outputPath || './lib');
+    return relative(outputPath, filePath);
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/utils/vite/assets.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 {gzipSync} from 'zlib';\nimport favicons from 'favicons';\nimport {existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync} from 'fs';\nimport {sync as globSync} from 'glob';\nimport {extname, join, relative, resolve} from 'path';\nimport sharp from 'sharp';\nimport {optimize} from 'svgo';\n\nimport type {LexConfigType} from '../../LexConfig.js';\nimport {LexSvgSpritemap} from '../assets/LexSvgSpritemap.js';\n\nconst COMPRESSIBLE_FILE = /\\.(css|html|js|json|svg|txt|xml)$/i;\nconst IMAGE_FILE = /\\.(gif|jpe?g|png|svg|webp)$/i;\nconst MINIMUM_GZIP_SIZE = 8192;\n\ninterface GeneratedFavicons {\n  readonly files: ReadonlyArray<{contents: string; name: string}>;\n  readonly html: string[];\n  readonly images: ReadonlyArray<{contents: Buffer; name: string}>;\n}\n\nconst faviconCache = new Map<string, {modifiedAt: number; response: GeneratedFavicons}>();\n\nconst copyDirectory = (source: string, destination: string, exclude?: RegExp): void => {\n  if(!existsSync(source)) return;\n\n  for(const entry of readdirSync(source, {withFileTypes: true})) {\n    const sourcePath = join(source, entry.name);\n    const destinationPath = join(destination, entry.name);\n\n    if(exclude?.test(sourcePath)) continue;\n\n    if(entry.isDirectory()) {\n      copyDirectory(sourcePath, destinationPath, exclude);\n    } else {\n      mkdirSync(resolve(destinationPath, '..'), {recursive: true});\n      writeFileSync(destinationPath, readFileSync(sourcePath));\n    }\n  }\n};\n\nconst getAssetDirectories = (config: LexConfigType): Array<{destination: string; exclude?: RegExp; source: string}> => {\n  const sourcePath = config.sourceFullPath || resolve(process.cwd(), config.sourcePath || './src');\n  const staticPath = config.vite?.staticPath || './src/static';\n\n  return [\n    {destination: '', source: resolve(process.cwd(), staticPath)},\n    {destination: 'images', source: resolve(sourcePath, 'images')},\n    {destination: 'fonts', source: resolve(sourcePath, 'fonts')},\n    {destination: 'docs', source: resolve(sourcePath, 'docs')},\n    {destination: 'icons', exclude: /\\.svg$/i, source: resolve(sourcePath, 'icons')}\n  ];\n};\n\nexport const generateLexFavicons = async (config: LexConfigType): Promise<GeneratedFavicons | null> => {\n  const sourcePath = config.sourceFullPath || resolve(process.cwd(), config.sourcePath || './src');\n  const logoPath = resolve(sourcePath, 'images/logo.png');\n\n  if(!existsSync(logoPath)) return null;\n\n  const modifiedAt = statSync(logoPath).mtimeMs;\n  const cached = faviconCache.get(logoPath);\n  if(cached?.modifiedAt === modifiedAt) return cached.response;\n\n  const generated = await favicons(logoPath, {\n    icons: {\n      android: true,\n      appleIcon: true,\n      appleStartup: false,\n      favicons: true,\n      windows: false,\n      yandex: false\n    },\n    path: '/'\n  });\n  const [openGraphImage, twitterImage] = await Promise.all([\n    sharp(logoPath).resize(1200, 630, {fit: 'contain'}).png().toBuffer(),\n    sharp(logoPath).resize(1200, 675, {fit: 'contain'}).png().toBuffer()\n  ]);\n  const response: GeneratedFavicons = {\n    ...generated,\n    html: [\n      ...generated.html,\n      '<meta property=\"og:image\" content=\"/open-graph.png\">',\n      '<meta name=\"twitter:image\" content=\"/twitter.png\">'\n    ],\n    images: [\n      ...generated.images,\n      {contents: openGraphImage, name: 'open-graph.png'},\n      {contents: twitterImage, name: 'twitter.png'}\n    ]\n  };\n  faviconCache.set(logoPath, {modifiedAt, response});\n  return response;\n};\n\nexport const copyLexWebAssets = async (config: LexConfigType): Promise<void> => {\n  const outputPath = config.outputFullPath || resolve(process.cwd(), config.outputPath || './lib');\n\n  for(const assetDirectory of getAssetDirectories(config)) {\n    copyDirectory(assetDirectory.source, resolve(outputPath, assetDirectory.destination), assetDirectory.exclude);\n  }\n\n  const sourcePath = config.sourceFullPath || resolve(process.cwd(), config.sourcePath || './src');\n  const spritemap = new LexSvgSpritemap(resolve(sourcePath, 'icons/**/*.svg'), {\n    filename: 'icons/icons.svg',\n    prefix: false\n  }).buildSpritemap();\n\n  for(const warning of spritemap.warnings) console.warn(warning.message);\n\n  if(spritemap.content) {\n    const spritePath = resolve(outputPath, 'icons/icons.svg');\n    mkdirSync(resolve(spritePath, '..'), {recursive: true});\n    writeFileSync(spritePath, spritemap.content);\n  }\n\n  const generatedFavicons = await generateLexFavicons(config);\n  if(generatedFavicons) {\n    for(const image of generatedFavicons.images) {\n      const imagePath = resolve(outputPath, image.name);\n      mkdirSync(resolve(imagePath, '..'), {recursive: true});\n      writeFileSync(imagePath, image.contents);\n    }\n    for(const file of generatedFavicons.files) {\n      const filePath = resolve(outputPath, file.name);\n      mkdirSync(resolve(filePath, '..'), {recursive: true});\n      writeFileSync(filePath, file.contents);\n    }\n\n    const indexPath = resolve(outputPath, 'index.html');\n    if(existsSync(indexPath)) {\n      const html = readFileSync(indexPath, 'utf8');\n      const faviconHtml = generatedFavicons.html.join('\\n    ');\n      writeFileSync(indexPath, html.replace('</head>', `    ${faviconHtml}\\n  </head>`));\n    }\n  }\n};\n\nconst optimizeImage = async (filePath: string): Promise<void> => {\n  const extension = extname(filePath).toLowerCase();\n  const source = readFileSync(filePath);\n\n  if(extension === '.svg') {\n    const isSpritemap = filePath.endsWith('/icons/icons.svg');\n    const result = optimize(source.toString(), {\n      multipass: true,\n      path: filePath,\n      plugins: isSpritemap\n        ? [{name: 'preset-default', params: {overrides: {cleanupIds: false, removeHiddenElems: false}}}]\n        : ['preset-default']\n    });\n    writeFileSync(filePath, result.data);\n    return;\n  }\n\n  let image = sharp(source);\n  if(extension === '.jpg' || extension === '.jpeg') image = image.jpeg({progressive: true, quality: 65});\n  if(extension === '.png') image = image.png({quality: 90});\n  if(extension === '.webp') image = image.webp({quality: 75});\n  if(extension === '.gif') image = image.gif();\n\n  const optimized = await image.toBuffer();\n  if(optimized.length < source.length) writeFileSync(filePath, optimized);\n};\n\nexport const optimizeLexWebAssets = async (config: LexConfigType): Promise<void> => {\n  const outputPath = config.outputFullPath || resolve(process.cwd(), config.outputPath || './lib');\n  if(!existsSync(outputPath)) return;\n\n  const imageFiles = globSync('**/*.{gif,jpg,jpeg,png,svg,webp}', {\n    absolute: true,\n    cwd: outputPath,\n    nodir: true\n  });\n\n  await Promise.all(imageFiles.filter((filePath) => IMAGE_FILE.test(filePath)).map(optimizeImage));\n};\n\nexport const compressLexWebAssets = (config: LexConfigType): void => {\n  const outputPath = config.outputFullPath || resolve(process.cwd(), config.outputPath || './lib');\n  if(!existsSync(outputPath)) return;\n\n  const files = globSync('**/*', {absolute: true, cwd: outputPath, nodir: true});\n  for(const filePath of files) {\n    if(!COMPRESSIBLE_FILE.test(filePath) || statSync(filePath).size < MINIMUM_GZIP_SIZE) continue;\n    writeFileSync(`${filePath}.gz`, gzipSync(readFileSync(filePath)));\n  }\n};\n\nexport const getDevAsset = async (config: LexConfigType, requestPath: string): Promise<Buffer | null> => {\n  const normalizedPath = requestPath.split('?')[0].replace(/^\\/+/, '');\n  if(normalizedPath.includes('..')) return null;\n\n  if(normalizedPath === 'icons/icons.svg') {\n    const sourcePath = config.sourceFullPath || resolve(process.cwd(), config.sourcePath || './src');\n    const spritemap = new LexSvgSpritemap(resolve(sourcePath, 'icons/**/*.svg'), {prefix: false}).buildSpritemap();\n    return spritemap.content ? Buffer.from(spritemap.content) : null;\n  }\n\n  const generatedFavicons = await generateLexFavicons(config);\n  const generatedImage = generatedFavicons?.images.find(({name}) => name === normalizedPath);\n  if(generatedImage) return generatedImage.contents;\n  const generatedFile = generatedFavicons?.files.find(({name}) => name === normalizedPath);\n  if(generatedFile) return Buffer.from(generatedFile.contents);\n\n  for(const assetDirectory of getAssetDirectories(config)) {\n    const prefix = assetDirectory.destination ? `${assetDirectory.destination}/` : '';\n    if(!normalizedPath.startsWith(prefix)) continue;\n\n    const relativePath = normalizedPath.slice(prefix.length);\n    const filePath = resolve(assetDirectory.source, relativePath);\n    if(filePath.startsWith(resolve(assetDirectory.source)) && existsSync(filePath) && statSync(filePath).isFile()) {\n      if(assetDirectory.exclude?.test(filePath)) continue;\n      return readFileSync(filePath);\n    }\n  }\n\n  return null;\n};\n\nexport const getAssetRelativePath = (config: LexConfigType, filePath: string): string => {\n  const outputPath = config.outputFullPath || resolve(process.cwd(), config.outputPath || './lib');\n  return relative(outputPath, filePath);\n};\n"],"names":["gzipSync","favicons","existsSync","mkdirSync","readFileSync","readdirSync","statSync","writeFileSync","sync","globSync","extname","join","relative","resolve","sharp","optimize","LexSvgSpritemap","COMPRESSIBLE_FILE","IMAGE_FILE","MINIMUM_GZIP_SIZE","faviconCache","Map","copyDirectory","source","destination","exclude","entry","withFileTypes","sourcePath","name","destinationPath","test","isDirectory","recursive","getAssetDirectories","config","sourceFullPath","process","cwd","staticPath","vite","generateLexFavicons","logoPath","modifiedAt","mtimeMs","cached","get","response","generated","icons","android","appleIcon","appleStartup","windows","yandex","path","openGraphImage","twitterImage","Promise","all","resize","fit","png","toBuffer","html","images","contents","set","copyLexWebAssets","outputPath","outputFullPath","assetDirectory","spritemap","filename","prefix","buildSpritemap","warning","warnings","console","warn","message","content","spritePath","generatedFavicons","image","imagePath","file","files","filePath","indexPath","faviconHtml","replace","optimizeImage","extension","toLowerCase","isSpritemap","endsWith","result","toString","multipass","plugins","params","overrides","cleanupIds","removeHiddenElems","data","jpeg","progressive","quality","webp","gif","optimized","length","optimizeLexWebAssets","imageFiles","absolute","nodir","filter","map","compressLexWebAssets","size","getDevAsset","requestPath","normalizedPath","split","includes","Buffer","from","generatedImage","find","generatedFile","startsWith","relativePath","slice","isFile","getAssetRelativePath"],"mappings":"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"}

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

@@ -0,0 +1,12 @@
+import type { InlineConfig } from 'vite';
+export interface LexViteOptions {
+    readonly analyze?: boolean;
+    readonly command: 'build' | 'serve';
+    readonly entry?: string;
+    readonly mode?: string;
+    readonly open?: boolean;
+    readonly port?: number;
+    readonly quiet?: boolean;
+    readonly ssr?: boolean;
+}
+export declare const createLexViteConfig: (options: LexViteOptions) => InlineConfig;

package/lib/utils/vite/config.js

@@ -0,0 +1,272 @@
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { transform } from '@swc/core';
+import inject from '@rollup/plugin-inject';
+import { existsSync, readFileSync } from 'fs';
+import { extname, resolve } from 'path';
+import { mergeConfig } from 'vite';
+import { LexConfig } from '../../LexConfig.js';
+import { generateLexFavicons, getDevAsset } from './assets.js';
+const createInjectPlugin = inject;
+const contentTypes = {
+    '.css': 'text/css',
+    '.gif': 'image/gif',
+    '.html': 'text/html',
+    '.ico': 'image/x-icon',
+    '.jpeg': 'image/jpeg',
+    '.jpg': 'image/jpeg',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.svg': 'image/svg+xml',
+    '.ttf': 'font/ttf',
+    '.txt': 'text/plain',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2'
+};
+const emptyCryptoPlugin = ()=>({
+        load (id) {
+            return id === '\0lex-empty-crypto' ? 'export default {}; export const webcrypto = undefined;' : null;
+        },
+        name: 'lex-empty-crypto',
+        resolveId (id) {
+            return id === 'crypto' || id === 'node:crypto' ? '\0lex-empty-crypto' : null;
+        }
+    });
+const nodePolyfillModules = {
+    assert: 'assert/build/assert.js',
+    buffer: 'buffer/index.js',
+    http: 'stream-http/index.js',
+    https: 'https-browserify/index.js',
+    os: 'os-browserify/browser.js',
+    path: 'path-browserify/index.js',
+    process: 'process/browser.js',
+    stream: 'stream-browserify/index.js',
+    util: 'util/util.js',
+    vm: 'vm-browserify/index.js'
+};
+const nodePolyfillsPlugin = ()=>({
+        name: 'lex-node-polyfills',
+        resolveId (id) {
+            const moduleName = id.startsWith('node:') ? id.slice(5) : id;
+            const replacement = nodePolyfillModules[moduleName];
+            return replacement ? resolveProjectPackage(replacement) : null;
+        }
+    });
+const graphqlPlugin = ()=>({
+        load (id) {
+            if (!/\.(gql|graphql)$/.test(id)) return null;
+            const source = JSON.stringify(readFileSync(id, 'utf8'));
+            return `import gql from 'graphql-tag'; export default gql(${source});`;
+        },
+        name: 'lex-graphql'
+    });
+const swcPlugin = (sourcePath)=>({
+        enforce: 'pre',
+        async transform (source, id) {
+            const cleanId = id.split('?')[0];
+            if (!cleanId.startsWith(sourcePath) || !/\.[jt]sx?$/.test(cleanId) || /\.(test|spec|integration|e2e)\.[jt]sx?$/.test(cleanId)) return null;
+            const swcConfig = LexConfig.getSWCConfigWithReactCompiler();
+            const result = await transform(source, {
+                ...swcConfig,
+                filename: cleanId,
+                module: {
+                    ...swcConfig?.module,
+                    type: 'es6'
+                },
+                sourceMaps: true
+            });
+            const needsReact = /\bReact\s*\./.test(result.code) && !/from\s+['"]react['"]/.test(result.code);
+            return {
+                code: needsReact ? `import React from 'react';\n${result.code}` : result.code,
+                map: result.map || null
+            };
+        },
+        name: 'lex-swc'
+    });
+const importMetaCompatibilityPlugin = (sourcePath)=>({
+        enforce: 'post',
+        name: 'lex-import-meta-compatibility',
+        transform (source, id) {
+            const cleanId = id.split('?')[0];
+            if (!cleanId.startsWith(sourcePath) || !source.includes('import.meta.url')) return null;
+            const replacement = '(typeof document !== "undefined" && document.currentScript && document.currentScript.src ? new URL(document.currentScript.src, window.location.href).href : (typeof window !== "undefined" ? new URL("", window.location.href).href : ""))';
+            return source.replaceAll('import.meta.url', replacement);
+        }
+    });
+const assetsDevPlugin = ()=>{
+    let faviconHtml = [];
+    return {
+        async buildStart () {
+            const generatedFavicons = await generateLexFavicons(LexConfig.config);
+            faviconHtml = generatedFavicons?.html || [];
+        },
+        configureServer (server) {
+            server.middlewares.use(async (request, response, next)=>{
+                if (!request.url) return next();
+                const asset = await getDevAsset(LexConfig.config, request.url);
+                if (!asset) return next();
+                response.statusCode = 200;
+                response.setHeader('Content-Type', contentTypes[extname(request.url.split('?')[0])] || 'application/octet-stream');
+                response.end(asset);
+            });
+        },
+        name: 'lex-assets-dev',
+        transformIndexHtml (html) {
+            if (faviconHtml.length === 0) return html;
+            return html.replace('</head>', `    ${faviconHtml.join('\n    ')}\n  </head>`);
+        }
+    };
+};
+const analyzerPlugin = (enabled)=>({
+        generateBundle (_options, bundle) {
+            if (!enabled) return;
+            const report = Object.entries(bundle).map(([fileName, output])=>({
+                    fileName,
+                    size: output.type === 'asset' ? Buffer.byteLength(typeof output.source === 'string' ? output.source : output.source) : Buffer.byteLength(output.code),
+                    type: output.type
+                }));
+            this.emitFile({
+                fileName: 'bundle-report.json',
+                source: JSON.stringify(report, null, 2),
+                type: 'asset'
+            });
+        },
+        name: 'lex-bundle-analyzer'
+    });
+const getLibraryFormats = (libraryTarget)=>{
+    if (libraryTarget === 'commonjs' || libraryTarget === 'commonjs2') return [
+        'cjs'
+    ];
+    if (libraryTarget === 'var' || libraryTarget === 'window') return [
+        'iife'
+    ];
+    if (libraryTarget === 'umd') return [
+        'umd'
+    ];
+    return [
+        'es'
+    ];
+};
+const resolveProjectPackage = (packageName)=>{
+    const projectPackage = resolve(process.cwd(), 'node_modules', packageName);
+    return existsSync(projectPackage) ? projectPackage : resolve(LexConfig.getLexDir(), 'node_modules', packageName);
+};
+export const createLexViteConfig = (options)=>{
+    const config = LexConfig.config;
+    const sourcePath = config.sourceFullPath || resolve(process.cwd(), config.sourcePath || './src');
+    const outputPath = config.outputFullPath || resolve(process.cwd(), config.outputPath || './lib');
+    const entryPath = resolve(sourcePath, options.entry || config.entryJs || 'index.js');
+    const htmlPath = resolve(sourcePath, config.entryHTML || 'index.html');
+    const hasHtmlEntry = existsSync(htmlPath) && !options.ssr;
+    const outputHash = config.outputHash || options.mode === 'production';
+    const fileName = config.outputFile || (outputHash ? '[name].[hash].js' : '[name].js');
+    const viteConfig = {
+        appType: hasHtmlEntry ? 'spa' : 'custom',
+        base: '/',
+        build: {
+            cssCodeSplit: true,
+            emptyOutDir: false,
+            minify: options.mode === 'production',
+            outDir: outputPath,
+            rolldownOptions: {
+                input: hasHtmlEntry ? htmlPath : entryPath,
+                output: {
+                    assetFileNames: outputHash ? 'assets/[name].[hash][extname]' : 'assets/[name][extname]',
+                    chunkFileNames: outputHash ? '[name].[hash].chunk.js' : '[name].chunk.js',
+                    entryFileNames: fileName,
+                    manualChunks (id) {
+                        return id.includes('/node_modules/') ? 'vendors' : undefined;
+                    }
+                }
+            },
+            sourcemap: config.swc?.sourceMaps ? true : false,
+            ssr: options.ssr ? entryPath : false,
+            target: config.swc?.jsc?.target?.toString() || 'es2020'
+        },
+        clearScreen: false,
+        configFile: false,
+        css: {
+            postcss: resolve(LexConfig.getLexDir(), 'postcss.config.js')
+        },
+        define: {
+            'process.env.NODE_ENV': JSON.stringify(options.mode || (options.command === 'build' ? 'production' : 'development'))
+        },
+        envDir: process.cwd(),
+        logLevel: options.quiet ? 'silent' : 'info',
+        mode: options.mode || (options.command === 'build' ? 'production' : 'development'),
+        plugins: [
+            ...options.ssr ? [] : [
+                emptyCryptoPlugin(),
+                nodePolyfillsPlugin(),
+                createInjectPlugin({
+                    Buffer: [
+                        resolveProjectPackage('buffer/index.js'),
+                        'Buffer'
+                    ],
+                    global: [
+                        resolveProjectPackage('global/window.js'),
+                        'default'
+                    ],
+                    process: [
+                        resolveProjectPackage('process/browser.js'),
+                        'default'
+                    ]
+                })
+            ],
+            swcPlugin(sourcePath),
+            graphqlPlugin(),
+            ...options.ssr ? [] : [
+                importMetaCompatibilityPlugin(sourcePath),
+                assetsDevPlugin(),
+                analyzerPlugin(Boolean(options.analyze))
+            ]
+        ],
+        publicDir: false,
+        resolve: {
+            alias: {
+                Buffer: resolveProjectPackage('buffer'),
+                'core-js': resolveProjectPackage('core-js'),
+                global: resolveProjectPackage('global'),
+                'graphql-tag': resolveProjectPackage('graphql-tag'),
+                randombytes: resolve(LexConfig.getLexDir(), 'node_modules/randombytes'),
+                react: resolveProjectPackage('react'),
+                'react-dom': resolveProjectPackage('react-dom'),
+                'regenerator-runtime': resolveProjectPackage('regenerator-runtime')
+            },
+            extensions: [
+                '.mjs',
+                '.js',
+                '.ts',
+                '.tsx',
+                '.jsx',
+                '.json',
+                '.gql',
+                '.graphql'
+            ],
+            preserveSymlinks: false,
+            tsconfigPaths: true
+        },
+        root: sourcePath,
+        server: {
+            hmr: false,
+            open: options.open,
+            port: options.port,
+            strictPort: true
+        }
+    };
+    if (!hasHtmlEntry && config.libraryName && !options.ssr) {
+        viteConfig.build = {
+            ...viteConfig.build,
+            lib: {
+                entry: entryPath,
+                fileName: ()=>config.outputFile || 'index.js',
+                formats: getLibraryFormats(config.libraryTarget),
+                name: config.libraryName
+            }
+        };
+    }
+    return mergeConfig(viteConfig, config.vite || {});
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/utils/vite/config.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 {transform} from '@swc/core';\nimport inject from '@rollup/plugin-inject';\nimport {existsSync, readFileSync} from 'fs';\nimport {extname, resolve} from 'path';\nimport {mergeConfig} from 'vite';\n\nimport {LexConfig} from '../../LexConfig.js';\nimport {generateLexFavicons, getDevAsset} from './assets.js';\n\nimport type {InlineConfig, Plugin} from 'vite';\n\nconst createInjectPlugin = inject as unknown as (options: Record<string, unknown>) => Plugin;\n\nexport interface LexViteOptions {\n  readonly analyze?: boolean;\n  readonly command: 'build' | 'serve';\n  readonly entry?: string;\n  readonly mode?: string;\n  readonly open?: boolean;\n  readonly port?: number;\n  readonly quiet?: boolean;\n  readonly ssr?: boolean;\n}\n\nconst contentTypes: Record<string, string> = {\n  '.css': 'text/css',\n  '.gif': 'image/gif',\n  '.html': 'text/html',\n  '.ico': 'image/x-icon',\n  '.jpeg': 'image/jpeg',\n  '.jpg': 'image/jpeg',\n  '.json': 'application/json',\n  '.png': 'image/png',\n  '.svg': 'image/svg+xml',\n  '.ttf': 'font/ttf',\n  '.txt': 'text/plain',\n  '.woff': 'font/woff',\n  '.woff2': 'font/woff2'\n};\n\nconst emptyCryptoPlugin = (): Plugin => ({\n  load(id) {\n    return id === '\\0lex-empty-crypto' ? 'export default {}; export const webcrypto = undefined;' : null;\n  },\n  name: 'lex-empty-crypto',\n  resolveId(id) {\n    return id === 'crypto' || id === 'node:crypto' ? '\\0lex-empty-crypto' : null;\n  }\n});\n\nconst nodePolyfillModules: Record<string, string> = {\n  assert: 'assert/build/assert.js',\n  buffer: 'buffer/index.js',\n  http: 'stream-http/index.js',\n  https: 'https-browserify/index.js',\n  os: 'os-browserify/browser.js',\n  path: 'path-browserify/index.js',\n  process: 'process/browser.js',\n  stream: 'stream-browserify/index.js',\n  util: 'util/util.js',\n  vm: 'vm-browserify/index.js'\n};\n\nconst nodePolyfillsPlugin = (): Plugin => ({\n  name: 'lex-node-polyfills',\n  resolveId(id) {\n    const moduleName = id.startsWith('node:') ? id.slice(5) : id;\n    const replacement = nodePolyfillModules[moduleName];\n    return replacement ? resolveProjectPackage(replacement) : null;\n  }\n});\n\nconst graphqlPlugin = (): Plugin => ({\n  load(id) {\n    if(!/\\.(gql|graphql)$/.test(id)) return null;\n    const source = JSON.stringify(readFileSync(id, 'utf8'));\n    return `import gql from 'graphql-tag'; export default gql(${source});`;\n  },\n  name: 'lex-graphql'\n});\n\nconst swcPlugin = (sourcePath: string): Plugin => ({\n  enforce: 'pre',\n  async transform(source, id) {\n    const cleanId = id.split('?')[0];\n    if(!cleanId.startsWith(sourcePath) || !/\\.[jt]sx?$/.test(cleanId) || /\\.(test|spec|integration|e2e)\\.[jt]sx?$/.test(cleanId)) return null;\n\n    const swcConfig = LexConfig.getSWCConfigWithReactCompiler();\n    const result = await transform(source, {\n      ...swcConfig,\n      filename: cleanId,\n      module: {...swcConfig?.module, type: 'es6'},\n      sourceMaps: true\n    });\n\n    const needsReact = /\\bReact\\s*\\./.test(result.code) && !/from\\s+['\"]react['\"]/.test(result.code);\n    return {\n      code: needsReact ? `import React from 'react';\\n${result.code}` : result.code,\n      map: result.map || null\n    };\n  },\n  name: 'lex-swc'\n});\n\nconst importMetaCompatibilityPlugin = (sourcePath: string): Plugin => ({\n  enforce: 'post',\n  name: 'lex-import-meta-compatibility',\n  transform(source, id) {\n    const cleanId = id.split('?')[0];\n    if(!cleanId.startsWith(sourcePath) || !source.includes('import.meta.url')) return null;\n\n    const replacement = '(typeof document !== \"undefined\" && document.currentScript && document.currentScript.src ? new URL(document.currentScript.src, window.location.href).href : (typeof window !== \"undefined\" ? new URL(\"\", window.location.href).href : \"\"))';\n    return source.replaceAll('import.meta.url', replacement);\n  }\n});\n\nconst assetsDevPlugin = (): Plugin => {\n  let faviconHtml: string[] = [];\n\n  return {\n    async buildStart() {\n      const generatedFavicons = await generateLexFavicons(LexConfig.config);\n      faviconHtml = generatedFavicons?.html || [];\n    },\n    configureServer(server) {\n      server.middlewares.use(async (request, response, next) => {\n        if(!request.url) return next();\n        const asset = await getDevAsset(LexConfig.config, request.url);\n        if(!asset) return next();\n\n        response.statusCode = 200;\n        response.setHeader('Content-Type', contentTypes[extname(request.url.split('?')[0])] || 'application/octet-stream');\n        response.end(asset);\n      });\n    },\n    name: 'lex-assets-dev',\n    transformIndexHtml(html) {\n      if(faviconHtml.length === 0) return html;\n      return html.replace('</head>', `    ${faviconHtml.join('\\n    ')}\\n  </head>`);\n    }\n  };\n};\n\nconst analyzerPlugin = (enabled: boolean): Plugin => ({\n  generateBundle(_options, bundle) {\n    if(!enabled) return;\n\n    const report = Object.entries(bundle).map(([fileName, output]) => ({\n      fileName,\n      size: output.type === 'asset'\n        ? Buffer.byteLength(typeof output.source === 'string' ? output.source : output.source)\n        : Buffer.byteLength(output.code),\n      type: output.type\n    }));\n\n    this.emitFile({fileName: 'bundle-report.json', source: JSON.stringify(report, null, 2), type: 'asset'});\n  },\n  name: 'lex-bundle-analyzer'\n});\n\nconst getLibraryFormats = (libraryTarget?: string): Array<'cjs' | 'es' | 'iife' | 'umd'> => {\n  if(libraryTarget === 'commonjs' || libraryTarget === 'commonjs2') return ['cjs'];\n  if(libraryTarget === 'var' || libraryTarget === 'window') return ['iife'];\n  if(libraryTarget === 'umd') return ['umd'];\n  return ['es'];\n};\n\nconst resolveProjectPackage = (packageName: string): string => {\n  const projectPackage = resolve(process.cwd(), 'node_modules', packageName);\n  return existsSync(projectPackage) ? projectPackage : resolve(LexConfig.getLexDir(), 'node_modules', packageName);\n};\n\nexport const createLexViteConfig = (options: LexViteOptions): InlineConfig => {\n  const config = LexConfig.config;\n  const sourcePath = config.sourceFullPath || resolve(process.cwd(), config.sourcePath || './src');\n  const outputPath = config.outputFullPath || resolve(process.cwd(), config.outputPath || './lib');\n  const entryPath = resolve(sourcePath, options.entry || config.entryJs || 'index.js');\n  const htmlPath = resolve(sourcePath, config.entryHTML || 'index.html');\n  const hasHtmlEntry = existsSync(htmlPath) && !options.ssr;\n  const outputHash = config.outputHash || options.mode === 'production';\n  const fileName = config.outputFile || (outputHash ? '[name].[hash].js' : '[name].js');\n\n  const viteConfig: InlineConfig = {\n    appType: hasHtmlEntry ? 'spa' : 'custom',\n    base: '/',\n    build: {\n      cssCodeSplit: true,\n      emptyOutDir: false,\n      minify: options.mode === 'production',\n      outDir: outputPath,\n      rolldownOptions: {\n        input: hasHtmlEntry ? htmlPath : entryPath,\n        output: {\n          assetFileNames: outputHash ? 'assets/[name].[hash][extname]' : 'assets/[name][extname]',\n          chunkFileNames: outputHash ? '[name].[hash].chunk.js' : '[name].chunk.js',\n          entryFileNames: fileName,\n          manualChunks(id) {\n            return id.includes('/node_modules/') ? 'vendors' : undefined;\n          }\n        }\n      },\n      sourcemap: config.swc?.sourceMaps ? true : false,\n      ssr: options.ssr ? entryPath : false,\n      target: config.swc?.jsc?.target?.toString() || 'es2020'\n    },\n    clearScreen: false,\n    configFile: false,\n    css: {\n      postcss: resolve(LexConfig.getLexDir(), 'postcss.config.js')\n    },\n    define: {\n      'process.env.NODE_ENV': JSON.stringify(options.mode || (options.command === 'build' ? 'production' : 'development'))\n    },\n    envDir: process.cwd(),\n    logLevel: options.quiet ? 'silent' : 'info',\n    mode: options.mode || (options.command === 'build' ? 'production' : 'development'),\n    plugins: [\n      ...(options.ssr ? [] : [\n        emptyCryptoPlugin(),\n        nodePolyfillsPlugin(),\n        createInjectPlugin({\n          Buffer: [resolveProjectPackage('buffer/index.js'), 'Buffer'],\n          global: [resolveProjectPackage('global/window.js'), 'default'],\n          process: [resolveProjectPackage('process/browser.js'), 'default']\n        })\n      ]),\n      swcPlugin(sourcePath),\n      graphqlPlugin(),\n      ...(options.ssr ? [] : [importMetaCompatibilityPlugin(sourcePath), assetsDevPlugin(), analyzerPlugin(Boolean(options.analyze))])\n    ],\n    publicDir: false,\n    resolve: {\n      alias: {\n        Buffer: resolveProjectPackage('buffer'),\n        'core-js': resolveProjectPackage('core-js'),\n        global: resolveProjectPackage('global'),\n        'graphql-tag': resolveProjectPackage('graphql-tag'),\n        randombytes: resolve(LexConfig.getLexDir(), 'node_modules/randombytes'),\n        react: resolveProjectPackage('react'),\n        'react-dom': resolveProjectPackage('react-dom'),\n        'regenerator-runtime': resolveProjectPackage('regenerator-runtime')\n      },\n      extensions: ['.mjs', '.js', '.ts', '.tsx', '.jsx', '.json', '.gql', '.graphql'],\n      preserveSymlinks: false,\n      tsconfigPaths: true\n    },\n    root: sourcePath,\n    server: {\n      hmr: false,\n      open: options.open,\n      port: options.port,\n      strictPort: true\n    }\n  };\n\n  if(!hasHtmlEntry && config.libraryName && !options.ssr) {\n    viteConfig.build = {\n      ...viteConfig.build,\n      lib: {\n        entry: entryPath,\n        fileName: () => config.outputFile || 'index.js',\n        formats: getLibraryFormats(config.libraryTarget),\n        name: config.libraryName\n      }\n    };\n  }\n\n  return mergeConfig(viteConfig, config.vite || {}) as InlineConfig;\n};\n"],"names":["transform","inject","existsSync","readFileSync","extname","resolve","mergeConfig","LexConfig","generateLexFavicons","getDevAsset","createInjectPlugin","contentTypes","emptyCryptoPlugin","load","id","name","resolveId","nodePolyfillModules","assert","buffer","http","https","os","path","process","stream","util","vm","nodePolyfillsPlugin","moduleName","startsWith","slice","replacement","resolveProjectPackage","graphqlPlugin","test","source","JSON","stringify","swcPlugin","sourcePath","enforce","cleanId","split","swcConfig","getSWCConfigWithReactCompiler","result","filename","module","type","sourceMaps","needsReact","code","map","importMetaCompatibilityPlugin","includes","replaceAll","assetsDevPlugin","faviconHtml","buildStart","generatedFavicons","config","html","configureServer","server","middlewares","use","request","response","next","url","asset","statusCode","setHeader","end","transformIndexHtml","length","replace","join","analyzerPlugin","enabled","generateBundle","_options","bundle","report","Object","entries","fileName","output","size","Buffer","byteLength","emitFile","getLibraryFormats","libraryTarget","packageName","projectPackage","cwd","getLexDir","createLexViteConfig","options","sourceFullPath","outputPath","outputFullPath","entryPath","entry","entryJs","htmlPath","entryHTML","hasHtmlEntry","ssr","outputHash","mode","outputFile","viteConfig","appType","base","build","cssCodeSplit","emptyOutDir","minify","outDir","rolldownOptions","input","assetFileNames","chunkFileNames","entryFileNames","manualChunks","undefined","sourcemap","swc","target","jsc","toString","clearScreen","configFile","css","postcss","define","command","envDir","logLevel","quiet","plugins","global","Boolean","analyze","publicDir","alias","randombytes","react","extensions","preserveSymlinks","tsconfigPaths","root","hmr","open","port","strictPort","libraryName","lib","formats","vite"],"mappings":"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"}