@nlabs/lex 1.46.2 → 1.47.1

package/dist/commands/dev/dev.js

@@ -0,0 +1,70 @@
+import { execa } from "execa";
+import { resolve as pathResolve } from "path";
+import { URL } from "url";
+import { LexConfig } from "../../LexConfig.js";
+import { createSpinner, removeFiles } from "../../utils/app.js";
+import { relativeNodePath } from "../../utils/file.js";
+import { log } from "../../utils/log.js";
+const dev = async (cmd, callback = () => ({})) => {
+  const { bundleAnalyzer, cliName = "Lex", config, open = false, quiet, remove, variables } = cmd;
+  const spinner = createSpinner(quiet);
+  log(`${cliName} start development server...`, "info", quiet);
+  await LexConfig.parseConfig(cmd);
+  const { outputFullPath, useTypescript } = LexConfig.config;
+  let variablesObj = { NODE_ENV: "development" };
+  if (variables) {
+    try {
+      variablesObj = JSON.parse(variables);
+    } catch (_error) {
+      log(`
+${cliName} Error: Environment variables option is not a valid JSON object.`, "error", quiet);
+      callback(1);
+      return 1;
+    }
+  }
+  process.env = { ...process.env, ...variablesObj };
+  if (useTypescript) {
+    LexConfig.checkTypescriptConfig();
+  }
+  if (remove) {
+    spinner.start("Cleaning output directory...");
+    await removeFiles(outputFullPath);
+    spinner.succeed("Successfully cleaned output directory!");
+  }
+  const dirName = new URL(".", import.meta.url).pathname;
+  const webpackConfig = config || pathResolve(dirName, "../../../webpack.config.js");
+  const webpackOptions = [
+    "--color",
+    "--watch",
+    "--config",
+    webpackConfig
+  ];
+  if (bundleAnalyzer) {
+    webpackOptions.push("--bundleAnalyzer");
+  }
+  try {
+    const dirPath = pathResolve(dirName, "../../..");
+    const webpackPath = relativeNodePath("webpack-cli/bin/cli.js", dirPath);
+    await execa(webpackPath, webpackOptions, {
+      encoding: "utf8",
+      env: {
+        LEX_QUIET: quiet,
+        WEBPACK_DEV_OPEN: open
+      },
+      stdio: "inherit"
+    });
+    spinner.succeed("Development server started.");
+    callback(0);
+    return 0;
+  } catch (error) {
+    log(`
+${cliName} Error: ${error.message}`, "error", quiet);
+    spinner.fail("There was an error while running Webpack.");
+    callback(1);
+    return 1;
+  }
+};
+export {
+  dev
+};
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

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

package/dist/commands/init/init.d.ts

@@ -0,0 +1,9 @@
+export interface InitOptions {
+    readonly cliName?: string;
+    readonly install?: boolean;
+    readonly packageManager?: string;
+    readonly quiet?: boolean;
+    readonly typescript?: boolean;
+}
+export type InitCallback = (status: number) => void;
+export declare const init: (appName: string, packageName: string, cmd: InitOptions, callback?: InitCallback) => Promise<number>;

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

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

package/dist/commands/init/init.js

