@nlabs/lex 1.46.2 → 1.47.1

package/dist/utils/aiService.js

@@ -0,0 +1,299 @@
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { resolve as pathResolve } from "path";
+import readline from "readline";
+import { createSpinner } from "./app.js";
+import { log } from "./log.js";
+import { LexConfig } from "../LexConfig.js";
+const callCursorAI = async (prompt, options) => {
+  try {
+    log("Using Cursor IDE for AI fixes...", "info");
+    log("AI fix requested via Cursor IDE", "info");
+    const taskMatch = prompt.match(/^(Generate code according to the following request|Explain the following code|Generate comprehensive unit tests|Analyze the following code|Provide guidance on the following development question):/);
+    const task = taskMatch ? taskMatch[1] : "";
+    const isGenerateTask = task.startsWith("Generate code");
+    const questionMatch = prompt.match(/(?:Generate code according to the following request|Explain the following code|Generate comprehensive unit tests|Analyze the following code|Provide guidance on the following development question):\s*([\s\S]+?)(?:===CONTEXT===|$)/);
+    const question = questionMatch ? questionMatch[1].trim() : prompt;
+    if (question.toLowerCase().includes("how many files") && prompt.includes("Project structure:")) {
+      const projectStructure = prompt.split("Project structure:")[1] || "";
+      const files = projectStructure.trim().split("\n");
+      return `Based on the project structure provided, there are ${files.length} files in the project.`;
+    }
+    if (isGenerateTask) {
+      return `
+# Code Generation Request: "${question}"
+
+To generate code using Cursor's AI capabilities:
+
+1. **Open your project in Cursor IDE** (https://cursor.sh)
+2. Press **Cmd+L** (or Ctrl+L on Windows/Linux) to open the AI chat
+3. Type your request: "${question}"
+4. Cursor will generate the code directly in your editor
+
+The current CLI integration doesn't have direct access to Cursor's code generation capabilities.
+
+**Alternative options:**
+
+1. **Use OpenAI or Anthropic directly:**
+   Configure in your lex.config file:
+   \`\`\`js
+   export default {
+     ai: {
+       provider: 'openai',
+       apiKey: process.env.OPENAI_API_KEY,
+       model: 'gpt-4o'
+     }
+   }
+   \`\`\`
+
+2. **Use Cursor's command line tool:**
+   Install: \`npm install -g @cursor/cli\`
+   Run: \`cursor ai "${question}"\`
+`;
+    }
+    return `
+To use Cursor's AI capabilities for "${question}", you need to:
+
+1. Open your project in Cursor IDE (https://cursor.sh)
+2. Use Cursor's built-in AI features by pressing Cmd+K or Cmd+L
+3. Or run the 'cursor' command directly from your terminal
+
+The current integration is limited and doesn't directly access Cursor's AI capabilities.
+
+For the best experience with AI code generation:
+- Use Cursor IDE directly
+- Or configure OpenAI or Anthropic as your provider in your lex.config file:
+
+\`\`\`js
+// lex.config.js (or lex.config.mjs, lex.config.cjs, etc.)
+export default {
+  ai: {
+    provider: 'openai', // or 'anthropic'
+    apiKey: process.env.OPENAI_API_KEY, // or ANTHROPIC_API_KEY
+    model: 'gpt-4o' // or 'claude-3-opus'
+  }
+}
+\`\`\`
+
+Then set your API key as an environment variable:
+\`\`\`
+export OPENAI_API_KEY=your_key_here
+\`\`\`
+`;
+  } catch (error) {
+    throw new Error(`Cursor AI error: ${error.message}`);
+  }
+};
+const callOpenAIAI = async (prompt, options) => {
+  try {
+    const apiKey = options.apiKey || process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+      throw new Error("OpenAI API key is required. Set it in your lex.config file or as OPENAI_API_KEY environment variable.");
+    }
+    const response = await fetch("https://api.openai.com/v1/chat/completions", {
+      body: JSON.stringify({
+        max_tokens: options.maxTokens || 4e3,
+        messages: [
+          { content: "You are a helpful assistant that fixes ESLint errors in code.", role: "system" },
+          { content: prompt, role: "user" }
+        ],
+        model: options.model || "gpt-4o",
+        temperature: options.temperature || 0.1
+      }),
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      method: "POST"
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(`OpenAI API error: ${error.error?.message || response.statusText}`);
+    }
+    const data = await response.json();
+    return data.choices[0].message.content;
+  } catch (error) {
+    throw new Error(`OpenAI AI error: ${error.message}`);
+  }
+};
+const callAnthropicAI = async (prompt, options) => {
+  try {
+    const apiKey = options.apiKey || process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      throw new Error("Anthropic API key is required. Set it in your lex.config file or as ANTHROPIC_API_KEY environment variable.");
+    }
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      body: JSON.stringify({
+        max_tokens: options.maxTokens || 4e3,
+        messages: [
+          { content: prompt, role: "user" }
+        ],
+        model: options.model || "claude-3-sonnet-20240229",
+        temperature: options.temperature || 0.1
+      }),
+      headers: {
+        "Content-Type": "application/json",
+        "anthropic-version": "2023-06-01",
+        "x-api-key": apiKey
+      },
+      method: "POST"
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(`Anthropic API error: ${error.error?.message || response.statusText}`);
+    }
+    const data = await response.json();
+    return data.content[0].text;
+  } catch (error) {
+    throw new Error(`Anthropic AI error: ${error.message}`);
+  }
+};
+const callCopilotAI = async (prompt, options) => {
+  try {
+    log("GitHub Copilot AI fixes not directly supported. Using manual fix mode.", "info");
+    return prompt;
+  } catch (error) {
+    throw new Error(`GitHub Copilot AI error: ${error.message}`);
+  }
+};
+const promptForAIProvider = async (quiet = false) => {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    log("\nNo AI provider configured. Please choose an AI provider:", "info");
+    log("1. Cursor IDE", "info");
+    log("2. OpenAI", "info");
+    log("3. Anthropic", "info");
+    log("4. GitHub Copilot", "info");
+    log("5. None (Skip AI features)", "info");
+    rl.question("Enter your choice (1-5): ", (answer) => {
+      rl.close();
+      switch (answer) {
+        case "1":
+          resolve("cursor");
+          break;
+        case "2":
+          resolve("openai");
+          break;
+        case "3":
+          resolve("anthropic");
+          break;
+        case "4":
+          resolve("copilot");
+          break;
+        default:
+          resolve("none");
+      }
+    });
+  });
+};
+const promptForAPIKey = async (provider, quiet = false) => {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(`Please enter your ${provider} API key: `, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+};
+const getAIService = (provider, options) => {
+  switch (provider) {
+    case "cursor":
+      return callCursorAI;
+    case "openai":
+      return callOpenAIAI;
+    case "anthropic":
+      return callAnthropicAI;
+    case "copilot":
+      return callCopilotAI;
+    default:
+      return async () => "No AI provider configured";
+  }
+};
+const callAIService = async (prompt, quiet = false) => {
+  const spinner = createSpinner(quiet);
+  spinner.start("Calling AI service to fix code issues...");
+  try {
+    const aiConfig = LexConfig.config.ai || { provider: "none" };
+    const isInCursorIDE = process.env.CURSOR_IDE === "true";
+    if (isInCursorIDE && (aiConfig.provider === "none" || !aiConfig.provider)) {
+      log("Detected Cursor IDE environment, using Cursor as AI provider", "info", quiet);
+      aiConfig.provider = "cursor";
+    }
+    if (aiConfig.provider === "none") {
+      const provider = await promptForAIProvider(quiet);
+      if (provider === "none") {
+        spinner.fail("AI features skipped");
+        return "";
+      }
+      aiConfig.provider = provider;
+      if (provider !== "cursor" && provider !== "copilot" && !process.env[`${provider.toUpperCase()}_API_KEY`]) {
+        aiConfig.apiKey = await promptForAPIKey(provider, quiet);
+      }
+      LexConfig.config.ai = aiConfig;
+      const configFormats = ["js", "mjs", "cjs", "ts", "json"];
+      const configBaseName = "lex.config";
+      let configPath = "";
+      for (const format of configFormats) {
+        const potentialPath = pathResolve(process.cwd(), `./${configBaseName}.${format}`);
+        if (existsSync(potentialPath)) {
+          configPath = potentialPath;
+          break;
+        }
+      }
+      if (configPath) {
+        try {
+          const configContent = readFileSync(configPath, "utf8");
+          const updatedConfig = configContent.replace(
+            /ai:.*?[,}]/s,
+            `ai: { provider: '${aiConfig.provider}' },`
+          );
+          writeFileSync(configPath, updatedConfig);
+        } catch (_error) {
+        }
+      }
+    }
+    let result = "";
+    switch (aiConfig.provider) {
+      case "cursor":
+        result = await callCursorAI(prompt, aiConfig);
+        log("Cursor IDE AI integration active", "info", quiet);
+        break;
+      case "openai":
+        result = await callOpenAIAI(prompt, aiConfig);
+        break;
+      case "anthropic":
+        result = await callAnthropicAI(prompt, aiConfig);
+        break;
+      case "copilot":
+        result = await callCopilotAI(prompt, aiConfig);
+        break;
+      default:
+        spinner.fail("No AI provider configured");
+        return "";
+    }
+    spinner.succeed("AI code fixes generated successfully");
+    return result;
+  } catch (error) {
+    spinner.fail(`AI service error: ${error.message}`);
+    if (!quiet) {
+      log(error, "error");
+    }
+    return "";
+  }
+};
+export {
+  callAIService,
+  callAnthropicAI,
+  callCopilotAI,
+  callCursorAI,
+  callOpenAIAI,
+  getAIService,
+  promptForAIProvider,
+  promptForAPIKey
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/utils/aiService.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2022-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {existsSync, readFileSync, writeFileSync} from 'fs';\nimport {resolve as pathResolve} from 'path';\nimport readline from 'readline';\n\nimport {createSpinner} from './app.js';\nimport {log} from './log.js';\nimport {LexConfig, AIConfig} from '../LexConfig.js';\n\n// Cursor IDE integration\nexport const callCursorAI = async (prompt: string, options: AIConfig): Promise<string> => {\n  try {\n    // When running within Cursor IDE, we can write the prompt to a temporary file\n    // that Cursor can use to provide AI assistance\n    log('Using Cursor IDE for AI fixes...', 'info');\n\n    // For now, just log the prompt and return a placeholder\n    // In a real implementation, Cursor would handle this automatically\n    log('AI fix requested via Cursor IDE', 'info');\n\n    const taskMatch = prompt.match(/^(Generate code according to the following request|Explain the following code|Generate comprehensive unit tests|Analyze the following code|Provide guidance on the following development question):/);\n    const task = taskMatch ? taskMatch[1] : '';\n    const isGenerateTask = task.startsWith('Generate code');\n\n    const questionMatch = prompt.match(/(?:Generate code according to the following request|Explain the following code|Generate comprehensive unit tests|Analyze the following code|Provide guidance on the following development question):\\s*([\\s\\S]+?)(?:===CONTEXT===|$)/);\n    const question = questionMatch ? questionMatch[1].trim() : prompt;\n\n    if(question.toLowerCase().includes('how many files') && prompt.includes('Project structure:')) {\n      const projectStructure = prompt.split('Project structure:')[1] || '';\n      const files = projectStructure.trim().split('\\n');\n      return `Based on the project structure provided, there are ${files.length} files in the project.`;\n    }\n\n    if(isGenerateTask) {\n      return `\n# Code Generation Request: \"${question}\"\n\nTo generate code using Cursor's AI capabilities:\n\n1. **Open your project in Cursor IDE** (https://cursor.sh)\n2. Press **Cmd+L** (or Ctrl+L on Windows/Linux) to open the AI chat\n3. Type your request: \"${question}\"\n4. Cursor will generate the code directly in your editor\n\nThe current CLI integration doesn't have direct access to Cursor's code generation capabilities.\n\n**Alternative options:**\n\n1. **Use OpenAI or Anthropic directly:**\n   Configure in your lex.config file:\n   \\`\\`\\`js\n   export default {\n     ai: {\n       provider: 'openai',\n       apiKey: process.env.OPENAI_API_KEY,\n       model: 'gpt-4o'\n     }\n   }\n   \\`\\`\\`\n\n2. **Use Cursor's command line tool:**\n   Install: \\`npm install -g @cursor/cli\\`\n   Run: \\`cursor ai \"${question}\"\\`\n`;\n    }\n\n    return `\nTo use Cursor's AI capabilities for \"${question}\", you need to:\n\n1. Open your project in Cursor IDE (https://cursor.sh)\n2. Use Cursor's built-in AI features by pressing Cmd+K or Cmd+L\n3. Or run the 'cursor' command directly from your terminal\n\nThe current integration is limited and doesn't directly access Cursor's AI capabilities.\n\nFor the best experience with AI code generation:\n- Use Cursor IDE directly\n- Or configure OpenAI or Anthropic as your provider in your lex.config file:\n\n\\`\\`\\`js\n// lex.config.js (or lex.config.mjs, lex.config.cjs, etc.)\nexport default {\n  ai: {\n    provider: 'openai', // or 'anthropic'\n    apiKey: process.env.OPENAI_API_KEY, // or ANTHROPIC_API_KEY\n    model: 'gpt-4o' // or 'claude-3-opus'\n  }\n}\n\\`\\`\\`\n\nThen set your API key as an environment variable:\n\\`\\`\\`\nexport OPENAI_API_KEY=your_key_here\n\\`\\`\\`\n`;\n  } catch(error) {\n    throw new Error(`Cursor AI error: ${error.message}`);\n  }\n};\n\nexport const callOpenAIAI = async (prompt: string, options: AIConfig): Promise<string> => {\n  try {\n    const apiKey = options.apiKey || process.env.OPENAI_API_KEY;\n    if(!apiKey) {\n      throw new Error('OpenAI API key is required. Set it in your lex.config file or as OPENAI_API_KEY environment variable.');\n    }\n\n    const response = await fetch('https://api.openai.com/v1/chat/completions', {\n      body: JSON.stringify({\n        max_tokens: options.maxTokens || 4000,\n        messages: [\n          {content: 'You are a helpful assistant that fixes ESLint errors in code.', role: 'system'},\n          {content: prompt, role: 'user'}\n        ],\n        model: options.model || 'gpt-4o',\n        temperature: options.temperature || 0.1\n      }),\n      headers: {\n        Authorization: `Bearer ${apiKey}`,\n        'Content-Type': 'application/json'\n      },\n      method: 'POST'\n    });\n\n    if(!response.ok) {\n      const error = await response.json();\n      throw new Error(`OpenAI API error: ${error.error?.message || response.statusText}`);\n    }\n\n    const data = await response.json();\n    return data.choices[0].message.content;\n  } catch(error) {\n    throw new Error(`OpenAI AI error: ${error.message}`);\n  }\n};\n\nexport const callAnthropicAI = async (prompt: string, options: AIConfig): Promise<string> => {\n  try {\n    const apiKey = options.apiKey || process.env.ANTHROPIC_API_KEY;\n    if(!apiKey) {\n      throw new Error('Anthropic API key is required. Set it in your lex.config file or as ANTHROPIC_API_KEY environment variable.');\n    }\n\n    const response = await fetch('https://api.anthropic.com/v1/messages', {\n      body: JSON.stringify({\n        max_tokens: options.maxTokens || 4000,\n        messages: [\n          {content: prompt, role: 'user'}\n        ],\n        model: options.model || 'claude-3-sonnet-20240229',\n        temperature: options.temperature || 0.1\n      }),\n      headers: {\n        'Content-Type': 'application/json',\n        'anthropic-version': '2023-06-01',\n        'x-api-key': apiKey\n      },\n      method: 'POST'\n    });\n\n    if(!response.ok) {\n      const error = await response.json();\n      throw new Error(`Anthropic API error: ${error.error?.message || response.statusText}`);\n    }\n\n    const data = await response.json();\n    return data.content[0].text;\n  } catch(error) {\n    throw new Error(`Anthropic AI error: ${error.message}`);\n  }\n};\n\nexport const callCopilotAI = async (prompt: string, options: AIConfig): Promise<string> => {\n  try {\n    log('GitHub Copilot AI fixes not directly supported. Using manual fix mode.', 'info');\n    return prompt;\n  } catch(error) {\n    throw new Error(`GitHub Copilot AI error: ${error.message}`);\n  }\n};\n\nexport const promptForAIProvider = async (quiet = false): Promise<'cursor' | 'copilot' | 'openai' | 'anthropic' | 'none'> => {\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout\n  });\n\n  return new Promise((resolve) => {\n    log('\\nNo AI provider configured. Please choose an AI provider:', 'info');\n    log('1. Cursor IDE', 'info');\n    log('2. OpenAI', 'info');\n    log('3. Anthropic', 'info');\n    log('4. GitHub Copilot', 'info');\n    log('5. None (Skip AI features)', 'info');\n\n    rl.question('Enter your choice (1-5): ', (answer) => {\n      rl.close();\n\n      switch(answer) {\n        case '1':\n          resolve('cursor');\n          break;\n        case '2':\n          resolve('openai');\n          break;\n        case '3':\n          resolve('anthropic');\n          break;\n        case '4':\n          resolve('copilot');\n          break;\n        default:\n          resolve('none');\n      }\n    });\n  });\n};\n\nexport const promptForAPIKey = async (provider: string, quiet = false): Promise<string> => {\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout\n  });\n\n  return new Promise((resolve) => {\n    rl.question(`Please enter your ${provider} API key: `, (answer) => {\n      rl.close();\n      resolve(answer);\n    });\n  });\n};\n\nexport const getAIService = (provider: string, options: AIConfig): (prompt: string, options: AIConfig) => Promise<string> => {\n  switch(provider) {\n    case 'cursor':\n      return callCursorAI;\n    case 'openai':\n      return callOpenAIAI;\n    case 'anthropic':\n      return callAnthropicAI;\n    case 'copilot':\n      return callCopilotAI;\n    default:\n      return async () => 'No AI provider configured';\n  }\n};\n\nexport const callAIService = async (prompt: string, quiet = false): Promise<string> => {\n  const spinner = createSpinner(quiet);\n  spinner.start('Calling AI service to fix code issues...');\n\n  try {\n    const aiConfig = LexConfig.config.ai || {provider: 'none'};\n\n    const isInCursorIDE = process.env.CURSOR_IDE === 'true';\n    if(isInCursorIDE && (aiConfig.provider === 'none' || !aiConfig.provider)) {\n      log('Detected Cursor IDE environment, using Cursor as AI provider', 'info', quiet);\n      aiConfig.provider = 'cursor';\n    }\n\n    if(aiConfig.provider === 'none') {\n      const provider = await promptForAIProvider(quiet);\n\n      if(provider === 'none') {\n        spinner.fail('AI features skipped');\n        return '';\n      }\n\n      aiConfig.provider = provider;\n\n      if(provider !== 'cursor' && provider !== 'copilot' &&\n         !process.env[`${provider.toUpperCase()}_API_KEY`]) {\n        aiConfig.apiKey = await promptForAPIKey(provider, quiet);\n      }\n\n      LexConfig.config.ai = aiConfig;\n\n      // Search for config files in multiple formats like LexConfig.parseConfig does\n      const configFormats = ['js', 'mjs', 'cjs', 'ts', 'json'];\n      const configBaseName = 'lex.config';\n      let configPath = '';\n\n      for(const format of configFormats) {\n        const potentialPath = pathResolve(process.cwd(), `./${configBaseName}.${format}`);\n        if(existsSync(potentialPath)) {\n          configPath = potentialPath;\n          break;\n        }\n      }\n\n      if(configPath) {\n        try {\n          const configContent = readFileSync(configPath, 'utf8');\n          const updatedConfig = configContent.replace(\n            /ai:.*?[,}]/s,\n            `ai: { provider: '${aiConfig.provider}' },`\n          );\n          writeFileSync(configPath, updatedConfig);\n        } catch(_error) {\n        }\n      }\n    }\n\n    let result = '';\n\n    switch(aiConfig.provider) {\n      case 'cursor':\n        result = await callCursorAI(prompt, aiConfig);\n        log('Cursor IDE AI integration active', 'info', quiet);\n        break;\n      case 'openai':\n        result = await callOpenAIAI(prompt, aiConfig);\n        break;\n      case 'anthropic':\n        result = await callAnthropicAI(prompt, aiConfig);\n        break;\n      case 'copilot':\n        result = await callCopilotAI(prompt, aiConfig);\n        break;\n      default:\n        spinner.fail('No AI provider configured');\n        return '';\n    }\n\n    spinner.succeed('AI code fixes generated successfully');\n    return result;\n  } catch(error) {\n    spinner.fail(`AI service error: ${error.message}`);\n    if(!quiet) {\n      log(error, 'error');\n    }\n    return '';\n  }\n};"],
  "mappings": "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",
  "names": []
}


