@nlabs/lex 1.46.2 → 1.47.1

package/dist/commands/compile/compile.js

@@ -0,0 +1,239 @@
+import { execa } from "execa";
+import { existsSync, lstatSync, readdirSync } from "fs";
+import { sync as globSync } from "glob";
+import { extname as pathExtname, join as pathJoin, resolve as pathResolve } from "path";
+import { URL } from "url";
+import { LexConfig } from "../../LexConfig.js";
+import { checkLinkedModules, copyConfiguredFiles, copyFiles, createSpinner, getFilesByExt, removeFiles } from "../../utils/app.js";
+import { relativeNodePath } from "../../utils/file.js";
+import { log } from "../../utils/log.js";
+const hasFileType = (startPath, ext) => {
+  if (!existsSync(startPath)) {
+    return false;
+  }
+  const files = readdirSync(startPath);
+  return files.some((file) => {
+    const filename = pathJoin(startPath, file);
+    const fileExt = pathExtname(filename);
+    const stat = lstatSync(filename);
+    if (stat.isDirectory()) {
+      return hasFileType(filename, ext);
+    }
+    return ext.includes(fileExt);
+  });
+};
+const compile = async (cmd, callback = () => ({})) => {
+  const {
+    cliName = "Lex",
+    config,
+    outputPath,
+    quiet,
+    remove,
+    sourcePath,
+    watch
+  } = cmd;
+  const spinner = createSpinner(quiet);
+  log(`${cliName} compiling...`, "info", quiet);
+  await LexConfig.parseConfig(cmd);
+  const { outputFullPath, sourceFullPath, useTypescript } = LexConfig.config;
+  const outputDir = outputPath || outputFullPath;
+  const sourceDir = sourcePath ? pathResolve(process.cwd(), `./${sourcePath}`) : sourceFullPath;
+  const dirName = new URL(".", import.meta.url).pathname;
+  const dirPath = pathResolve(dirName, "../..");
+  checkLinkedModules();
+  if (remove) {
+    await removeFiles(outputDir);
+  }
+  if (useTypescript) {
+    LexConfig.checkTypescriptConfig();
+    const typescriptPath = relativeNodePath("typescript/bin/tsc", dirPath);
+    const typescriptOptions = config ? ["-p", config] : [
+      "--allowSyntheticDefaultImports",
+      "--baseUrl",
+      sourceDir,
+      "--declaration",
+      "--emitDeclarationOnly",
+      "--lib",
+      "ESNext,DOM",
+      "--module",
+      "esnext",
+      "--moduleResolution",
+      "node",
+      "--noImplicitReturns",
+      "--noImplicitThis",
+      "--outDir",
+      outputDir,
+      "--removeComments",
+      "--resolveJsonModule",
+      "--target",
+      "ESNext",
+      "--typeRoots",
+      "node_modules/@types,node_modules/json-d-ts"
+    ];
+    spinner.start("Static type checking with Typescript...");
+    try {
+      await execa(typescriptPath, typescriptOptions, { encoding: "utf8" });
+      spinner.succeed("Successfully completed type checking!");
+    } catch (error) {
+      log(`
+${cliName} Error: ${error.message}`, "error", quiet);
+      spinner.fail("Type checking failed.");
+      callback(1);
+      return 1;
+    }
+  }
+  const globOptions = {
+    cwd: sourceDir,
+    dot: false,
+    nodir: true,
+    nosort: true
+  };
+  const tsFiles = globSync(`${sourceDir}/**/!(*.spec|*.test).ts*`, globOptions);
+  const jsFiles = globSync(`${sourceDir}/**/!(*.spec|*.test).js`, globOptions);
+  const sourceFiles = [...tsFiles, ...jsFiles];
+  const esbuildConfig = LexConfig.config.esbuild || {};
+  const esbuildPath = relativeNodePath("esbuild/bin/esbuild", dirPath);
+  const esbuildOptions = [
+    ...sourceFiles,
+    "--color=true",
+    `--format=${esbuildConfig.format || "cjs"}`,
+    `--outdir=${outputDir}`,
+    `--platform=${esbuildConfig.platform || "node"}`,
+    `--sourcemap=${esbuildConfig.sourcemap || "inline"}`,
+    `--target=${esbuildConfig.target || "node20"}`
+  ];
+  if (esbuildConfig.minify === true) {
+    esbuildOptions.push("--minify");
+  }
+  if (esbuildConfig.treeShaking !== false) {
+    esbuildOptions.push("--tree-shaking=true");
+  }
+  if (esbuildConfig.drop && esbuildConfig.drop.length > 0) {
+    esbuildConfig.drop.forEach((item) => {
+      esbuildOptions.push(`--drop:${item}`);
+    });
+  }
+  if (esbuildConfig.pure && esbuildConfig.pure.length > 0) {
+    esbuildConfig.pure.forEach((item) => {
+      esbuildOptions.push(`--pure:${item}`);
+    });
+  }
+  if (esbuildConfig.legalComments) {
+    esbuildOptions.push(`--legal-comments=${esbuildConfig.legalComments}`);
+  }
+  if (esbuildConfig.banner) {
+    Object.entries(esbuildConfig.banner).forEach(([type, content]) => {
+      esbuildOptions.push(`--banner:${type}=${content}`);
+    });
+  }
+  if (esbuildConfig.footer) {
+    Object.entries(esbuildConfig.footer).forEach(([type, content]) => {
+      esbuildOptions.push(`--footer:${type}=${content}`);
+    });
+  }
+  if (esbuildConfig.define) {
+    Object.entries(esbuildConfig.define).forEach(([key, value]) => {
+      esbuildOptions.push(`--define:${key}=${value}`);
+    });
+  }
+  if (watch) {
+    esbuildOptions.push("--watch");
+  }
+  const cssFiles = getFilesByExt(".css", LexConfig.config);
+  if (cssFiles.length) {
+    const postcssPath = relativeNodePath("postcss-cli/index.js", dirPath);
+    const postcssOptions = [
+      `${sourceDir}/**/**.css`,
+      "--base",
+      sourceDir,
+      "--dir",
+      outputDir,
+      "--config",
+      pathResolve(dirName, "../../postcss.config.js")
+    ];
+    try {
+      await execa(postcssPath, postcssOptions, { encoding: "utf8" });
+      spinner.succeed(`Successfully formatted ${cssFiles.length} css files!`);
+    } catch (error) {
+      log(`
+${cliName} Error: ${error.message}`, "error", quiet);
+      spinner.fail("Failed formatting css.");
+      callback(1);
+      return 1;
+    }
+  }
+  const gifFiles = getFilesByExt(".gif", LexConfig.config);
+  const jpgFiles = getFilesByExt(".jpg", LexConfig.config);
+  const pngFiles = getFilesByExt(".png", LexConfig.config);
+  const svgFiles = getFilesByExt(".svg", LexConfig.config);
+  const imageFiles = [...gifFiles, ...jpgFiles, ...pngFiles, ...svgFiles];
+  if (imageFiles.length) {
+    try {
+      await copyFiles(imageFiles, "image", spinner, LexConfig.config);
+    } catch (error) {
+      log(`
+${cliName} Error: ${error.message}`, "error", quiet);
+      spinner.fail("Failed to move images to output directory.");
+      callback(1);
+      return 1;
+    }
+  }
+  const ttfFiles = getFilesByExt(".ttf", LexConfig.config);
+  const otfFiles = getFilesByExt(".otf", LexConfig.config);
+  const woffFiles = getFilesByExt(".woff", LexConfig.config);
+  const woff2Files = getFilesByExt(".woff2", LexConfig.config);
+  const fontFiles = [...ttfFiles, ...otfFiles, ...woffFiles, ...woff2Files];
+  if (fontFiles.length) {
+    try {
+      await copyFiles(fontFiles, "font", spinner, LexConfig.config);
+    } catch (error) {
+      log(`
+${cliName} Error: ${error.message}`, "error", quiet);
+      spinner.fail("Failed to move fonts to output directory.");
+      callback(1);
+      return 1;
+    }
+  }
+  const mdFiles = getFilesByExt(".md", LexConfig.config);
+  if (mdFiles.length) {
+    try {
+      await copyFiles(mdFiles, "documents", spinner, LexConfig.config);
+    } catch (error) {
+      log(`
+${cliName} Error: ${error.message}`, "error", quiet);
+      spinner.fail("Failed to move docs to output directory.");
+      callback(1);
+      return 1;
+    }
+  }
+  spinner.start(watch ? "Watching for changes..." : "Compiling with ESBuild...");
+  try {
+    await execa(esbuildPath, esbuildOptions, { encoding: "utf8" });
+    spinner.succeed("Compile completed successfully!");
+  } catch (error) {
+    log(`
+${cliName} Error: ${error.message}`, "error", quiet);
+    if (!quiet) {
+      console.error(error);
+    }
+    spinner.fail("Code compiling failed.");
+    callback(1);
+    return 1;
+  }
+  try {
+    await copyConfiguredFiles(spinner, LexConfig.config, quiet);
+  } catch (copyError) {
+    log(`
+${cliName} Error: Failed to copy configured files: ${copyError.message}`, "error", quiet);
+    spinner.fail("Failed to copy configured files.");
+    callback(1);
+    return 1;
+  }
+  callback(0);
+  return 0;
+};
+export {
+  compile,
+  hasFileType
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/commands/compile/compile.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 {execa} from 'execa';\nimport {existsSync, lstatSync, readdirSync} from 'fs';\nimport {sync as globSync} from 'glob';\nimport {extname as pathExtname, join as pathJoin, resolve as pathResolve} from 'path';\nimport {URL} from 'url';\n\nimport {LexConfig} from '../../LexConfig.js';\nimport {checkLinkedModules, copyConfiguredFiles, copyFiles, createSpinner, getFilesByExt, removeFiles} from '../../utils/app.js';\nimport {relativeNodePath} from '../../utils/file.js';\nimport {log} from '../../utils/log.js';\n\nexport const hasFileType = (startPath: string, ext: string[]): boolean => {\n  if(!existsSync(startPath)) {\n    return false;\n  }\n\n  const files: string[] = readdirSync(startPath);\n\n  return files.some((file: string) => {\n    const filename: string = pathJoin(startPath, file);\n    const fileExt: string = pathExtname(filename);\n    const stat = lstatSync(filename);\n\n    if(stat.isDirectory()) {\n      // Recursive search\n      return hasFileType(filename, ext);\n    }\n\n    return ext.includes(fileExt);\n  });\n};\n\nexport const compile = async (cmd: any, callback: any = () => ({})): Promise<number> => {\n  const {\n    cliName = 'Lex',\n    config,\n    outputPath,\n    quiet,\n    remove,\n    sourcePath,\n    watch\n  } = cmd;\n\n  // Spinner\n  const spinner = createSpinner(quiet);\n\n  // Display status\n  log(`${cliName} compiling...`, 'info', quiet);\n\n  // Get custom configuration\n  await LexConfig.parseConfig(cmd);\n\n  // Compile type\n  const {outputFullPath, sourceFullPath, useTypescript} = LexConfig.config;\n  const outputDir: string = outputPath || outputFullPath;\n  const sourceDir: string = sourcePath ? pathResolve(process.cwd(), `./${sourcePath}`) : sourceFullPath;\n  const dirName = new URL('.', import.meta.url).pathname;\n  const dirPath: string = pathResolve(dirName, '../..');\n\n  // Check for linked modules\n  checkLinkedModules();\n\n  // Clean output directory before we start adding in new files\n  if(remove) {\n    await removeFiles(outputDir);\n  }\n\n  // Add tsconfig file if none exists\n  if(useTypescript) {\n    // Make sure tsconfig.json exists\n    LexConfig.checkTypescriptConfig();\n\n    // Check static types with typescript\n    const typescriptPath: string = relativeNodePath('typescript/bin/tsc', dirPath);\n    const typescriptOptions: string[] = config ?\n      ['-p', config] :\n      [\n        '--allowSyntheticDefaultImports',\n        '--baseUrl', sourceDir,\n        '--declaration',\n        '--emitDeclarationOnly',\n        '--lib', 'ESNext,DOM',\n        '--module', 'esnext',\n        '--moduleResolution', 'node',\n        '--noImplicitReturns',\n        '--noImplicitThis',\n        '--outDir', outputDir,\n        '--removeComments',\n        '--resolveJsonModule',\n        '--target', 'ESNext',\n        '--typeRoots', 'node_modules/@types,node_modules/json-d-ts'\n      ];\n\n    // Start type checking spinner\n    spinner.start('Static type checking with Typescript...');\n\n    // Type checking\n    try {\n      await execa(typescriptPath, typescriptOptions, {encoding: 'utf8'});\n\n      // Stop spinner\n      spinner.succeed('Successfully completed type checking!');\n    } catch(error) {\n      // Display error message\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      // Stop spinner\n      spinner.fail('Type checking failed.');\n\n      // Kill Process\n      callback(1);\n      return 1;\n    }\n  }\n\n  // Source files\n  const globOptions = {\n    cwd: sourceDir,\n    dot: false,\n    nodir: true,\n    nosort: true\n  };\n  const tsFiles: string[] = globSync(`${sourceDir}/**/!(*.spec|*.test).ts*`, globOptions);\n  const jsFiles: string[] = globSync(`${sourceDir}/**/!(*.spec|*.test).js`, globOptions);\n  const sourceFiles: string[] = [...tsFiles, ...jsFiles];\n\n  // Get esbuild configuration with defaults for compile (individual files)\n  const esbuildConfig = LexConfig.config.esbuild || {};\n\n  // ESBuild options\n  const esbuildPath: string = relativeNodePath('esbuild/bin/esbuild', dirPath);\n  const esbuildOptions: string[] = [\n    ...sourceFiles,\n    '--color=true',\n    `--format=${esbuildConfig.format || 'cjs'}`,\n    `--outdir=${outputDir}`,\n    `--platform=${esbuildConfig.platform || 'node'}`,\n    `--sourcemap=${esbuildConfig.sourcemap || 'inline'}`,\n    `--target=${esbuildConfig.target || 'node20'}`\n  ];\n\n  // Apply optimization options for compile (more conservative defaults)\n  if(esbuildConfig.minify === true) {\n    esbuildOptions.push('--minify');\n  }\n\n  if(esbuildConfig.treeShaking !== false) {\n    esbuildOptions.push('--tree-shaking=true');\n  }\n\n  if(esbuildConfig.drop && esbuildConfig.drop.length > 0) {\n    esbuildConfig.drop.forEach((item) => {\n      esbuildOptions.push(`--drop:${item}`);\n    });\n  }\n\n  if(esbuildConfig.pure && esbuildConfig.pure.length > 0) {\n    esbuildConfig.pure.forEach((item) => {\n      esbuildOptions.push(`--pure:${item}`);\n    });\n  }\n\n  if(esbuildConfig.legalComments) {\n    esbuildOptions.push(`--legal-comments=${esbuildConfig.legalComments}`);\n  }\n\n  if(esbuildConfig.banner) {\n    Object.entries(esbuildConfig.banner).forEach(([type, content]) => {\n      esbuildOptions.push(`--banner:${type}=${content}`);\n    });\n  }\n\n  if(esbuildConfig.footer) {\n    Object.entries(esbuildConfig.footer).forEach(([type, content]) => {\n      esbuildOptions.push(`--footer:${type}=${content}`);\n    });\n  }\n\n  if(esbuildConfig.define) {\n    Object.entries(esbuildConfig.define).forEach(([key, value]) => {\n      esbuildOptions.push(`--define:${key}=${value}`);\n    });\n  }\n\n  if(watch) {\n    esbuildOptions.push('--watch');\n  }\n\n  // Use PostCSS for CSS files\n  const cssFiles: string[] = getFilesByExt('.css', LexConfig.config);\n\n  if(cssFiles.length) {\n    const postcssPath: string = relativeNodePath('postcss-cli/index.js', dirPath);\n    const postcssOptions: string[] = [\n      `${sourceDir}/**/**.css`,\n      '--base',\n      sourceDir,\n      '--dir',\n      outputDir,\n      '--config',\n      pathResolve(dirName, '../../postcss.config.js')\n    ];\n\n    try {\n      await execa(postcssPath, postcssOptions, {encoding: 'utf8'});\n      spinner.succeed(`Successfully formatted ${cssFiles.length} css files!`);\n    } catch(error) {\n      // Display error message\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      // Stop spinner\n      spinner.fail('Failed formatting css.');\n\n      // Kill Process\n      callback(1);\n      return 1;\n    }\n  }\n\n  // Copy image files\n  const gifFiles: string[] = getFilesByExt('.gif', LexConfig.config);\n  const jpgFiles: string[] = getFilesByExt('.jpg', LexConfig.config);\n  const pngFiles: string[] = getFilesByExt('.png', LexConfig.config);\n  const svgFiles: string[] = getFilesByExt('.svg', LexConfig.config);\n  const imageFiles: string[] = [...gifFiles, ...jpgFiles, ...pngFiles, ...svgFiles];\n\n  if(imageFiles.length) {\n    try {\n      await copyFiles(imageFiles, 'image', spinner, LexConfig.config);\n    } catch(error) {\n      // Display error message\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      // Stop spinner\n      spinner.fail('Failed to move images to output directory.');\n\n      // Kill Process\n      callback(1);\n      return 1;\n    }\n  }\n\n  // Copy font files\n  const ttfFiles: string[] = getFilesByExt('.ttf', LexConfig.config);\n  const otfFiles: string[] = getFilesByExt('.otf', LexConfig.config);\n  const woffFiles: string[] = getFilesByExt('.woff', LexConfig.config);\n  const woff2Files: string[] = getFilesByExt('.woff2', LexConfig.config);\n  const fontFiles: string[] = [...ttfFiles, ...otfFiles, ...woffFiles, ...woff2Files];\n\n  if(fontFiles.length) {\n    try {\n      await copyFiles(fontFiles, 'font', spinner, LexConfig.config);\n    } catch(error) {\n      // Display error message\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      // Stop spinner\n      spinner.fail('Failed to move fonts to output directory.');\n\n      // Kill Process\n      callback(1);\n      return 1;\n    }\n  }\n\n  // Copy markdown files\n  const mdFiles: string[] = getFilesByExt('.md', LexConfig.config);\n\n  if(mdFiles.length) {\n    try {\n      await copyFiles(mdFiles, 'documents', spinner, LexConfig.config);\n    } catch(error) {\n      // Display error message\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      // Stop spinner\n      spinner.fail('Failed to move docs to output directory.');\n\n      // Kill Process\n      callback(1);\n      return 1;\n    }\n  }\n\n  // Start compile spinner\n  spinner.start(watch ? 'Watching for changes...' : 'Compiling with ESBuild...');\n\n  try {\n    await execa(esbuildPath, esbuildOptions, {encoding: 'utf8'});\n\n    // Stop spinner\n    spinner.succeed('Compile completed successfully!');\n  } catch(error) {\n    // Display error message\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n    if(!quiet) {\n      console.error(error);\n    }\n\n    // Stop spinner\n    spinner.fail('Code compiling failed.');\n\n    // Kill Process\n    callback(1);\n    return 1;\n  }\n\n  // Copy configured files after successful compilation\n  try {\n    await copyConfiguredFiles(spinner, LexConfig.config, quiet);\n  } catch(copyError) {\n    // Display error message\n    log(`\\n${cliName} Error: Failed to copy configured files: ${copyError.message}`, 'error', quiet);\n\n    // Stop spinner\n    spinner.fail('Failed to copy configured files.');\n\n    // Kill Process\n    callback(1);\n    return 1;\n  }\n\n  // Stop process\n  callback(0);\n  return 0;\n};"],
  "mappings": "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",
  "names": []
}


package/dist/commands/compile/compile.options.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/config/config.cli.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/config/config.d.ts

@@ -0,0 +1,7 @@
+export interface ConfigOptions {
+    readonly cliName?: string;
+    readonly json?: string;
+    readonly quiet?: boolean;
+}
+export type ConfigCallback = (status: number) => void;
+export declare const config: (type: string, cmd: ConfigOptions, callback?: ConfigCallback) => Promise<number>;

package/dist/commands/config/config.integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/config/config.js

@@ -0,0 +1,43 @@
+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.lex.js");
+      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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

package/dist/commands/config/config.options.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/copy/copy.cli.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/copy/copy.d.ts

@@ -0,0 +1,6 @@
+export interface CopyOptions {
+    readonly cliName?: string;
+    readonly quiet?: boolean;
+}
+export type CopyCallback = (status: number) => void;
+export declare const copy: (from: string, to: string, cmd: CopyOptions, callback?: CopyCallback) => Promise<number>;

package/dist/commands/copy/copy.integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/copy/copy.js

@@ -0,0 +1,38 @@
+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);
+    }
+  } else {
+    try {
+      copyFileSync(from, to);
+    } catch (error) {
+      log(`
+${cliName} Error: Cannot copy "${from}" ${error.message}`, "error", quiet);
+      callback(1);
+      return Promise.resolve(1);
+    }
+  }
+  callback(0);
+  return Promise.resolve(0);
+};
+export {
+  copy
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/copy/copy.options.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/create/create.cli.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/create/create.d.ts

@@ -0,0 +1,8 @@
+export interface CreateOptions {
+    readonly cliName?: string;
+    readonly outputFile?: string;
+    readonly outputName?: string;
+    readonly quiet?: boolean;
+}
+export type CreateCallback = (status: number) => void;
+export declare const create: (type: string, cmd: CreateOptions, callback?: CreateCallback) => Promise<number>;

package/dist/commands/create/create.integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/create/create.js

@@ -0,0 +1,124 @@
+import { existsSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { resolve as pathResolve } from "path";
+import { URL } from "url";
+import { createChangelog } from "../../create/changelog.js";
+import { LexConfig } from "../../LexConfig.js";
+import { copyFolderRecursiveSync, getFilenames, removeFiles, updateTemplateName } from "../../utils/app.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 = new URL(".", import.meta.url).pathname;
+  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)) {
+          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;
+    }
+    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(/.\/dist/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
+};
+//# 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';\nimport {URL} from 'url';\n\nimport {createChangelog} from '../../create/changelog.js';\nimport {LexConfig} from '../../LexConfig.js';\nimport {copyFolderRecursiveSync, getFilenames, removeFiles, updateTemplateName} from '../../utils/app.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 = new URL('.', import.meta.url).pathname;\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(/.\\/dist/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": []
}


package/dist/commands/create/create.options.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/dev/dev.cli.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/dev/dev.d.ts

@@ -0,0 +1,11 @@
+export interface DevOptions {
+    readonly bundleAnalyzer?: boolean;
+    readonly cliName?: string;
+    readonly config?: string;
+    readonly open?: boolean;
+    readonly quiet?: boolean;
+    readonly remove?: boolean;
+    readonly variables?: string;
+}
+export type DevCallback = (status: number) => void;
+export declare const dev: (cmd: DevOptions, callback?: DevCallback) => Promise<number>;

package/dist/commands/dev/dev.integration.test.d.ts

@@ -0,0 +1 @@
+export {};