@@ -0,0 +1,93 @@
+import { execa } from "execa";
+import { renameSync, writeFileSync } from "fs";
+import { resolve as pathResolve } from "path";
+import { URL } from "url";
+import { LexConfig } from "../../LexConfig.js";
+import { createSpinner, getPackageJson, setPackageJson } from "../../utils/app.js";
+import { log } from "../../utils/log.js";
+const init = async (appName, packageName, cmd, callback = () => ({})) => {
+  const { cliName = "Lex", install, packageManager: cmdPackageManager, quiet, typescript } = cmd;
+  const cwd = process.cwd();
+  const spinner = createSpinner(quiet);
+  log(`${cliName} is downloading the app module...`, "info", quiet);
+  spinner.start("Downloading app...");
+  const tmpPath = pathResolve(cwd, "./.lexTmp");
+  const appPath = pathResolve(cwd, `./${appName}`);
+  const dirName = new URL(".", import.meta.url).pathname;
+  const dnpPath = pathResolve(dirName, "../../../node_modules/download-npm-package/bin/cli.js");
+  await LexConfig.parseConfig(cmd);
+  const { packageManager: configPackageManager, useTypescript: configTypescript } = LexConfig.config;
+  const packageManager = cmdPackageManager || configPackageManager;
+  const useTypescript = typescript !== void 0 ? typescript : configTypescript;
+  let appModule = packageName;
+  if (!appModule) {
+    if (useTypescript) {
+      appModule = "@nlabs/arkhamjs-example-ts-react";
+    } else {
+      appModule = "@nlabs/arkhamjs-example-flow-react";
+    }
+  }
+  try {
+    await execa(dnpPath, [appModule, tmpPath], {});
+    spinner.succeed("Successfully downloaded app!");
+  } catch (error) {
+    console.log("error", error);
+    log(`
+${cliName} Error: There was an error downloading ${appModule}. Make sure the package exists and there is a network connection.`, "error", quiet);
+    spinner.fail("Downloaded of app failed.");
+    callback(1);
+    return 1;
+  }
+  try {
+    renameSync(`${tmpPath}/${appModule}`, appPath);
+  } catch (_error) {
+    log(`
+${cliName} Error: There was an error copying ${appModule} to the current working directory.`, "error", quiet);
+    callback(1);
+    return 1;
+  }
+  const packagePath = `${appPath}/package.json`;
+  const packageJson = getPackageJson(packagePath);
+  packageJson.name = appName;
+  packageJson.description = `${cliName} created app`;
+  packageJson.version = "0.1.0";
+  delete packageJson.keywords;
+  delete packageJson.author;
+  delete packageJson.contributors;
+  delete packageJson.repository;
+  delete packageJson.homepage;
+  delete packageJson.bugs;
+  try {
+    setPackageJson(packageJson, packagePath);
+    const readmePath = `${appPath}/README.md`;
+    writeFileSync(readmePath, `# ${appName}`);
+  } catch (error) {
+    log(`
+${cliName} Error: ${error.message}`, "error", quiet);
+    callback(1);
+    return 1;
+  }
+  if (install) {
+    spinner.start("Installing dependencies...");
+    process.chdir(appPath);
+    try {
+      await execa(packageManager, ["install"], {
+        encoding: "utf8",
+        stdio: "inherit"
+      });
+      spinner.succeed("Successfully installed dependencies!");
+    } catch (error) {
+      log(`
+${cliName} Error: ${error.message}`, "error", quiet);
+      spinner.fail("Failed to install dependencies.");
+      callback(1);
+      return 1;
+    }
+  }
+  callback(0);
+  return 0;
+};
+export {
+  init
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/commands/init/init.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 {renameSync, writeFileSync} from 'fs';\nimport {resolve as pathResolve} from 'path';\nimport {URL} from 'url';\n\nimport {LexConfig} from '../../LexConfig.js';\nimport {createSpinner, getPackageJson, setPackageJson} from '../../utils/app.js';\nimport {log} from '../../utils/log.js';\n\nexport interface InitOptions {\n  readonly cliName?: string;\n  readonly install?: boolean;\n  readonly packageManager?: string;\n  readonly quiet?: boolean;\n  readonly typescript?: boolean;\n}\n\nexport type InitCallback = (status: number) => void;\n\nexport const init = async (\n  appName: string,\n  packageName: string,\n  cmd: InitOptions,\n  callback: InitCallback = () => ({})\n): Promise<number> => {\n  const {cliName = 'Lex', install, packageManager: cmdPackageManager, quiet, typescript} = cmd;\n  const cwd: string = process.cwd();\n\n  // Spinner\n  const spinner = createSpinner(quiet);\n\n  // Download app module into temporary directory\n  log(`${cliName} is downloading the app module...`, 'info', quiet);\n  spinner.start('Downloading app...');\n  const tmpPath: string = pathResolve(cwd, './.lexTmp');\n  const appPath: string = pathResolve(cwd, `./${appName}`);\n  const dirName = new URL('.', import.meta.url).pathname;\n  const dnpPath: string = pathResolve(dirName, '../../../node_modules/download-npm-package/bin/cli.js');\n\n  // Get custom configuration\n  await LexConfig.parseConfig(cmd);\n  const {packageManager: configPackageManager, useTypescript: configTypescript} = LexConfig.config;\n  const packageManager: string = cmdPackageManager || configPackageManager;\n  const useTypescript: boolean = typescript !== undefined ? typescript : configTypescript;\n\n  let appModule: string = packageName;\n\n  // Use base app module based on config\n  if(!appModule) {\n    if(useTypescript) {\n      appModule = '@nlabs/arkhamjs-example-ts-react';\n    } else {\n      appModule = '@nlabs/arkhamjs-example-flow-react';\n    }\n  }\n\n  try {\n    await execa(dnpPath, [appModule, tmpPath], {});\n\n    // Stop spinner and update status\n    spinner.succeed('Successfully downloaded app!');\n  } catch(error) {\n    console.log('error', error);\n    log(`\\n${cliName} Error: There was an error downloading ${appModule}. Make sure the package exists and there is a network connection.`, 'error', quiet);\n\n    // Stop spinner and kill process\n    spinner.fail('Downloaded of app failed.');\n\n    // Kill process\n    callback(1);\n    return 1;\n  }\n\n  // Move into configured directory\n  try {\n    renameSync(`${tmpPath}/${appModule}`, appPath);\n  } catch(_error) {\n    log(`\\n${cliName} Error: There was an error copying ${appModule} to the current working directory.`, 'error', quiet);\n    callback(1);\n    return 1;\n  }\n\n  // Configure package.json\n  const packagePath: string = `${appPath}/package.json`;\n  const packageJson = getPackageJson(packagePath);\n  packageJson.name = appName;\n  packageJson.description = `${cliName} created app`;\n  packageJson.version = '0.1.0';\n  delete packageJson.keywords;\n  delete packageJson.author;\n  delete packageJson.contributors;\n  delete packageJson.repository;\n  delete packageJson.homepage;\n  delete packageJson.bugs;\n\n  try {\n    // Update package.json\n    setPackageJson(packageJson, packagePath);\n\n    // Update README\n    const readmePath: string = `${appPath}/README.md`;\n    writeFileSync(readmePath, `# ${appName}`);\n  } catch(error) {\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n    callback(1);\n    return 1;\n  }\n\n  if(install) {\n    spinner.start('Installing dependencies...');\n\n    // Change to the app directory\n    process.chdir(appPath);\n\n    // Install dependencies\n    try {\n      await execa(packageManager, ['install'], {\n        encoding: 'utf8',\n        stdio: 'inherit'\n      });\n\n      // Stop spinner\n      spinner.succeed('Successfully installed dependencies!');\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 install dependencies.');\n\n      // Kill process\n      callback(1);\n      return 1;\n    }\n  }\n\n  // Kill process\n  callback(0);\n  return 0;\n};"],
  "mappings": "AAIA,SAAQ,aAAY;AACpB,SAAQ,YAAY,qBAAoB;AACxC,SAAQ,WAAW,mBAAkB;AACrC,SAAQ,WAAU;AAElB,SAAQ,iBAAgB;AACxB,SAAQ,eAAe,gBAAgB,sBAAqB;AAC5D,SAAQ,WAAU;AAYX,MAAM,OAAO,OAClB,SACA,aACA,KACA,WAAyB,OAAO,CAAC,OACb;AACpB,QAAM,EAAC,UAAU,OAAO,SAAS,gBAAgB,mBAAmB,OAAO,WAAU,IAAI;AACzF,QAAM,MAAc,QAAQ,IAAI;AAGhC,QAAM,UAAU,cAAc,KAAK;AAGnC,MAAI,GAAG,OAAO,qCAAqC,QAAQ,KAAK;AAChE,UAAQ,MAAM,oBAAoB;AAClC,QAAM,UAAkB,YAAY,KAAK,WAAW;AACpD,QAAM,UAAkB,YAAY,KAAK,KAAK,OAAO,EAAE;AACvD,QAAM,UAAU,IAAI,IAAI,KAAK,YAAY,GAAG,EAAE;AAC9C,QAAM,UAAkB,YAAY,SAAS,uDAAuD;AAGpG,QAAM,UAAU,YAAY,GAAG;AAC/B,QAAM,EAAC,gBAAgB,sBAAsB,eAAe,iBAAgB,IAAI,UAAU;AAC1F,QAAM,iBAAyB,qBAAqB;AACpD,QAAM,gBAAyB,eAAe,SAAY,aAAa;AAEvE,MAAI,YAAoB;AAGxB,MAAG,CAAC,WAAW;AACb,QAAG,eAAe;AAChB,kBAAY;AAAA,IACd,OAAO;AACL,kBAAY;AAAA,IACd;AAAA,EACF;AAEA,MAAI;AACF,UAAM,MAAM,SAAS,CAAC,WAAW,OAAO,GAAG,CAAC,CAAC;AAG7C,YAAQ,QAAQ,8BAA8B;AAAA,EAChD,SAAQ,OAAO;AACb,YAAQ,IAAI,SAAS,KAAK;AAC1B,QAAI;AAAA,EAAK,OAAO,0CAA0C,SAAS,qEAAqE,SAAS,KAAK;AAGtJ,YAAQ,KAAK,2BAA2B;AAGxC,aAAS,CAAC;AACV,WAAO;AAAA,EACT;AAGA,MAAI;AACF,eAAW,GAAG,OAAO,IAAI,SAAS,IAAI,OAAO;AAAA,EAC/C,SAAQ,QAAQ;AACd,QAAI;AAAA,EAAK,OAAO,sCAAsC,SAAS,sCAAsC,SAAS,KAAK;AACnH,aAAS,CAAC;AACV,WAAO;AAAA,EACT;AAGA,QAAM,cAAsB,GAAG,OAAO;AACtC,QAAM,cAAc,eAAe,WAAW;AAC9C,cAAY,OAAO;AACnB,cAAY,cAAc,GAAG,OAAO;AACpC,cAAY,UAAU;AACtB,SAAO,YAAY;AACnB,SAAO,YAAY;AACnB,SAAO,YAAY;AACnB,SAAO,YAAY;AACnB,SAAO,YAAY;AACnB,SAAO,YAAY;AAEnB,MAAI;AAEF,mBAAe,aAAa,WAAW;AAGvC,UAAM,aAAqB,GAAG,OAAO;AACrC,kBAAc,YAAY,KAAK,OAAO,EAAE;AAAA,EAC1C,SAAQ,OAAO;AACb,QAAI;AAAA,EAAK,OAAO,WAAW,MAAM,OAAO,IAAI,SAAS,KAAK;AAC1D,aAAS,CAAC;AACV,WAAO;AAAA,EACT;AAEA,MAAG,SAAS;AACV,YAAQ,MAAM,4BAA4B;AAG1C,YAAQ,MAAM,OAAO;AAGrB,QAAI;AACF,YAAM,MAAM,gBAAgB,CAAC,SAAS,GAAG;AAAA,QACvC,UAAU;AAAA,QACV,OAAO;AAAA,MACT,CAAC;AAGD,cAAQ,QAAQ,sCAAsC;AAAA,IACxD,SAAQ,OAAO;AAEb,UAAI;AAAA,EAAK,OAAO,WAAW,MAAM,OAAO,IAAI,SAAS,KAAK;AAG1D,cAAQ,KAAK,iCAAiC;AAG9C,eAAS,CAAC;AACV,aAAO;AAAA,IACT;AAAA,EACF;AAGA,WAAS,CAAC;AACV,SAAO;AACT;",
  "names": []
}


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

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

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

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

package/dist/commands/link/link.d.ts

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

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

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

package/dist/commands/link/link.js

@@ -0,0 +1,15 @@
+import { LexConfig } from "../../LexConfig.js";
+import { checkLinkedModules } from "../../utils/app.js";
+import { log } from "../../utils/log.js";
+const linked = async (cmd, callback = () => ({})) => {
+  const { cliName = "Lex", quiet } = cmd;
+  log(`${cliName} checking for linked modules...`, "info", quiet);
+  await LexConfig.parseConfig(cmd);
+  checkLinkedModules();
+  callback(0);
+  return Promise.resolve(0);
+};
+export {
+  linked
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2NvbW1hbmRzL2xpbmsvbGluay50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBDb3B5cmlnaHQgKGMpIDIwMTgtUHJlc2VudCwgTml0cm9nZW4gTGFicywgSW5jLlxuICogQ29weXJpZ2h0cyBsaWNlbnNlZCB1bmRlciB0aGUgTUlUIExpY2Vuc2UuIFNlZSB0aGUgYWNjb21wYW55aW5nIExJQ0VOU0UgZmlsZSBmb3IgdGVybXMuXG4gKi9cbmltcG9ydCB7TGV4Q29uZmlnfSBmcm9tICcuLi8uLi9MZXhDb25maWcuanMnO1xuaW1wb3J0IHtjaGVja0xpbmtlZE1vZHVsZXN9IGZyb20gJy4uLy4uL3V0aWxzL2FwcC5qcyc7XG5pbXBvcnQge2xvZ30gZnJvbSAnLi4vLi4vdXRpbHMvbG9nLmpzJztcblxuZXhwb3J0IGludGVyZmFjZSBMaW5rT3B0aW9ucyB7XG4gIHJlYWRvbmx5IGNsaU5hbWU/OiBzdHJpbmc7XG4gIHJlYWRvbmx5IHF1aWV0PzogYm9vbGVhbjtcbn1cblxuZXhwb3J0IHR5cGUgTGlua0NhbGxiYWNrID0gKHN0YXR1czogbnVtYmVyKSA9PiB2b2lkO1xuXG5leHBvcnQgY29uc3QgbGlua2VkID0gYXN5bmMgKGNtZDogTGlua09wdGlvbnMsIGNhbGxiYWNrOiBMaW5rQ2FsbGJhY2sgPSAoKSA9PiAoe30pKTogUHJvbWlzZTxudW1iZXI+ID0+IHtcbiAgY29uc3Qge2NsaU5hbWUgPSAnTGV4JywgcXVpZXR9ID0gY21kO1xuXG4gIC8vIERpc3BsYXkgc3RhdHVzXG4gIGxvZyhgJHtjbGlOYW1lfSBjaGVja2luZyBmb3IgbGlua2VkIG1vZHVsZXMuLi5gLCAnaW5mbycsIHF1aWV0KTtcblxuICAvLyBHZXQgY3VzdG9tIGNvbmZpZ3VyYXRpb25cbiAgYXdhaXQgTGV4Q29uZmlnLnBhcnNlQ29uZmlnKGNtZCk7XG5cbiAgLy8gQ2hlY2sgZm9yIGxpbmtlZCBtb2R1bGVzXG4gIGNoZWNrTGlua2VkTW9kdWxlcygpO1xuICBjYWxsYmFjaygwKTtcbiAgcmV0dXJuIFByb21pc2UucmVzb2x2ZSgwKTtcbn07Il0sCiAgIm1hcHBpbmdzIjogIkFBSUEsU0FBUSxpQkFBZ0I7QUFDeEIsU0FBUSwwQkFBeUI7QUFDakMsU0FBUSxXQUFVO0FBU1gsTUFBTSxTQUFTLE9BQU8sS0FBa0IsV0FBeUIsT0FBTyxDQUFDLE9BQXdCO0FBQ3RHLFFBQU0sRUFBQyxVQUFVLE9BQU8sTUFBSyxJQUFJO0FBR2pDLE1BQUksR0FBRyxPQUFPLG1DQUFtQyxRQUFRLEtBQUs7QUFHOUQsUUFBTSxVQUFVLFlBQVksR0FBRztBQUcvQixxQkFBbUI7QUFDbkIsV0FBUyxDQUFDO0FBQ1YsU0FBTyxRQUFRLFFBQVEsQ0FBQztBQUMxQjsiLAogICJuYW1lcyI6IFtdCn0K

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

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

package/dist/commands/lint/autofix.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

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

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

package/dist/commands/lint/lint.d.ts

@@ -0,0 +1,39 @@
+export interface LintOptions {
+    readonly cache?: boolean;
+    readonly cacheFile?: string;
+    readonly cacheLocation?: string;
+    readonly cliName?: string;
+    readonly color?: boolean;
+    readonly config?: string;
+    readonly debug?: boolean;
+    readonly env?: string;
+    readonly envInfo?: boolean;
+    readonly ext?: string;
+    readonly fix?: boolean;
+    readonly fixDryRun?: boolean;
+    readonly fixType?: string;
+    readonly format?: string;
+    readonly global?: string;
+    readonly ignorePath?: string;
+    readonly ignorePattern?: string;
+    readonly init?: boolean;
+    readonly maxWarnings?: string;
+    readonly noColor?: boolean;
+    readonly noEslintrc?: boolean;
+    readonly noIgnore?: boolean;
+    readonly noInlineConfig?: boolean;
+    readonly outputFile?: string;
+    readonly parser?: string;
+    readonly parserOptions?: string;
+    readonly plugin?: string;
+    readonly printConfig?: string;
+    readonly quiet?: boolean;
+    readonly reportUnusedDisableDirectives?: boolean;
+    readonly resolvePluginsRelativeTo?: string;
+    readonly rule?: string;
+    readonly rulesdir?: string;
+    readonly stdin?: boolean;
+    readonly stdinFilename?: string;
+}
+export type LintCallback = typeof process.exit;
+export declare const lint: (cmd: LintOptions, callback?: LintCallback) => Promise<number>;

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

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