package/dist/utils/app.d.ts

@@ -0,0 +1,41 @@
+import type { LexConfigType } from '../LexConfig.js';
+export declare const cwd: string;
+export interface GetFilenamesProps {
+    readonly callback?: (status: number) => void;
+    readonly cliName?: string;
+    readonly name?: string;
+    readonly quiet?: boolean;
+    readonly type?: string;
+    readonly useTypescript?: boolean;
+}
+interface FilenamesResult {
+    nameCaps: string;
+    templateExt: string;
+    templatePath: string;
+    templateReact: string;
+}
+export declare const getFilenames: (props: GetFilenamesProps) => FilenamesResult | void;
+export interface Spinner {
+    fail: (text?: string) => void;
+    start: (text?: string) => void;
+    succeed: (text?: string) => void;
+}
+export declare const createSpinner: (quiet?: boolean) => Spinner;
+export declare const copyFiles: (files: string[], typeName: string, spinner: any, config: LexConfigType) => Promise<void>;
+export declare const copyConfiguredFiles: (spinner: any, config: LexConfigType, quiet: boolean) => Promise<void>;
+export declare const copyFileSync: (source: string, target: string) => void;
+export declare const copyFolderRecursiveSync: (source: string, target: string) => void;
+export declare const getPackageJson: (packagePath?: string) => any;
+export declare const getFilesByExt: (ext: string, config: LexConfigType) => string[];
+export declare const removeConflictModules: (moduleList: object) => object;
+export declare const removeFiles: (fileName: string, isRelative?: boolean) => Promise<unknown>;
+export declare const removeModules: () => Promise<unknown>;
+export declare const setPackageJson: (json: any, packagePath?: string) => void;
+export interface LinkedModuleType {
+    readonly name: string;
+    readonly path: string;
+}
+export declare const linkedModules: (startPath?: string) => LinkedModuleType[];
+export declare const checkLinkedModules: () => void;
+export declare const updateTemplateName: (filePath: string, replace: string, replaceCaps: string) => void;
+export {};

