@nlabs/lex 1.49.5 → 1.50.1

package/lib/commands/config/config.js

@@ -1,43 +1,47 @@
-import { writeFileSync } from "fs";
-import startCase from "lodash/startCase.js";
-import { relative as pathRelative } from "path";
-import { LexConfig } from "../../LexConfig.js";
-import { createSpinner } from "../../utils/app.js";
-import { log } from "../../utils/log.js";
-const config = async (type, cmd, callback = () => ({})) => {
-  const { cliName = "Lex", json, quiet } = cmd;
-  const validTypes = ["app", "jest", "webpack"];
-  if (!validTypes.includes(type)) {
-    log(`
-${cliName} Error: Option for ${type} not found. Configurations only available for app, jest, and webpack.`, "error", quiet);
-    callback(1);
-    return Promise.resolve(1);
-  }
-  log(`${cliName} generating configuration for ${startCase(type)}...`, "info", quiet);
-  await LexConfig.parseConfig(cmd);
-  let configOptions;
-  switch (type) {
-    case "app":
-      configOptions = LexConfig.config;
-      break;
-    case "jest":
-      configOptions = import("../../../jest.config.mjs");
-      break;
-    case "webpack":
-      configOptions = import("../../../webpack.config.js");
-      break;
-  }
-  const jsonOutput = JSON.stringify(configOptions, null, 2);
-  if (json) {
-    const spinner = createSpinner(quiet);
-    spinner.start("Creating JSON output...");
-    writeFileSync(json, jsonOutput);
-    spinner.succeed(`Successfully saved JSON output to ${pathRelative(process.cwd(), json)}`);
-  }
-  callback(0);
-  return Promise.resolve(0);
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { writeFileSync } from 'fs';
+import startCase from 'lodash/startCase.js';
+import { relative as pathRelative } from 'path';
+import { LexConfig } from '../../LexConfig.js';
+import { createSpinner } from '../../utils/app.js';
+import { log } from '../../utils/log.js';
+export const config = async (type, cmd, callback = ()=>({}))=>{
+    const { cliName = 'Lex', json, quiet } = cmd;
+    const validTypes = [
+        'app',
+        'jest',
+        'webpack'
+    ];
+    if (!validTypes.includes(type)) {
+        log(`\n${cliName} Error: Option for ${type} not found. Configurations only available for app, jest, and webpack.`, 'error', quiet);
+        callback(1);
+        return Promise.resolve(1);
+    }
+    log(`${cliName} generating configuration for ${startCase(type)}...`, 'info', quiet);
+    await LexConfig.parseConfig(cmd);
+    let configOptions;
+    switch(type){
+        case 'app':
+            configOptions = LexConfig.config;
+            break;
+        case 'jest':
+            configOptions = import('../../../jest.config.mjs');
+            break;
+        case 'webpack':
+            configOptions = import('../../../webpack.config.js');
+            break;
+    }
+    const jsonOutput = JSON.stringify(configOptions, null, 2);
+    if (json) {
+        const spinner = createSpinner(quiet);
+        spinner.start('Creating JSON output...');
+        writeFileSync(json, jsonOutput);
+        spinner.succeed(`Successfully saved JSON output to ${pathRelative(process.cwd(), json)}`);
+    }
+    callback(0);
+    return Promise.resolve(0);
 };
-export {
-  config
-};
-//# sourceMappingURL=data:application/json;base64,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
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/commands/copy/copy.js

@@ -1,38 +1,39 @@
-import { existsSync, lstatSync } from "fs";
-import { copyFileSync, copyFolderRecursiveSync } from "../../utils/app.js";
-import { log } from "../../utils/log.js";
-const copy = (from, to, cmd, callback = () => ({})) => {
-  const { cliName = "Lex", quiet } = cmd;
-  log(`${cliName} copying "${to}"...`, "info", quiet);
-  if (!existsSync(from)) {
-    log(`
-${cliName} Error: Path not found, "${from}"...`, "error", quiet);
-    callback(1);
-    return Promise.resolve(1);
-  }
-  if (lstatSync(from).isDirectory()) {
-    try {
-      copyFolderRecursiveSync(from, to);
-    } catch (error) {
-      log(`
-${cliName} Error: Cannot copy "${from}". ${error.message}`, "error", quiet);
-      callback(1);
-      return Promise.resolve(1);
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { existsSync, lstatSync } from 'fs';
+import { copyFileSync, copyFolderRecursiveSync } from '../../utils/app.js';
+import { log } from '../../utils/log.js';
+export const copy = (from, to, cmd, callback = ()=>({}))=>{
+    const { cliName = 'Lex', quiet } = cmd;
+    // Display message
+    log(`${cliName} copying "${to}"...`, 'info', quiet);
+    if (!existsSync(from)) {
+        log(`\n${cliName} Error: Path not found, "${from}"...`, 'error', quiet);
+        callback(1);
+        return Promise.resolve(1);
     }
-  } else {
-    try {
-      copyFileSync(from, to);
-    } catch (error) {
-      log(`
-${cliName} Error: Cannot copy "${from}" ${error.message}`, "error", quiet);
-      callback(1);
-      return Promise.resolve(1);
+    if (lstatSync(from).isDirectory()) {
+        try {
+            // Copy directory
+            copyFolderRecursiveSync(from, to);
+        } catch (error) {
+            log(`\n${cliName} Error: Cannot copy "${from}". ${error.message}`, 'error', quiet);
+            callback(1);
+            return Promise.resolve(1);
+        }
+    } else {
+        try {
+            // Copy file
+            copyFileSync(from, to);
+        } catch (error) {
+            log(`\n${cliName} Error: Cannot copy "${from}" ${error.message}`, 'error', quiet);
+            callback(1);
+            return Promise.resolve(1);
+        }
     }
-  }
-  callback(0);
-  return Promise.resolve(0);
+    callback(0);
+    return Promise.resolve(0);
 };
-export {
-  copy
-};
-//# sourceMappingURL=data:application/json;base64,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
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/commands/create/create.js

@@ -1,124 +1,203 @@
-import { existsSync, readFileSync, renameSync, writeFileSync } from "fs";
-import { resolve as pathResolve } from "path";
-import { createChangelog } from "../../create/changelog.js";
-import { LexConfig } from "../../LexConfig.js";
-import { copyFolderRecursiveSync, getFilenames, removeFiles, updateTemplateName } from "../../utils/app.js";
-import { getDirName } from "../../utils/file.js";
-import { log } from "../../utils/log.js";
-const create = async (type, cmd, callback = () => ({})) => {
-  const { cliName = "Lex", outputFile = "", outputName = "", quiet } = cmd;
-  const cwd = process.cwd();
-  log(`${cliName} creating ${type}...`, "info", quiet);
-  await LexConfig.parseConfig(cmd, false);
-  const { outputPath = "", sourcePath = "", useTypescript } = LexConfig.config;
-  if (useTypescript) {
-    LexConfig.checkTypescriptConfig();
-  }
-  const { config } = LexConfig;
-  const dirName = getDirName();
-  switch (type) {
-    case "changelog": {
-      const statusChangelog = await createChangelog({ cliName, config, outputFile, quiet });
-      callback(statusChangelog);
-      return statusChangelog;
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { existsSync, readFileSync, renameSync, writeFileSync } from 'fs';
+import { resolve as pathResolve } from 'path';
+import { createChangelog } from '../../create/changelog.js';
+import { LexConfig } from '../../LexConfig.js';
+import { copyFolderRecursiveSync, getFilenames, removeFiles, updateTemplateName } from '../../utils/app.js';
+import { getDirName } from '../../utils/file.js';
+import { log } from '../../utils/log.js';
+export const create = async (type, cmd, callback = ()=>({}))=>{
+    const { cliName = 'Lex', outputFile = '', outputName = '', quiet } = cmd;
+    const cwd = process.cwd();
+    log(`${cliName} creating ${type}...`, 'info', quiet);
+    // Get custom configuration
+    await LexConfig.parseConfig(cmd, false);
+    const { outputPath = '', sourcePath = '', useTypescript } = LexConfig.config;
+    if (useTypescript) {
+        // Make sure tsconfig.json exists
+        LexConfig.checkTypescriptConfig();
     }
-    case "store": {
-      try {
-        const result = getFilenames({
-          cliName,
-          name: outputName,
-          quiet,
-          type,
-          useTypescript
-        });
-        if (!result) {
-          return 1;
-        }
-        const { nameCaps, templateExt, templatePath } = result;
-        const storePath = `${cwd}/${nameCaps}Store`;
-        if (!existsSync(storePath)) {
-          copyFolderRecursiveSync(pathResolve(dirName, templatePath, "./.SampleStore"), cwd);
-          renameSync(`${cwd}/.SampleStore`, storePath);
-          const storeTestPath = `${storePath}/${nameCaps}Store.test${templateExt}`;
-          renameSync(`${storePath}/SampleStore.test${templateExt}.txt`, storeTestPath);
-          updateTemplateName(storeTestPath, outputName, nameCaps);
-          const storeFilePath = `${storePath}/${nameCaps}Store${templateExt}`;
-          renameSync(`${storePath}/SampleStore${templateExt}.txt`, storeFilePath);
-          updateTemplateName(storeFilePath, outputName, nameCaps);
-        } else {
-          log(`
-${cliName} Error: Cannot create new ${type}. Directory, ${storePath} already exists.`, "error", quiet);
-          callback(1);
-          return 1;
-        }
-      } catch (error) {
-        log(`
-${cliName} Error: Cannot create new ${type}. ${error.message}`, "error", quiet);
-        callback(1);
-        return 1;
-      }
-      break;
+    const { config } = LexConfig;
+    const dirName = getDirName();
+    switch(type){
+        case 'changelog':
+            {
+                const statusChangelog = await createChangelog({
+                    cliName,
+                    config,
+                    outputFile,
+                    quiet
+                });
+                callback(statusChangelog);
+                return statusChangelog;
+            }
+        case 'store':
+            {
+                try {
+                    const result = getFilenames({
+                        cliName,
+                        name: outputName,
+                        quiet,
+                        type,
+                        useTypescript
+                    });
+                    if (!result) {
+                        return 1;
+                    }
+                    const { nameCaps, templateExt, templatePath } = result;
+                    const storePath = `${cwd}/${nameCaps}Store`;
+                    if (!existsSync(storePath)) {
+                        // Copy store files
+                        copyFolderRecursiveSync(pathResolve(dirName, templatePath, './.SampleStore'), cwd);
+                        // Rename directory
+                        renameSync(`${cwd}/.SampleStore`, storePath);
+                        // Rename test
+                        const storeTestPath = `${storePath}/${nameCaps}Store.test${templateExt}`;
+                        renameSync(`${storePath}/SampleStore.test${templateExt}.txt`, storeTestPath);
+                        // Search and replace store name
+                        updateTemplateName(storeTestPath, outputName, nameCaps);
+                        // Rename source file
+                        const storeFilePath = `${storePath}/${nameCaps}Store${templateExt}`;
+                        renameSync(`${storePath}/SampleStore${templateExt}.txt`, storeFilePath);
+                        // Search and replace store name
+                        updateTemplateName(storeFilePath, outputName, nameCaps);
+                    } else {
+                        log(`\n${cliName} Error: Cannot create new ${type}. Directory, ${storePath} already exists.`, 'error', quiet);
+                        callback(1);
+                        return 1;
+                    }
+                } catch (error) {
+                    log(`\n${cliName} Error: Cannot create new ${type}. ${error.message}`, 'error', quiet);
+                    callback(1);
+                    return 1;
+                }
+                break;
+            }
+        case 'tsconfig':
+            {
+                // Remove existing file
+                await removeFiles('tsconfig.json', true);
+                // Get tsconfig template
+                const templatePath = pathResolve(dirName, '../../../tsconfig.template.json');
+                let data = readFileSync(templatePath, 'utf8');
+                // Update Lex tsconfig template with source and output directories
+                data = data.replace(/.\/src/g, sourcePath);
+                data = data.replace(/.\/lib/g, outputPath);
+                // Save new tsconfig to app
+                const destPath = pathResolve(cwd, './tsconfig.json');
+                writeFileSync(destPath, data, 'utf8');
+                break;
+            }
+        case 'view':
+            {
+                const result = getFilenames({
+                    cliName,
+                    name: outputName,
+                    quiet,
+                    type,
+                    useTypescript
+                });
+                if (!result) {
+                    return 1;
+                }
+                const { nameCaps, templatePath, templateReact } = result;
+                const viewPath = `${cwd}/${nameCaps}View`;
+                try {
+                    if (!existsSync(viewPath)) {
+                        // Copy view files
+                        copyFolderRecursiveSync(pathResolve(dirName, templatePath, './.SampleView'), cwd);
+                        // Rename directory
+                        renameSync(`${cwd}/.SampleView`, viewPath);
+                        // Rename CSS
+                        const viewStylePath = `${viewPath}/${outputName}View.css`;
+                        renameSync(`${viewPath}/sampleView.css`, viewStylePath);
+                        // Search and replace view name
+                        updateTemplateName(viewStylePath, outputName, nameCaps);
+                        // Rename test
+                        const viewTestPath = `${viewPath}/${nameCaps}View.test${templateReact}`;
+                        renameSync(`${viewPath}/SampleView.test${templateReact}.txt`, viewTestPath);
+                        // Search and replace view name
+                        updateTemplateName(viewTestPath, outputName, nameCaps);
+                        // Rename source file
+                        const viewFilePath = `${viewPath}/${nameCaps}View${templateReact}`;
+                        renameSync(`${viewPath}/SampleView${templateReact}.txt`, viewFilePath);
+                        // Search and replace view name
+                        updateTemplateName(viewFilePath, outputName, nameCaps);
+                    } else {
+                        log(`\n${cliName} Error: Cannot create new ${type}. Directory, ${viewPath} already exists.`, 'error', quiet);
+                        callback(1);
+                        return 1;
+                    }
+                } catch (error) {
+                    log(`\n${cliName} Error: Cannot create new ${type}. ${error.message}`, 'error', quiet);
+                    callback(1);
+                    return 1;
+                }
+                break;
+            }
+        case 'vscode':
+            {
+                // Remove existing directory
+                await removeFiles('.vscode', true);
+                // Copy vscode configuration
+                copyFolderRecursiveSync(pathResolve(dirName, '../../../.vscode'), cwd);
+                break;
+            }
+        case 'datalayer':
+            {
+                try {
+                    const result = getFilenames({
+                        cliName,
+                        name: outputName,
+                        quiet,
+                        type,
+                        useTypescript
+                    });
+                    if (!result) {
+                        return 1;
+                    }
+                    const { nameCaps, templateExt, templatePath } = result;
+                    const dataLayerPath = `${cwd}/${nameCaps}DataLayer`;
+                    if (!existsSync(dataLayerPath)) {
+                        // Create data layer directory
+                        const fs = await import('fs');
+                        fs.mkdirSync(dataLayerPath, {
+                            recursive: true
+                        });
+                        // Copy and rename main data layer file
+                        const sourceFile = pathResolve(dirName, templatePath, `./DataLayer${templateExt}.txt`);
+                        const targetFile = `${dataLayerPath}/${nameCaps}DataLayer${templateExt}`;
+                        if (existsSync(sourceFile)) {
+                            const content = readFileSync(sourceFile, 'utf8');
+                            const updatedContent = content.replace(/DataLayer/g, nameCaps);
+                            writeFileSync(targetFile, updatedContent);
+                        }
+                        // Copy and rename test file
+                        const sourceTestFile = pathResolve(dirName, templatePath, `./DataLayer.test${templateExt}.txt`);
+                        const targetTestFile = `${dataLayerPath}/${nameCaps}DataLayer.test${templateExt}`;
+                        if (existsSync(sourceTestFile)) {
+                            const testContent = readFileSync(sourceTestFile, 'utf8');
+                            const updatedTestContent = testContent.replace(/DataLayer/g, nameCaps);
+                            writeFileSync(targetTestFile, updatedTestContent);
+                        }
+                        log(`\n${cliName} Success: Created ${nameCaps}DataLayer with test files.`, 'info', quiet);
+                    } else {
+                        log(`\n${cliName} Error: Cannot create new ${type}. Directory, ${dataLayerPath} already exists.`, 'error', quiet);
+                        callback(1);
+                        return 1;
+                    }
+                } catch (error) {
+                    log(`\n${cliName} Error: Cannot create new ${type}. ${error.message}`, 'error', quiet);
+                    callback(1);
+                    return 1;
+                }
+                break;
+            }
     }
-    case "tsconfig": {
-      await removeFiles("tsconfig.json", true);
-      const templatePath = pathResolve(dirName, "../../../tsconfig.template.json");
-      let data = readFileSync(templatePath, "utf8");
-      data = data.replace(/.\/src/g, sourcePath);
-      data = data.replace(/.\/lib/g, outputPath);
-      const destPath = pathResolve(cwd, "./tsconfig.json");
-      writeFileSync(destPath, data, "utf8");
-      break;
-    }
-    case "view": {
-      const result = getFilenames({
-        cliName,
-        name: outputName,
-        quiet,
-        type,
-        useTypescript
-      });
-      if (!result) {
-        return 1;
-      }
-      const { nameCaps, templatePath, templateReact } = result;
-      const viewPath = `${cwd}/${nameCaps}View`;
-      try {
-        if (!existsSync(viewPath)) {
-          copyFolderRecursiveSync(pathResolve(dirName, templatePath, "./.SampleView"), cwd);
-          renameSync(`${cwd}/.SampleView`, viewPath);
-          const viewStylePath = `${viewPath}/${outputName}View.css`;
-          renameSync(`${viewPath}/sampleView.css`, viewStylePath);
-          updateTemplateName(viewStylePath, outputName, nameCaps);
-          const viewTestPath = `${viewPath}/${nameCaps}View.test${templateReact}`;
-          renameSync(`${viewPath}/SampleView.test${templateReact}.txt`, viewTestPath);
-          updateTemplateName(viewTestPath, outputName, nameCaps);
-          const viewFilePath = `${viewPath}/${nameCaps}View${templateReact}`;
-          renameSync(`${viewPath}/SampleView${templateReact}.txt`, viewFilePath);
-          updateTemplateName(viewFilePath, outputName, nameCaps);
-        } else {
-          log(`
-${cliName} Error: Cannot create new ${type}. Directory, ${viewPath} already exists.`, "error", quiet);
-          callback(1);
-          return 1;
-        }
-      } catch (error) {
-        log(`
-${cliName} Error: Cannot create new ${type}. ${error.message}`, "error", quiet);
-        callback(1);
-        return 1;
-      }
-      break;
-    }
-    case "vscode": {
-      await removeFiles(".vscode", true);
-      copyFolderRecursiveSync(pathResolve(dirName, "../../../.vscode"), cwd);
-      break;
-    }
-  }
-  callback(0);
-  return 0;
-};
-export {
-  create
+    callback(0);
+    return 0;
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/commands/create/create.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {existsSync, readFileSync, renameSync, writeFileSync} from 'fs';\nimport {resolve as pathResolve} from 'path';\n\nimport {createChangelog} from '../../create/changelog.js';\nimport {LexConfig} from '../../LexConfig.js';\nimport {copyFolderRecursiveSync, getFilenames, removeFiles, updateTemplateName} from '../../utils/app.js';\nimport {getDirName} from '../../utils/file.js';\nimport {log} from '../../utils/log.js';\n\nexport interface CreateOptions {\n  readonly cliName?: string;\n  readonly outputFile?: string;\n  readonly outputName?: string;\n  readonly quiet?: boolean;\n}\n\nexport type CreateCallback = (status: number) => void;\n\nexport const create = async (type: string, cmd: CreateOptions, callback: CreateCallback = () => ({})): Promise<number> => {\n  const {cliName = 'Lex', outputFile = '', outputName = '', quiet} = cmd;\n  const cwd: string = process.cwd();\n  log(`${cliName} creating ${type}...`, 'info', quiet);\n\n  // Get custom configuration\n  await LexConfig.parseConfig(cmd, false);\n  const {outputPath = '', sourcePath = '', useTypescript} = LexConfig.config;\n\n  if(useTypescript) {\n    // Make sure tsconfig.json exists\n    LexConfig.checkTypescriptConfig();\n  }\n\n  const {config} = LexConfig;\n  const dirName = getDirName();\n\n  switch(type) {\n    case 'changelog': {\n      const statusChangelog: number = await createChangelog({cliName, config, outputFile, quiet});\n      callback(statusChangelog);\n      return statusChangelog;\n    }\n    case 'store': {\n      try {\n        const result = getFilenames({\n          cliName,\n          name: outputName,\n          quiet,\n          type,\n          useTypescript\n        });\n\n        if(!result) {\n          return 1;\n        }\n\n        const {nameCaps, templateExt, templatePath} = result;\n        const storePath: string = `${cwd}/${nameCaps}Store`;\n\n        if(!existsSync(storePath)) {\n        // Copy store files\n          copyFolderRecursiveSync(pathResolve(dirName, templatePath, './.SampleStore'), cwd);\n\n          // Rename directory\n          renameSync(`${cwd}/.SampleStore`, storePath);\n\n          // Rename test\n          const storeTestPath: string = `${storePath}/${nameCaps}Store.test${templateExt}`;\n          renameSync(`${storePath}/SampleStore.test${templateExt}.txt`, storeTestPath);\n\n          // Search and replace store name\n          updateTemplateName(storeTestPath, outputName, nameCaps);\n\n          // Rename source file\n          const storeFilePath: string = `${storePath}/${nameCaps}Store${templateExt}`;\n          renameSync(`${storePath}/SampleStore${templateExt}.txt`, storeFilePath);\n\n          // Search and replace store name\n          updateTemplateName(storeFilePath, outputName, nameCaps);\n        } else {\n          log(`\\n${cliName} Error: Cannot create new ${type}. Directory, ${storePath} already exists.`, 'error', quiet);\n          callback(1);\n          return 1;\n        }\n      } catch (error) {\n        log(`\\n${cliName} Error: Cannot create new ${type}. ${error.message}`, 'error', quiet);\n        callback(1);\n        return 1;\n      }\n      break;\n    }\n    case 'tsconfig': {\n    // Remove existing file\n      await removeFiles('tsconfig.json', true);\n\n      // Get tsconfig template\n      const templatePath: string = pathResolve(dirName, '../../../tsconfig.template.json');\n      let data: string = readFileSync(templatePath, 'utf8');\n\n      // Update Lex tsconfig template with source and output directories\n      data = data.replace(/.\\/src/g, sourcePath);\n      data = data.replace(/.\\/lib/g, outputPath);\n\n      // Save new tsconfig to app\n      const destPath: string = pathResolve(cwd, './tsconfig.json');\n      writeFileSync(destPath, data, 'utf8');\n      break;\n    }\n    case 'view': {\n      const result = getFilenames({\n        cliName,\n        name: outputName,\n        quiet,\n        type,\n        useTypescript\n      });\n\n      if(!result) {\n        return 1;\n      }\n\n      const {nameCaps, templatePath, templateReact} = result;\n      const viewPath: string = `${cwd}/${nameCaps}View`;\n\n      try {\n        if(!existsSync(viewPath)) {\n        // Copy view files\n          copyFolderRecursiveSync(pathResolve(dirName, templatePath, './.SampleView'), cwd);\n\n          // Rename directory\n          renameSync(`${cwd}/.SampleView`, viewPath);\n\n          // Rename CSS\n          const viewStylePath: string = `${viewPath}/${outputName}View.css`;\n          renameSync(`${viewPath}/sampleView.css`, viewStylePath);\n\n          // Search and replace view name\n          updateTemplateName(viewStylePath, outputName, nameCaps);\n\n          // Rename test\n          const viewTestPath: string = `${viewPath}/${nameCaps}View.test${templateReact}`;\n          renameSync(`${viewPath}/SampleView.test${templateReact}.txt`, viewTestPath);\n\n          // Search and replace view name\n          updateTemplateName(viewTestPath, outputName, nameCaps);\n\n          // Rename source file\n          const viewFilePath: string = `${viewPath}/${nameCaps}View${templateReact}`;\n          renameSync(`${viewPath}/SampleView${templateReact}.txt`, viewFilePath);\n\n          // Search and replace view name\n          updateTemplateName(viewFilePath, outputName, nameCaps);\n        } else {\n          log(`\\n${cliName} Error: Cannot create new ${type}. Directory, ${viewPath} already exists.`, 'error', quiet);\n          callback(1);\n          return 1;\n        }\n      } catch (error) {\n        log(`\\n${cliName} Error: Cannot create new ${type}. ${error.message}`, 'error', quiet);\n        callback(1);\n        return 1;\n      }\n      break;\n    }\n    case 'vscode': {\n    // Remove existing directory\n      await removeFiles('.vscode', true);\n\n      // Copy vscode configuration\n      copyFolderRecursiveSync(pathResolve(dirName, '../../../.vscode'), cwd);\n      break;\n    }\n  }\n\n  callback(0);\n  return 0;\n};"],
  "mappings": "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",
  "names": []
}

+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/commands/create/create.ts"],"sourcesContent":["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {existsSync, readFileSync, renameSync, writeFileSync} from 'fs';\nimport {resolve as pathResolve} from 'path';\n\nimport {createChangelog} from '../../create/changelog.js';\nimport {LexConfig} from '../../LexConfig.js';\nimport {copyFolderRecursiveSync, getFilenames, removeFiles, updateTemplateName} from '../../utils/app.js';\nimport {getDirName} from '../../utils/file.js';\nimport {log} from '../../utils/log.js';\n\nexport interface CreateOptions {\n  readonly cliName?: string;\n  readonly outputFile?: string;\n  readonly outputName?: string;\n  readonly quiet?: boolean;\n}\n\nexport type CreateCallback = (status: number) => void;\n\nexport const create = async (type: string, cmd: CreateOptions, callback: CreateCallback = () => ({})): Promise<number> => {\n  const {cliName = 'Lex', outputFile = '', outputName = '', quiet} = cmd;\n  const cwd: string = process.cwd();\n  log(`${cliName} creating ${type}...`, 'info', quiet);\n\n  // Get custom configuration\n  await LexConfig.parseConfig(cmd, false);\n  const {outputPath = '', sourcePath = '', useTypescript} = LexConfig.config;\n\n  if(useTypescript) {\n    // Make sure tsconfig.json exists\n    LexConfig.checkTypescriptConfig();\n  }\n\n  const {config} = LexConfig;\n  const dirName = getDirName();\n\n  switch(type) {\n    case 'changelog': {\n      const statusChangelog: number = await createChangelog({cliName, config, outputFile, quiet});\n      callback(statusChangelog);\n      return statusChangelog;\n    }\n    case 'store': {\n      try {\n        const result = getFilenames({\n          cliName,\n          name: outputName,\n          quiet,\n          type,\n          useTypescript\n        });\n\n        if(!result) {\n          return 1;\n        }\n\n        const {nameCaps, templateExt, templatePath} = result;\n        const storePath: string = `${cwd}/${nameCaps}Store`;\n\n        if(!existsSync(storePath)) {\n        // Copy store files\n          copyFolderRecursiveSync(pathResolve(dirName, templatePath, './.SampleStore'), cwd);\n\n          // Rename directory\n          renameSync(`${cwd}/.SampleStore`, storePath);\n\n          // Rename test\n          const storeTestPath: string = `${storePath}/${nameCaps}Store.test${templateExt}`;\n          renameSync(`${storePath}/SampleStore.test${templateExt}.txt`, storeTestPath);\n\n          // Search and replace store name\n          updateTemplateName(storeTestPath, outputName, nameCaps);\n\n          // Rename source file\n          const storeFilePath: string = `${storePath}/${nameCaps}Store${templateExt}`;\n          renameSync(`${storePath}/SampleStore${templateExt}.txt`, storeFilePath);\n\n          // Search and replace store name\n          updateTemplateName(storeFilePath, outputName, nameCaps);\n        } else {\n          log(`\\n${cliName} Error: Cannot create new ${type}. Directory, ${storePath} already exists.`, 'error', quiet);\n          callback(1);\n          return 1;\n        }\n      } catch(error) {\n        log(`\\n${cliName} Error: Cannot create new ${type}. ${error.message}`, 'error', quiet);\n        callback(1);\n        return 1;\n      }\n      break;\n    }\n    case 'tsconfig': {\n    // Remove existing file\n      await removeFiles('tsconfig.json', true);\n\n      // Get tsconfig template\n      const templatePath: string = pathResolve(dirName, '../../../tsconfig.template.json');\n      let data: string = readFileSync(templatePath, 'utf8');\n\n      // Update Lex tsconfig template with source and output directories\n      data = data.replace(/.\\/src/g, sourcePath);\n      data = data.replace(/.\\/lib/g, outputPath);\n\n      // Save new tsconfig to app\n      const destPath: string = pathResolve(cwd, './tsconfig.json');\n      writeFileSync(destPath, data, 'utf8');\n      break;\n    }\n    case 'view': {\n      const result = getFilenames({\n        cliName,\n        name: outputName,\n        quiet,\n        type,\n        useTypescript\n      });\n\n      if(!result) {\n        return 1;\n      }\n\n      const {nameCaps, templatePath, templateReact} = result;\n      const viewPath: string = `${cwd}/${nameCaps}View`;\n\n      try {\n        if(!existsSync(viewPath)) {\n        // Copy view files\n          copyFolderRecursiveSync(pathResolve(dirName, templatePath, './.SampleView'), cwd);\n\n          // Rename directory\n          renameSync(`${cwd}/.SampleView`, viewPath);\n\n          // Rename CSS\n          const viewStylePath: string = `${viewPath}/${outputName}View.css`;\n          renameSync(`${viewPath}/sampleView.css`, viewStylePath);\n\n          // Search and replace view name\n          updateTemplateName(viewStylePath, outputName, nameCaps);\n\n          // Rename test\n          const viewTestPath: string = `${viewPath}/${nameCaps}View.test${templateReact}`;\n          renameSync(`${viewPath}/SampleView.test${templateReact}.txt`, viewTestPath);\n\n          // Search and replace view name\n          updateTemplateName(viewTestPath, outputName, nameCaps);\n\n          // Rename source file\n          const viewFilePath: string = `${viewPath}/${nameCaps}View${templateReact}`;\n          renameSync(`${viewPath}/SampleView${templateReact}.txt`, viewFilePath);\n\n          // Search and replace view name\n          updateTemplateName(viewFilePath, outputName, nameCaps);\n        } else {\n          log(`\\n${cliName} Error: Cannot create new ${type}. Directory, ${viewPath} already exists.`, 'error', quiet);\n          callback(1);\n          return 1;\n        }\n      } catch(error) {\n        log(`\\n${cliName} Error: Cannot create new ${type}. ${error.message}`, 'error', quiet);\n        callback(1);\n        return 1;\n      }\n      break;\n    }\n    case 'vscode': {\n    // Remove existing directory\n      await removeFiles('.vscode', true);\n\n      // Copy vscode configuration\n      copyFolderRecursiveSync(pathResolve(dirName, '../../../.vscode'), cwd);\n      break;\n    }\n    case 'datalayer': {\n      try {\n        const result = getFilenames({\n          cliName,\n          name: outputName,\n          quiet,\n          type,\n          useTypescript\n        });\n\n        if(!result) {\n          return 1;\n        }\n\n        const {nameCaps, templateExt, templatePath} = result;\n        const dataLayerPath: string = `${cwd}/${nameCaps}DataLayer`;\n\n        if(!existsSync(dataLayerPath)) {\n          // Create data layer directory\n          const fs = await import('fs');\n          fs.mkdirSync(dataLayerPath, {recursive: true});\n\n          // Copy and rename main data layer file\n          const sourceFile = pathResolve(dirName, templatePath, `./DataLayer${templateExt}.txt`);\n          const targetFile = `${dataLayerPath}/${nameCaps}DataLayer${templateExt}`;\n\n          if(existsSync(sourceFile)) {\n            const content = readFileSync(sourceFile, 'utf8');\n            const updatedContent = content.replace(/DataLayer/g, nameCaps);\n            writeFileSync(targetFile, updatedContent);\n          }\n\n          // Copy and rename test file\n          const sourceTestFile = pathResolve(dirName, templatePath, `./DataLayer.test${templateExt}.txt`);\n          const targetTestFile = `${dataLayerPath}/${nameCaps}DataLayer.test${templateExt}`;\n\n          if(existsSync(sourceTestFile)) {\n            const testContent = readFileSync(sourceTestFile, 'utf8');\n            const updatedTestContent = testContent.replace(/DataLayer/g, nameCaps);\n            writeFileSync(targetTestFile, updatedTestContent);\n          }\n\n          log(`\\n${cliName} Success: Created ${nameCaps}DataLayer with test files.`, 'info', quiet);\n        } else {\n          log(`\\n${cliName} Error: Cannot create new ${type}. Directory, ${dataLayerPath} already exists.`, 'error', quiet);\n          callback(1);\n          return 1;\n        }\n      } catch(error) {\n        log(`\\n${cliName} Error: Cannot create new ${type}. ${error.message}`, 'error', quiet);\n        callback(1);\n        return 1;\n      }\n      break;\n    }\n  }\n\n  callback(0);\n  return 0;\n};"],"names":["existsSync","readFileSync","renameSync","writeFileSync","resolve","pathResolve","createChangelog","LexConfig","copyFolderRecursiveSync","getFilenames","removeFiles","updateTemplateName","getDirName","log","create","type","cmd","callback","cliName","outputFile","outputName","quiet","cwd","process","parseConfig","outputPath","sourcePath","useTypescript","config","checkTypescriptConfig","dirName","statusChangelog","result","name","nameCaps","templateExt","templatePath","storePath","storeTestPath","storeFilePath","error","message","data","replace","destPath","templateReact","viewPath","viewStylePath","viewTestPath","viewFilePath","dataLayerPath","fs","mkdirSync","recursive","sourceFile","targetFile","content","updatedContent","sourceTestFile","targetTestFile","testContent","updatedTestContent"],"mappings":"AAAA;;;CAGC,GACD,SAAQA,UAAU,EAAEC,YAAY,EAAEC,UAAU,EAAEC,aAAa,QAAO,KAAK;AACvE,SAAQC,WAAWC,WAAW,QAAO,OAAO;AAE5C,SAAQC,eAAe,QAAO,4BAA4B;AAC1D,SAAQC,SAAS,QAAO,qBAAqB;AAC7C,SAAQC,uBAAuB,EAAEC,YAAY,EAAEC,WAAW,EAAEC,kBAAkB,QAAO,qBAAqB;AAC1G,SAAQC,UAAU,QAAO,sBAAsB;AAC/C,SAAQC,GAAG,QAAO,qBAAqB;AAWvC,OAAO,MAAMC,SAAS,OAAOC,MAAcC,KAAoBC,WAA2B,IAAO,CAAA,CAAC,CAAA,CAAE;IAClG,MAAM,EAACC,UAAU,KAAK,EAAEC,aAAa,EAAE,EAAEC,aAAa,EAAE,EAAEC,KAAK,EAAC,GAAGL;IACnE,MAAMM,MAAcC,QAAQD,GAAG;IAC/BT,IAAI,GAAGK,QAAQ,UAAU,EAAEH,KAAK,GAAG,CAAC,EAAE,QAAQM;IAE9C,2BAA2B;IAC3B,MAAMd,UAAUiB,WAAW,CAACR,KAAK;IACjC,MAAM,EAACS,aAAa,EAAE,EAAEC,aAAa,EAAE,EAAEC,aAAa,EAAC,GAAGpB,UAAUqB,MAAM;IAE1E,IAAGD,eAAe;QAChB,iCAAiC;QACjCpB,UAAUsB,qBAAqB;IACjC;IAEA,MAAM,EAACD,MAAM,EAAC,GAAGrB;IACjB,MAAMuB,UAAUlB;IAEhB,OAAOG;QACL,KAAK;YAAa;gBAChB,MAAMgB,kBAA0B,MAAMzB,gBAAgB;oBAACY;oBAASU;oBAAQT;oBAAYE;gBAAK;gBACzFJ,SAASc;gBACT,OAAOA;YACT;QACA,KAAK;YAAS;gBACZ,IAAI;oBACF,MAAMC,SAASvB,aAAa;wBAC1BS;wBACAe,MAAMb;wBACNC;wBACAN;wBACAY;oBACF;oBAEA,IAAG,CAACK,QAAQ;wBACV,OAAO;oBACT;oBAEA,MAAM,EAACE,QAAQ,EAAEC,WAAW,EAAEC,YAAY,EAAC,GAAGJ;oBAC9C,MAAMK,YAAoB,GAAGf,IAAI,CAAC,EAAEY,SAAS,KAAK,CAAC;oBAEnD,IAAG,CAAClC,WAAWqC,YAAY;wBAC3B,mBAAmB;wBACjB7B,wBAAwBH,YAAYyB,SAASM,cAAc,mBAAmBd;wBAE9E,mBAAmB;wBACnBpB,WAAW,GAAGoB,IAAI,aAAa,CAAC,EAAEe;wBAElC,cAAc;wBACd,MAAMC,gBAAwB,GAAGD,UAAU,CAAC,EAAEH,SAAS,UAAU,EAAEC,aAAa;wBAChFjC,WAAW,GAAGmC,UAAU,iBAAiB,EAAEF,YAAY,IAAI,CAAC,EAAEG;wBAE9D,gCAAgC;wBAChC3B,mBAAmB2B,eAAelB,YAAYc;wBAE9C,qBAAqB;wBACrB,MAAMK,gBAAwB,GAAGF,UAAU,CAAC,EAAEH,SAAS,KAAK,EAAEC,aAAa;wBAC3EjC,WAAW,GAAGmC,UAAU,YAAY,EAAEF,YAAY,IAAI,CAAC,EAAEI;wBAEzD,gCAAgC;wBAChC5B,mBAAmB4B,eAAenB,YAAYc;oBAChD,OAAO;wBACLrB,IAAI,CAAC,EAAE,EAAEK,QAAQ,0BAA0B,EAAEH,KAAK,aAAa,EAAEsB,UAAU,gBAAgB,CAAC,EAAE,SAAShB;wBACvGJ,SAAS;wBACT,OAAO;oBACT;gBACF,EAAE,OAAMuB,OAAO;oBACb3B,IAAI,CAAC,EAAE,EAAEK,QAAQ,0BAA0B,EAAEH,KAAK,EAAE,EAAEyB,MAAMC,OAAO,EAAE,EAAE,SAASpB;oBAChFJ,SAAS;oBACT,OAAO;gBACT;gBACA;YACF;QACA,KAAK;YAAY;gBACjB,uBAAuB;gBACrB,MAAMP,YAAY,iBAAiB;gBAEnC,wBAAwB;gBACxB,MAAM0B,eAAuB/B,YAAYyB,SAAS;gBAClD,IAAIY,OAAezC,aAAamC,cAAc;gBAE9C,kEAAkE;gBAClEM,OAAOA,KAAKC,OAAO,CAAC,WAAWjB;gBAC/BgB,OAAOA,KAAKC,OAAO,CAAC,WAAWlB;gBAE/B,2BAA2B;gBAC3B,MAAMmB,WAAmBvC,YAAYiB,KAAK;gBAC1CnB,cAAcyC,UAAUF,MAAM;gBAC9B;YACF;QACA,KAAK;YAAQ;gBACX,MAAMV,SAASvB,aAAa;oBAC1BS;oBACAe,MAAMb;oBACNC;oBACAN;oBACAY;gBACF;gBAEA,IAAG,CAACK,QAAQ;oBACV,OAAO;gBACT;gBAEA,MAAM,EAACE,QAAQ,EAAEE,YAAY,EAAES,aAAa,EAAC,GAAGb;gBAChD,MAAMc,WAAmB,GAAGxB,IAAI,CAAC,EAAEY,SAAS,IAAI,CAAC;gBAEjD,IAAI;oBACF,IAAG,CAAClC,WAAW8C,WAAW;wBAC1B,kBAAkB;wBAChBtC,wBAAwBH,YAAYyB,SAASM,cAAc,kBAAkBd;wBAE7E,mBAAmB;wBACnBpB,WAAW,GAAGoB,IAAI,YAAY,CAAC,EAAEwB;wBAEjC,aAAa;wBACb,MAAMC,gBAAwB,GAAGD,SAAS,CAAC,EAAE1B,WAAW,QAAQ,CAAC;wBACjElB,WAAW,GAAG4C,SAAS,eAAe,CAAC,EAAEC;wBAEzC,+BAA+B;wBAC/BpC,mBAAmBoC,eAAe3B,YAAYc;wBAE9C,cAAc;wBACd,MAAMc,eAAuB,GAAGF,SAAS,CAAC,EAAEZ,SAAS,SAAS,EAAEW,eAAe;wBAC/E3C,WAAW,GAAG4C,SAAS,gBAAgB,EAAED,cAAc,IAAI,CAAC,EAAEG;wBAE9D,+BAA+B;wBAC/BrC,mBAAmBqC,cAAc5B,YAAYc;wBAE7C,qBAAqB;wBACrB,MAAMe,eAAuB,GAAGH,SAAS,CAAC,EAAEZ,SAAS,IAAI,EAAEW,eAAe;wBAC1E3C,WAAW,GAAG4C,SAAS,WAAW,EAAED,cAAc,IAAI,CAAC,EAAEI;wBAEzD,+BAA+B;wBAC/BtC,mBAAmBsC,cAAc7B,YAAYc;oBAC/C,OAAO;wBACLrB,IAAI,CAAC,EAAE,EAAEK,QAAQ,0BAA0B,EAAEH,KAAK,aAAa,EAAE+B,SAAS,gBAAgB,CAAC,EAAE,SAASzB;wBACtGJ,SAAS;wBACT,OAAO;oBACT;gBACF,EAAE,OAAMuB,OAAO;oBACb3B,IAAI,CAAC,EAAE,EAAEK,QAAQ,0BAA0B,EAAEH,KAAK,EAAE,EAAEyB,MAAMC,OAAO,EAAE,EAAE,SAASpB;oBAChFJ,SAAS;oBACT,OAAO;gBACT;gBACA;YACF;QACA,KAAK;YAAU;gBACf,4BAA4B;gBAC1B,MAAMP,YAAY,WAAW;gBAE7B,4BAA4B;gBAC5BF,wBAAwBH,YAAYyB,SAAS,qBAAqBR;gBAClE;YACF;QACA,KAAK;YAAa;gBAChB,IAAI;oBACF,MAAMU,SAASvB,aAAa;wBAC1BS;wBACAe,MAAMb;wBACNC;wBACAN;wBACAY;oBACF;oBAEA,IAAG,CAACK,QAAQ;wBACV,OAAO;oBACT;oBAEA,MAAM,EAACE,QAAQ,EAAEC,WAAW,EAAEC,YAAY,EAAC,GAAGJ;oBAC9C,MAAMkB,gBAAwB,GAAG5B,IAAI,CAAC,EAAEY,SAAS,SAAS,CAAC;oBAE3D,IAAG,CAAClC,WAAWkD,gBAAgB;wBAC7B,8BAA8B;wBAC9B,MAAMC,KAAK,MAAM,MAAM,CAAC;wBACxBA,GAAGC,SAAS,CAACF,eAAe;4BAACG,WAAW;wBAAI;wBAE5C,uCAAuC;wBACvC,MAAMC,aAAajD,YAAYyB,SAASM,cAAc,CAAC,WAAW,EAAED,YAAY,IAAI,CAAC;wBACrF,MAAMoB,aAAa,GAAGL,cAAc,CAAC,EAAEhB,SAAS,SAAS,EAAEC,aAAa;wBAExE,IAAGnC,WAAWsD,aAAa;4BACzB,MAAME,UAAUvD,aAAaqD,YAAY;4BACzC,MAAMG,iBAAiBD,QAAQb,OAAO,CAAC,cAAcT;4BACrD/B,cAAcoD,YAAYE;wBAC5B;wBAEA,4BAA4B;wBAC5B,MAAMC,iBAAiBrD,YAAYyB,SAASM,cAAc,CAAC,gBAAgB,EAAED,YAAY,IAAI,CAAC;wBAC9F,MAAMwB,iBAAiB,GAAGT,cAAc,CAAC,EAAEhB,SAAS,cAAc,EAAEC,aAAa;wBAEjF,IAAGnC,WAAW0D,iBAAiB;4BAC7B,MAAME,cAAc3D,aAAayD,gBAAgB;4BACjD,MAAMG,qBAAqBD,YAAYjB,OAAO,CAAC,cAAcT;4BAC7D/B,cAAcwD,gBAAgBE;wBAChC;wBAEAhD,IAAI,CAAC,EAAE,EAAEK,QAAQ,kBAAkB,EAAEgB,SAAS,0BAA0B,CAAC,EAAE,QAAQb;oBACrF,OAAO;wBACLR,IAAI,CAAC,EAAE,EAAEK,QAAQ,0BAA0B,EAAEH,KAAK,aAAa,EAAEmC,cAAc,gBAAgB,CAAC,EAAE,SAAS7B;wBAC3GJ,SAAS;wBACT,OAAO;oBACT;gBACF,EAAE,OAAMuB,OAAO;oBACb3B,IAAI,CAAC,EAAE,EAAEK,QAAQ,0BAA0B,EAAEH,KAAK,EAAE,EAAEyB,MAAMC,OAAO,EAAE,EAAE,SAASpB;oBAChFJ,SAAS;oBACT,OAAO;gBACT;gBACA;YACF;IACF;IAEAA,SAAS;IACT,OAAO;AACT,EAAE"}

package/lib/commands/dev/dev.d.ts

@@ -4,6 +4,7 @@ export interface DevOptions {
     readonly config?: string;
     readonly format?: string;
     readonly open?: boolean;
+    readonly port?: number;
     readonly quiet?: boolean;
     readonly remove?: boolean;
     readonly translations?: boolean;