package/dist/utils/app.js

@@ -77,7 +77,56 @@ const copyFiles = async (files, typeName, spinner, config) => {
   } catch (error) {
     spinner.fail(`Copying of ${typeName} files failed.`);
     log(`Error: ${error.message}`, "error");
-    console.log(error);
+    log(error, "error");
+  }
+};
+const copyConfiguredFiles = async (spinner, config, quiet) => {
+  const { copyFiles: copyFilesConfig, outputFullPath, sourceFullPath, sourcePath } = config;
+  if (!copyFilesConfig || copyFilesConfig.length === 0) {
+    return;
+  }
+  try {
+    spinner.start("Copying configured files...");
+    let totalCopied = 0;
+    const baseDir = sourceFullPath || (sourcePath ? pathResolve(cwd, sourcePath) : cwd);
+    for (const pattern of copyFilesConfig) {
+      const resolvedPattern = pathResolve(baseDir, pattern);
+      const matchingFiles = globSync(resolvedPattern, {
+        nodir: true,
+        absolute: true
+      });
+      if (matchingFiles.length === 0) {
+        if (!quiet) {
+          log(`Warning: No files found matching pattern: ${pattern}`, "warn", quiet);
+        }
+        continue;
+      }
+      for (const sourceFile of matchingFiles) {
+        const relativePath = pathRelative(baseDir, sourceFile);
+        const destPath = pathResolve(outputFullPath, relativePath);
+        const destDir = pathResolve(destPath, "..");
+        mkdirSync(destDir, { recursive: true });
+        await new Promise((resolve, reject) => {
+          copyFile(sourceFile, destPath, (copyError) => {
+            if (copyError) {
+              reject(copyError);
+            } else {
+              resolve(true);
+            }
+          });
+        });
+        totalCopied++;
+      }
+    }
+    if (totalCopied > 0) {
+      spinner.succeed(`Successfully copied ${totalCopied} configured files!`);
+    } else {
+      spinner.succeed("No configured files to copy");
+    }
+  } catch (error) {
+    spinner.fail("Failed to copy configured files");
+    log(`Error copying configured files: ${error.message}`, "error", quiet);
+    throw error;
   }
 };
 const copyFileSync = (source, target) => {
@@ -119,7 +168,7 @@ const getFilesByExt = (ext, config) => {
 const removeConflictModules = (moduleList) => {
   const updatedList = { ...moduleList };
   Object.keys(updatedList).forEach((moduleName) => {
-    const regex = new RegExp("^(?!@types/).*(jest|webpack).*$", "gi");
+    const regex = new RegExp("^(?!@types/).*?(jest|webpack).*$", "gi");
     if (regex.test(moduleName)) {
       delete updatedList[moduleName];
     }
@@ -199,6 +248,7 @@ const updateTemplateName = (filePath, replace, replaceCaps) => {
 };
 export {
   checkLinkedModules,
+  copyConfiguredFiles,
   copyFileSync,
   copyFiles,
   copyFolderRecursiveSync,
@@ -214,4 +264,4 @@ export {
   setPackageJson,
   updateTemplateName
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/utils/app.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 boxen from 'boxen';\nimport {copyFile, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, writeFileSync} from 'fs';\nimport {globSync} from 'glob';\nimport isEmpty from 'lodash/isEmpty.js';\nimport ora from 'ora';\nimport {basename as pathBasename, join as pathJoin, relative as pathRelative, resolve as pathResolve} from 'path';\nimport {rimrafSync} from 'rimraf';\n\nimport {log} from './log.js';\n\nimport type {LexConfigType} from '../LexConfig.js';\n\nexport const cwd: string = process.cwd();\n\nexport interface GetFilenamesProps {\n  readonly callback?: (status: number) => void;\n  readonly cliName?: string;\n  readonly name?: string;\n  readonly quiet?: boolean;\n  readonly type?: string;\n  readonly useTypescript?: boolean;\n}\n\ninterface FilenamesResult {\n  nameCaps: string;\n  templateExt: string;\n  templatePath: string;\n  templateReact: string;\n}\n\nexport const getFilenames = (props: GetFilenamesProps): FilenamesResult | void => {\n  const {callback, cliName, name, quiet, type, useTypescript} = props;\n\n  // Set filename\n  let nameCaps: string;\n  const itemTypes: string[] = ['stores', 'views'];\n\n  if(!name) {\n    if(itemTypes.includes(type)) {\n      log(`\\n${cliName} Error: ${type} name is required. Please use 'lex -h' for options.`, 'error', quiet);\n      return callback?.(1);\n    }\n  } else {\n    nameCaps = `${name.charAt(0).toUpperCase()}${name.substr(1)}`;\n  }\n\n  // Display message\n  log(`${cliName} adding ${name} ${type}...`, 'info', quiet);\n\n  // Template directory\n  let templatePath: string;\n  let templateExt: string;\n  let templateReact: string;\n\n  if(useTypescript) {\n    templatePath = '../../templates/typescript';\n    templateExt = '.ts';\n    templateReact = '.tsx';\n  } else {\n    templatePath = '../../templates/flow';\n    templateExt = '.js';\n    templateReact = '.js';\n  }\n\n  return {\n    nameCaps,\n    templateExt,\n    templatePath,\n    templateReact\n  };\n};\n\nexport interface Spinner {\n  fail: (text?: string) => void;\n  start: (text?: string) => void;\n  succeed: (text?: string) => void;\n}\n\nexport const createSpinner = (quiet = false): Spinner => {\n  if(quiet) {\n    return {\n      fail: () => {},\n      start: () => {},\n      succeed: () => {}\n    };\n  }\n\n  return ora({color: 'yellow'});\n};\n\nexport const copyFiles = async (files: string[], typeName: string, spinner, config: LexConfigType) => {\n  const {outputFullPath, sourceFullPath} = config;\n  const items = files.map((fileName: string) => ({\n    from: fileName,\n    to: pathResolve(outputFullPath, pathRelative(sourceFullPath, fileName))\n  }));\n\n  try {\n    spinner.start(`Copying ${typeName} files...`);\n    await Promise.all(items.map(({from, to}) => new Promise(\n      (resolve, reject) => {\n        mkdirSync(pathResolve(to, '..'), {recursive: true});\n        return copyFile(from, to, (copyError) => {\n          if(copyError) {\n            reject();\n          } else {\n            resolve(true);\n          }\n        });\n      }\n    )));\n    spinner.succeed(`Successfully copied ${files.length} ${typeName} files!`);\n  } catch(error) {\n    // Stop spinner\n    spinner.fail(`Copying of ${typeName} files failed.`);\n    log(`Error: ${error.message}`, 'error');\n    console.log(error);\n  }\n};\n\nexport const copyFileSync = (source: string, target: string) => {\n  let targetFile: string = target;\n\n  // If target is a directory a new file with the same name will be created\n  if(existsSync(target)) {\n    if(lstatSync(target).isDirectory()) {\n      targetFile = pathJoin(target, pathBasename(source));\n    }\n  }\n\n  writeFileSync(targetFile, readFileSync(source));\n};\n\nexport const copyFolderRecursiveSync = (source: string, target: string): void => {\n  let files: string[] = [];\n\n  // Check if folder needs to be created or integrated\n  const targetFolder: string = pathJoin(target, pathBasename(source));\n\n  if(!existsSync(targetFolder)) {\n    mkdirSync(targetFolder);\n  }\n\n  // Copy\n  if(lstatSync(source).isDirectory()) {\n    files = readdirSync(source);\n    files.forEach((file: string) => {\n      const curSource: string = pathJoin(source, file);\n\n      if(lstatSync(curSource).isDirectory()) {\n        copyFolderRecursiveSync(curSource, targetFolder);\n      } else {\n        copyFileSync(curSource, targetFolder);\n      }\n    });\n  }\n};\n\nexport const getPackageJson = (packagePath?: string) => {\n  const formatPath: string = packagePath || `${process.cwd()}/package.json`;\n\n  // Configure package.json\n  const packageData: string = readFileSync(formatPath).toString();\n  return JSON.parse(packageData);\n};\n\nexport const getFilesByExt = (ext: string, config: LexConfigType): string[] => {\n  const {sourceFullPath} = config;\n  return globSync(`${sourceFullPath}/**/**${ext}`);\n};\n\nexport const removeConflictModules = (moduleList: object) => {\n  const updatedList: object = {...moduleList};\n\n  Object.keys(updatedList).forEach((moduleName: string) => {\n    const regex: RegExp = new RegExp('^(?!@types\\/).*(jest|webpack).*$', 'gi');\n    if(regex.test(moduleName)) {\n      delete updatedList[moduleName];\n    }\n  });\n\n  return updatedList;\n};\n\nexport const removeFiles = (fileName: string, isRelative: boolean = false) => new Promise((resolve, reject) => {\n  const filePath: string = isRelative ? pathResolve(cwd, fileName) : fileName;\n  try {\n    rimrafSync(filePath);\n    return resolve(null);\n  } catch(error) {\n    return reject(error);\n  }\n});\n\nexport const removeModules = () => new Promise(async (resolve, reject) => {\n  try {\n    // Remove node_modules\n    await removeFiles('./node_modules', true);\n\n    // Remove yarn lock\n    await removeFiles('./yarn.lock', true);\n\n    // Remove npm lock\n    await removeFiles('./package-lock.json', true);\n\n    resolve(null);\n  } catch(error) {\n    reject(error);\n  }\n});\n\nexport const setPackageJson = (json, packagePath?: string) => {\n  if(!json) {\n    return;\n  }\n\n  const formatPath: string = packagePath || `${process.cwd()}/package.json`;\n\n  // Update package.json\n  writeFileSync(formatPath, JSON.stringify(json, null, 2));\n};\n\nexport interface LinkedModuleType {\n  readonly name: string;\n  readonly path: string;\n}\n\nexport const linkedModules = (startPath?: string): LinkedModuleType[] => {\n  const workingPath: string = startPath || process.cwd();\n  let modulePath: string;\n  let prefix: string;\n\n  // if we have a scope we should check if the modules inside the folder is linked\n  if(workingPath.includes('@')) {\n    prefix = `@${workingPath.split('@').pop()}`;\n    modulePath = workingPath;\n  } else {\n    modulePath = pathJoin(workingPath, 'node_modules');\n  }\n\n  const foundPaths: string[] = globSync(`${modulePath}/*`);\n  return foundPaths.reduce((list: LinkedModuleType[], foundPath: string) => {\n    try {\n      const stats = lstatSync(foundPath);\n\n      if(stats.isDirectory()) {\n        const deepList: LinkedModuleType[] = linkedModules(foundPath);\n        list.push(...deepList);\n      } else if(stats.isSymbolicLink()) {\n        const moduleNames: string[] = ([prefix, pathBasename(foundPath)]).filter((item: string) => !isEmpty(item));\n        list.push({name: `${moduleNames.join('/')}`, path: foundPath});\n      }\n\n      return list;\n    } catch(fsError) {\n      throw fsError;\n    }\n  }, []);\n};\n\n// Check for linked modules\nexport const checkLinkedModules = () => {\n  const linked = linkedModules();\n\n  if(linked.length) {\n    const msgModule: string = linked.length > 1 ? 'Modules' : 'Module';\n    const linkedMsg: string = linked.reduce(\n      (msg: string, linkedModule: LinkedModuleType) =>\n        `${msg}\\n * ${linkedModule.name}`,\n      `Linked ${msgModule}:`\n    );\n    log(boxen(linkedMsg, {dimBorder: true, padding: 1}), 'warn');\n  }\n};\n\nexport const updateTemplateName = (filePath: string, replace: string, replaceCaps: string) => {\n  let data: string = readFileSync(filePath, 'utf8');\n  data = data.replace(/sample/g, replace);\n  data = data.replace(/Sample/g, replaceCaps);\n  writeFileSync(filePath, data, 'utf8');\n};\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/utils/app.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 boxen from 'boxen';\nimport {copyFile, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, writeFileSync} from 'fs';\nimport {globSync} from 'glob';\nimport isEmpty from 'lodash/isEmpty.js';\nimport ora from 'ora';\nimport {basename as pathBasename, join as pathJoin, relative as pathRelative, resolve as pathResolve} from 'path';\nimport {rimrafSync} from 'rimraf';\n\nimport {log} from './log.js';\n\nimport type {LexConfigType} from '../LexConfig.js';\n\nexport const cwd: string = process.cwd();\n\nexport interface GetFilenamesProps {\n  readonly callback?: (status: number) => void;\n  readonly cliName?: string;\n  readonly name?: string;\n  readonly quiet?: boolean;\n  readonly type?: string;\n  readonly useTypescript?: boolean;\n}\n\ninterface FilenamesResult {\n  nameCaps: string;\n  templateExt: string;\n  templatePath: string;\n  templateReact: string;\n}\n\nexport const getFilenames = (props: GetFilenamesProps): FilenamesResult | void => {\n  const {callback, cliName, name, quiet, type, useTypescript} = props;\n\n  let nameCaps: string;\n  const itemTypes: string[] = ['stores', 'views'];\n\n  if(!name) {\n    if(itemTypes.includes(type)) {\n      log(`\\n${cliName} Error: ${type} name is required. Please use 'lex -h' for options.`, 'error', quiet);\n      return callback?.(1);\n    }\n  } else {\n    nameCaps = `${name.charAt(0).toUpperCase()}${name.substr(1)}`;\n  }\n\n  log(`${cliName} adding ${name} ${type}...`, 'info', quiet);\n\n  let templatePath: string;\n  let templateExt: string;\n  let templateReact: string;\n\n  if(useTypescript) {\n    templatePath = '../../templates/typescript';\n    templateExt = '.ts';\n    templateReact = '.tsx';\n  } else {\n    templatePath = '../../templates/flow';\n    templateExt = '.js';\n    templateReact = '.js';\n  }\n\n  return {\n    nameCaps,\n    templateExt,\n    templatePath,\n    templateReact\n  };\n};\n\nexport interface Spinner {\n  fail: (text?: string) => void;\n  start: (text?: string) => void;\n  succeed: (text?: string) => void;\n}\n\nexport const createSpinner = (quiet = false): Spinner => {\n  if(quiet) {\n    return {\n      fail: () => {},\n      start: () => {},\n      succeed: () => {}\n    };\n  }\n\n  return ora({color: 'yellow'});\n};\n\nexport const copyFiles = async (files: string[], typeName: string, spinner, config: LexConfigType) => {\n  const {outputFullPath, sourceFullPath} = config;\n  const items = files.map((fileName: string) => ({\n    from: fileName,\n    to: pathResolve(outputFullPath, pathRelative(sourceFullPath, fileName))\n  }));\n\n  try {\n    spinner.start(`Copying ${typeName} files...`);\n    await Promise.all(items.map(({from, to}) => new Promise(\n      (resolve, reject) => {\n        mkdirSync(pathResolve(to, '..'), {recursive: true});\n        return copyFile(from, to, (copyError) => {\n          if(copyError) {\n            reject();\n          } else {\n            resolve(true);\n          }\n        });\n      }\n    )));\n    spinner.succeed(`Successfully copied ${files.length} ${typeName} files!`);\n  } catch(error) {\n    spinner.fail(`Copying of ${typeName} files failed.`);\n    log(`Error: ${error.message}`, 'error');\n    log(error, 'error');\n  }\n};\n\nexport const copyConfiguredFiles = async (spinner, config: LexConfigType, quiet: boolean) => {\n  const {copyFiles: copyFilesConfig, outputFullPath, sourceFullPath, sourcePath} = config;\n  if (!copyFilesConfig || copyFilesConfig.length === 0) {\n    return;\n  }\n\n  try {\n    spinner.start('Copying configured files...');\n    let totalCopied = 0;\n\n    const baseDir = sourceFullPath || (sourcePath ? pathResolve(cwd, sourcePath) : cwd);\n\n    for (const pattern of copyFilesConfig) {\n      const resolvedPattern = pathResolve(baseDir, pattern);\n      const matchingFiles = globSync(resolvedPattern, {\n        nodir: true,\n        absolute: true\n      });\n      if (matchingFiles.length === 0) {\n        if (!quiet) {\n          log(`Warning: No files found matching pattern: ${pattern}`, 'warn', quiet);\n        }\n        continue;\n      }\n\n      for (const sourceFile of matchingFiles) {\n        // Calculate relative path from source directory\n        const relativePath = pathRelative(baseDir, sourceFile);\n        // Determine destination path in output directory\n        const destPath = pathResolve(outputFullPath, relativePath);\n        // Create destination directory if it doesn't exist\n        const destDir = pathResolve(destPath, '..');\n        mkdirSync(destDir, {recursive: true});\n\n        await new Promise((resolve, reject) => {\n          copyFile(sourceFile, destPath, (copyError) => {\n            if (copyError) {\n              reject(copyError);\n            } else {\n              resolve(true);\n            }\n          });\n        });\n        totalCopied++;\n      }\n    }\n    if (totalCopied > 0) {\n      spinner.succeed(`Successfully copied ${totalCopied} configured files!`);\n    } else {\n      spinner.succeed('No configured files to copy');\n    }\n  } catch (error) {\n    spinner.fail('Failed to copy configured files');\n    log(`Error copying configured files: ${error.message}`, 'error', quiet);\n    throw error;\n  }\n};\n\nexport const copyFileSync = (source: string, target: string) => {\n  let targetFile: string = target;\n\n  if(existsSync(target)) {\n    if(lstatSync(target).isDirectory()) {\n      targetFile = pathJoin(target, pathBasename(source));\n    }\n  }\n\n  writeFileSync(targetFile, readFileSync(source));\n};\n\nexport const copyFolderRecursiveSync = (source: string, target: string): void => {\n  let files: string[] = [];\n\n  const targetFolder: string = pathJoin(target, pathBasename(source));\n\n  if(!existsSync(targetFolder)) {\n    mkdirSync(targetFolder);\n  }\n\n  if(lstatSync(source).isDirectory()) {\n    files = readdirSync(source);\n    files.forEach((file: string) => {\n      const curSource: string = pathJoin(source, file);\n\n      if(lstatSync(curSource).isDirectory()) {\n        copyFolderRecursiveSync(curSource, targetFolder);\n      } else {\n        copyFileSync(curSource, targetFolder);\n      }\n    });\n  }\n};\n\nexport const getPackageJson = (packagePath?: string) => {\n  const formatPath: string = packagePath || `${process.cwd()}/package.json`;\n\n  const packageData: string = readFileSync(formatPath).toString();\n  return JSON.parse(packageData);\n};\n\nexport const getFilesByExt = (ext: string, config: LexConfigType): string[] => {\n  const {sourceFullPath} = config;\n  return globSync(`${sourceFullPath}/**/**${ext}`);\n};\n\nexport const removeConflictModules = (moduleList: object) => {\n  const updatedList: object = {...moduleList};\n\n  Object.keys(updatedList).forEach((moduleName: string) => {\n    const regex: RegExp = new RegExp('^(?!@types/).*?(jest|webpack).*$', 'gi');\n    if(regex.test(moduleName)) {\n      delete updatedList[moduleName];\n    }\n  });\n\n  return updatedList;\n};\n\nexport const removeFiles = (fileName: string, isRelative: boolean = false) => new Promise((resolve, reject) => {\n  const filePath: string = isRelative ? pathResolve(cwd, fileName) : fileName;\n  try {\n    rimrafSync(filePath);\n    return resolve(null);\n  } catch(error) {\n    return reject(error);\n  }\n});\n\nexport const removeModules = () => new Promise(async (resolve, reject) => {\n  try {\n    // Remove node_modules\n    await removeFiles('./node_modules', true);\n\n    // Remove yarn lock\n    await removeFiles('./yarn.lock', true);\n\n    // Remove npm lock\n    await removeFiles('./package-lock.json', true);\n\n    resolve(null);\n  } catch(error) {\n    reject(error);\n  }\n});\n\nexport const setPackageJson = (json, packagePath?: string) => {\n  if(!json) {\n    return;\n  }\n\n  const formatPath: string = packagePath || `${process.cwd()}/package.json`;\n\n  writeFileSync(formatPath, JSON.stringify(json, null, 2));\n};\n\nexport interface LinkedModuleType {\n  readonly name: string;\n  readonly path: string;\n}\n\nexport const linkedModules = (startPath?: string): LinkedModuleType[] => {\n  const workingPath: string = startPath || process.cwd();\n  let modulePath: string;\n  let prefix: string;\n\n  if(workingPath.includes('@')) {\n    prefix = `@${workingPath.split('@').pop()}`;\n    modulePath = workingPath;\n  } else {\n    modulePath = pathJoin(workingPath, 'node_modules');\n  }\n\n  const foundPaths: string[] = globSync(`${modulePath}/*`);\n  return foundPaths.reduce((list: LinkedModuleType[], foundPath: string) => {\n    try {\n      const stats = lstatSync(foundPath);\n\n      if(stats.isDirectory()) {\n        const deepList: LinkedModuleType[] = linkedModules(foundPath);\n        list.push(...deepList);\n      } else if(stats.isSymbolicLink()) {\n        const moduleNames: string[] = ([prefix, pathBasename(foundPath)]).filter((item: string) => !isEmpty(item));\n        list.push({name: `${moduleNames.join('/')}`, path: foundPath});\n      }\n\n      return list;\n    } catch(fsError) {\n      throw fsError;\n    }\n  }, []);\n};\n\nexport const checkLinkedModules = () => {\n  const linked = linkedModules();\n\n  if(linked.length) {\n    const msgModule: string = linked.length > 1 ? 'Modules' : 'Module';\n    const linkedMsg: string = linked.reduce(\n      (msg: string, linkedModule: LinkedModuleType) =>\n        `${msg}\\n * ${linkedModule.name}`,\n      `Linked ${msgModule}:`\n    );\n    log(boxen(linkedMsg, {dimBorder: true, padding: 1}), 'warn');\n  }\n};\n\nexport const updateTemplateName = (filePath: string, replace: string, replaceCaps: string) => {\n  let data: string = readFileSync(filePath, 'utf8');\n  data = data.replace(/sample/g, replace);\n  data = data.replace(/Sample/g, replaceCaps);\n  writeFileSync(filePath, data, 'utf8');\n};"],
  "mappings": "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",
  "names": []
}


package/dist/utils/file.d.ts

@@ -0,0 +1,3 @@
+export declare const relativeFilePath: (filename: string, dirPath?: string, backUp?: number) => string;
+export declare const relativeNodePath: (filename: string, dirPath?: string, backUp?: number) => string;
+export declare const getNodePath: (moduleName: string) => string;

package/dist/utils/file.js

@@ -13,16 +13,31 @@ const relativeFilePath = (filename, dirPath = "./", backUp = 0) => {
 };
 const relativeNodePath = (filename, dirPath = "./", backUp = 0) => {
   const nestDepth = 10;
+  const modulePath = `node_modules/${filename}`;
+  if (dirPath !== "./") {
+    const lexModulePath = pathResolve(dirPath, modulePath);
+    if (existsSync(lexModulePath)) {
+      return lexModulePath;
+    }
+  }
+  const projectPath = pathResolve(process.cwd(), modulePath);
+  if (existsSync(projectPath)) {
+    return projectPath;
+  }
   if (backUp) {
-    const filePath = findFileUp.sync(`node_modules/${filename}`, dirPath, nestDepth);
+    const filePath = findFileUp.sync(modulePath, dirPath, nestDepth);
     const previousPath = Array(nestDepth).fill(null).map(() => "../").join("");
     return pathResolve(filePath, previousPath);
   }
-  return findFileUp.sync(`node_modules/${filename}`, dirPath, nestDepth);
+  return findFileUp.sync(modulePath, dirPath, nestDepth) || `/node_modules/${filename}`;
 };
 const getNodePath = (moduleName) => {
   const dirName = new URL(".", import.meta.url).pathname;
   const modulePath = `node_modules/${moduleName}`;
+  const projectPath = pathResolve(process.cwd(), modulePath);
+  if (existsSync(projectPath)) {
+    return projectPath;
+  }
   const repoPath = findFileUp.sync(modulePath, dirName);
   if (repoPath && existsSync(repoPath)) {
     return repoPath;
@@ -35,4 +50,4 @@ export {
   relativeFilePath,
   relativeNodePath
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/log.d.ts

@@ -0,0 +1 @@
+export declare const log: (message: string, type?: string, quiet?: boolean) => void;

package/dist/utils/log.js

@@ -13,6 +13,7 @@ const log = (message, type = "info", quiet = false) => {
         color = chalk.greenBright;
         break;
       case "warn":
+      case "warning":
         color = chalk.yellow;
         break;
       default:
@@ -25,4 +26,4 @@ const log = (message, type = "info", quiet = false) => {
 export {
   log
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL3V0aWxzL2xvZy50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBDb3B5cmlnaHQgKGMpIDIwMjItUHJlc2VudCwgTml0cm9nZW4gTGFicywgSW5jLlxuICogQ29weXJpZ2h0cyBsaWNlbnNlZCB1bmRlciB0aGUgTUlUIExpY2Vuc2UuIFNlZSB0aGUgYWNjb21wYW55aW5nIExJQ0VOU0UgZmlsZSBmb3IgdGVybXMuXG4gKi9cbmltcG9ydCBjaGFsayBmcm9tICdjaGFsayc7XG5cbmV4cG9ydCBjb25zdCBsb2cgPSAobWVzc2FnZTogc3RyaW5nLCB0eXBlOiBzdHJpbmcgPSAnaW5mbycsIHF1aWV0ID0gZmFsc2UpID0+IHtcbiAgaWYoIXF1aWV0KSB7XG4gICAgbGV0IGNvbG9yO1xuXG4gICAgc3dpdGNoKHR5cGUpIHtcbiAgICAgIGNhc2UgJ2Vycm9yJzpcbiAgICAgICAgY29sb3IgPSBjaGFsay5yZWQ7XG4gICAgICAgIGJyZWFrO1xuICAgICAgY2FzZSAnbm90ZSc6XG4gICAgICAgIGNvbG9yID0gY2hhbGsuZ3JleTtcbiAgICAgICAgYnJlYWs7XG4gICAgICBjYXNlICdzdWNjZXNzJzpcbiAgICAgICAgY29sb3IgPSBjaGFsay5ncmVlbkJyaWdodDtcbiAgICAgICAgYnJlYWs7XG4gICAgICBjYXNlICd3YXJuJzpcbiAgICAgICAgY29sb3IgPSBjaGFsay55ZWxsb3c7XG4gICAgICAgIGJyZWFrO1xuICAgICAgZGVmYXVsdDpcbiAgICAgICAgY29sb3IgPSBjaGFsay5jeWFuO1xuICAgICAgICBicmVhaztcbiAgICB9XG5cbiAgICBjb25zb2xlLmxvZyhjb2xvcihtZXNzYWdlKSk7XG4gIH1cbn07XG4iXSwKICAibWFwcGluZ3MiOiAiQUFJQSxPQUFPLFdBQVc7QUFFWCxNQUFNLE1BQU0sQ0FBQyxTQUFpQixPQUFlLFFBQVEsUUFBUSxVQUFVO0FBQzVFLE1BQUcsQ0FBQyxPQUFPO0FBQ1QsUUFBSTtBQUVKLFlBQU8sTUFBTTtBQUFBLE1BQ1gsS0FBSztBQUNILGdCQUFRLE1BQU07QUFDZDtBQUFBLE1BQ0YsS0FBSztBQUNILGdCQUFRLE1BQU07QUFDZDtBQUFBLE1BQ0YsS0FBSztBQUNILGdCQUFRLE1BQU07QUFDZDtBQUFBLE1BQ0YsS0FBSztBQUNILGdCQUFRLE1BQU07QUFDZDtBQUFBLE1BQ0Y7QUFDRSxnQkFBUSxNQUFNO0FBQ2Q7QUFBQSxJQUNKO0FBRUEsWUFBUSxJQUFJLE1BQU0sT0FBTyxDQUFDO0FBQUEsRUFDNUI7QUFDRjsiLAogICJuYW1lcyI6IFtdCn0K
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL3V0aWxzL2xvZy50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBDb3B5cmlnaHQgKGMpIDIwMjItUHJlc2VudCwgTml0cm9nZW4gTGFicywgSW5jLlxuICogQ29weXJpZ2h0cyBsaWNlbnNlZCB1bmRlciB0aGUgTUlUIExpY2Vuc2UuIFNlZSB0aGUgYWNjb21wYW55aW5nIExJQ0VOU0UgZmlsZSBmb3IgdGVybXMuXG4gKi9cbmltcG9ydCBjaGFsayBmcm9tICdjaGFsayc7XG5cbmV4cG9ydCBjb25zdCBsb2cgPSAobWVzc2FnZTogc3RyaW5nLCB0eXBlOiBzdHJpbmcgPSAnaW5mbycsIHF1aWV0ID0gZmFsc2UpID0+IHtcbiAgaWYoIXF1aWV0KSB7XG4gICAgbGV0IGNvbG9yO1xuXG4gICAgc3dpdGNoKHR5cGUpIHtcbiAgICAgIGNhc2UgJ2Vycm9yJzpcbiAgICAgICAgY29sb3IgPSBjaGFsay5yZWQ7XG4gICAgICAgIGJyZWFrO1xuICAgICAgY2FzZSAnbm90ZSc6XG4gICAgICAgIGNvbG9yID0gY2hhbGsuZ3JleTtcbiAgICAgICAgYnJlYWs7XG4gICAgICBjYXNlICdzdWNjZXNzJzpcbiAgICAgICAgY29sb3IgPSBjaGFsay5ncmVlbkJyaWdodDtcbiAgICAgICAgYnJlYWs7XG4gICAgICBjYXNlICd3YXJuJzpcbiAgICAgIGNhc2UgJ3dhcm5pbmcnOlxuICAgICAgICBjb2xvciA9IGNoYWxrLnllbGxvdztcbiAgICAgICAgYnJlYWs7XG4gICAgICBkZWZhdWx0OlxuICAgICAgICBjb2xvciA9IGNoYWxrLmN5YW47XG4gICAgICAgIGJyZWFrO1xuICAgIH1cblxuICAgIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby1jb25zb2xlXG4gICAgY29uc29sZS5sb2coY29sb3IobWVzc2FnZSkpO1xuICB9XG59OyJdLAogICJtYXBwaW5ncyI6ICJBQUlBLE9BQU8sV0FBVztBQUVYLE1BQU0sTUFBTSxDQUFDLFNBQWlCLE9BQWUsUUFBUSxRQUFRLFVBQVU7QUFDNUUsTUFBRyxDQUFDLE9BQU87QUFDVCxRQUFJO0FBRUosWUFBTyxNQUFNO0FBQUEsTUFDWCxLQUFLO0FBQ0gsZ0JBQVEsTUFBTTtBQUNkO0FBQUEsTUFDRixLQUFLO0FBQ0gsZ0JBQVEsTUFBTTtBQUNkO0FBQUEsTUFDRixLQUFLO0FBQ0gsZ0JBQVEsTUFBTTtBQUNkO0FBQUEsTUFDRixLQUFLO0FBQUEsTUFDTCxLQUFLO0FBQ0gsZ0JBQVEsTUFBTTtBQUNkO0FBQUEsTUFDRjtBQUNFLGdCQUFRLE1BQU07QUFDZDtBQUFBLElBQ0o7QUFHQSxZQUFRLElBQUksTUFBTSxPQUFPLENBQUM7QUFBQSxFQUM1QjtBQUNGOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/utils/reactShim.d.ts

@@ -0,0 +1,2 @@
+import * as react from 'react';
+export { react };

package/dist/utils/reactShim.js

@@ -1,5 +1,5 @@
-import React from "react";
+import * as react from "react";
 export {
-  React
+  react
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL3V0aWxzL3JlYWN0U2hpbS50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0JztcblxuZXhwb3J0IHtSZWFjdH07XG4iXSwKICAibWFwcGluZ3MiOiAiQUFBQSxPQUFPLFdBQVc7IiwKICAibmFtZXMiOiBbXQp9Cg==
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL3V0aWxzL3JlYWN0U2hpbS50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiaW1wb3J0ICogYXMgcmVhY3QgZnJvbSAncmVhY3QnO1xuXG5leHBvcnQge3JlYWN0fTsiXSwKICAibWFwcGluZ3MiOiAiQUFBQSxZQUFZLFdBQVc7IiwKICAibmFtZXMiOiBbXQp9Cg==