@nlabs/lex 1.39.0 → 1.41.0

package/dist/commands/bulid.test.js

@@ -1,8 +1,317 @@
-import { build } from "./build.js";
+import { build as esBuild } from "esbuild";
+import { execa } from "execa";
+import { build, buildWithEsBuild, buildWithWebpack } from "./build.js";
+import { LexConfig, defaultConfigValues } from "../LexConfig.js";
+import { checkLinkedModules, removeFiles } from "../utils/app";
+jest.mock("esbuild", () => ({
+  ...jest.requireActual("esbuild"),
+  build: jest.fn(() => Promise.resolve({}))
+}));
+jest.mock("execa", () => ({
+  ...jest.requireActual("execa"),
+  execa: jest.fn(() => Promise.resolve({}))
+}));
+jest.mock("@luckycatfactory/esbuild-graphql-loader", () => ({
+  ...jest.requireActual("@luckycatfactory/esbuild-graphql-loader"),
+  __esModule: true,
+  default: jest.fn(() => "esbuildGraphqlLoader")
+}));
+jest.mock("../utils/app", () => ({
+  ...jest.requireActual("../utils/app"),
+  checkLinkedModules: jest.fn(),
+  removeFiles: jest.fn(() => Promise.resolve())
+}));
+jest.mock("../LexConfig", () => ({
+  LexConfig: {
+    config: {},
+    checkTypescriptConfig: jest.fn(),
+    parseConfig: jest.fn()
+  }
+}));
 describe("build", () => {
-  it("should", async () => {
-    const status = await build({ cliName: "Test" }, Promise.resolve);
-    expect(status).toBe(1);
+  let callback;
+  let spinner;
+  let oldConsole;
+  beforeAll(() => {
+    oldConsole = { ...console };
+    console = {
+      ...oldConsole,
+      debug: jest.fn(),
+      error: jest.fn(),
+      warn: jest.fn()
+    };
+  });
+  beforeEach(() => {
+    LexConfig.config = {
+      ...defaultConfigValues
+    };
+    callback = jest.fn();
+    spinner = {
+      succeed: jest.fn(),
+      fail: jest.fn()
+    };
+  });
+  afterAll(() => {
+    console = { ...oldConsole };
+    jest.resetAllMocks();
+  });
+  describe("buildWithEsBuild", () => {
+    beforeEach(() => {
+      esBuild.mockImplementation(() => Promise.resolve({}));
+    });
+    it("should build using default config", async () => {
+      const status = await buildWithEsBuild(spinner, {}, callback);
+      expect(esBuild).toHaveBeenCalledWith({
+        bundle: true,
+        color: true,
+        entryPoints: [void 0],
+        loader: {
+          ".js": "js"
+        },
+        outdir: void 0,
+        platform: "node",
+        plugins: [],
+        sourcemap: "inline",
+        target: "es2016",
+        watch: false
+      });
+      expect(spinner.succeed).toHaveBeenCalled();
+      expect(spinner.fail).not.toHaveBeenCalled();
+      expect(callback).toHaveBeenCalledWith(0);
+      expect(status).toBe(0);
+    });
+    it("should build for node", async () => {
+      LexConfig.config = {
+        ...defaultConfigValues,
+        targetEnvironment: "node"
+      };
+      const status = await buildWithEsBuild(spinner, {}, callback);
+      expect(esBuild).toHaveBeenCalledWith({
+        bundle: true,
+        color: true,
+        entryPoints: [void 0],
+        loader: {
+          ".js": "js"
+        },
+        outdir: void 0,
+        platform: "node",
+        plugins: [],
+        sourcemap: "inline",
+        target: "node18",
+        watch: false
+      });
+      expect(spinner.succeed).toHaveBeenCalled();
+      expect(spinner.fail).not.toHaveBeenCalled();
+      expect(callback).toHaveBeenCalledWith(0);
+      expect(status).toBe(0);
+    });
+    it("should build using typescript", async () => {
+      LexConfig.config = {
+        ...defaultConfigValues,
+        useTypescript: true
+      };
+      const callback2 = jest.fn();
+      const status = await buildWithEsBuild(spinner, { cliName: "Test" }, callback2);
+      expect(esBuild).toHaveBeenCalledWith({
+        bundle: true,
+        color: true,
+        entryPoints: [void 0],
+        loader: {
+          ".js": "js",
+          ".ts": "ts",
+          ".tsx": "tsx"
+        },
+        outdir: void 0,
+        platform: "node",
+        plugins: [],
+        sourcemap: "inline",
+        target: "es2016",
+        watch: false
+      });
+      expect(spinner.succeed).toHaveBeenCalled();
+      expect(spinner.fail).not.toHaveBeenCalled();
+      expect(callback2).toHaveBeenCalledWith(0);
+      expect(status).toBe(0);
+    });
+    it("should build using graphql", async () => {
+      LexConfig.config = {
+        ...defaultConfigValues,
+        useGraphQl: true
+      };
+      const status = await buildWithEsBuild(spinner, { cliName: "Test" }, callback);
+      expect(esBuild).toHaveBeenCalledWith({
+        bundle: true,
+        color: true,
+        entryPoints: [void 0],
+        loader: {
+          ".js": "js"
+        },
+        outdir: void 0,
+        platform: "node",
+        plugins: ["esbuildGraphqlLoader"],
+        sourcemap: "inline",
+        target: "es2016",
+        watch: false
+      });
+      expect(spinner.succeed).toHaveBeenCalled();
+      expect(spinner.fail).not.toHaveBeenCalled();
+      expect(callback).toHaveBeenCalledWith(0);
+      expect(status).toBe(0);
+    });
+    it("should handle errors", async () => {
+      esBuild.mockImplementation(() => Promise.reject(new Error("Mock Error")));
+      const status = await buildWithEsBuild(spinner, { cliName: "Test" }, callback);
+      expect(spinner.succeed).not.toHaveBeenCalled();
+      expect(spinner.fail).toHaveBeenCalled();
+      expect(callback).toHaveBeenCalledWith(1);
+      expect(status).toBe(1);
+    });
+  });
+  describe("buildWithWebpack", () => {
+    beforeEach(() => {
+      execa.mockImplementation(() => Promise.resolve({}));
+    });
+    it("should build using default config", async () => {
+      const status = await buildWithWebpack(spinner, {}, callback);
+      expect(execa).toHaveBeenCalledWith(
+        expect.stringContaining("/node_modules/webpack-cli/bin/cli.js"),
+        [
+          "--color",
+          "--progress",
+          "--config",
+          "/webpack.config.js"
+        ],
+        { encoding: "utf8", stdio: "inherit" }
+      );
+      expect(spinner.succeed).toHaveBeenCalled();
+      expect(spinner.fail).not.toHaveBeenCalled();
+      expect(callback).toHaveBeenCalledWith(0);
+      expect(status).toBe(0);
+    });
+    it("should build using custom options", async () => {
+      LexConfig.config = {
+        ...defaultConfigValues,
+        useTypescript: true
+      };
+      const callback2 = jest.fn();
+      const cmd = {
+        analyze: true,
+        cliName: "Lex",
+        config: "config.js",
+        configName: "configName",
+        defineProcessEnvNodeEnv: "development",
+        devtool: "devtool",
+        disableInterpret: true,
+        entry: "entry",
+        env: "env",
+        failOnWarnings: true,
+        json: "json",
+        merge: "merge",
+        mode: "mode",
+        name: "name",
+        nodeEnv: "nodeEnv",
+        noDevtool: true,
+        noStats: true,
+        noTarget: true,
+        noWatch: true,
+        noWatchOptionsStdin: true,
+        outputPath: "outputPath",
+        quiet: false,
+        stats: "stats",
+        target: "target",
+        watch: true,
+        watchOptionsStdin: true
+      };
+      const status = await buildWithWebpack(spinner, cmd, callback2);
+      expect(execa).toHaveBeenLastCalledWith(
+        expect.stringContaining("/node_modules/webpack-cli/bin/cli.js"),
+        [
+          "--color",
+          "--progress",
+          "--config",
+          "config.js",
+          "--analyze",
+          "--config-name",
+          "configName",
+          "--define-process-env-node-env",
+          "development",
+          "--devtool",
+          "devtool",
+          "--disable-interpret",
+          "--entry",
+          "entry",
+          "--env",
+          "env",
+          "--fail-on-warnings",
+          "--json",
+          "json",
+          "--mode",
+          "mode",
+          "--merge",
+          "--name",
+          "name",
+          "--no-devtool",
+          "--no-stats",
+          "--no-target",
+          "--no-watch",
+          "--no-watch-options-stdin",
+          "--node-env",
+          "nodeEnv",
+          "--output-path",
+          "outputPath",
+          "--stats",
+          "stats",
+          "--target",
+          "target",
+          "--watch",
+          "--watch-options-stdin"
+        ],
+        { encoding: "utf8", stdio: "inherit" }
+      );
+      expect(spinner.succeed).toHaveBeenCalled();
+      expect(spinner.fail).not.toHaveBeenCalled();
+      expect(callback2).toHaveBeenCalledWith(0);
+      expect(status).toBe(0);
+    });
+    it("should handle errors", async () => {
+      execa.mockImplementation(() => Promise.reject(new Error("Mock Error")));
+      const status = await buildWithWebpack(spinner, { cliName: "Test" }, callback);
+      expect(spinner.succeed).not.toHaveBeenCalled();
+      expect(spinner.fail).toHaveBeenCalled();
+      expect(callback).toHaveBeenCalledWith(1);
+      expect(status).toBe(1);
+    });
+  });
+  describe("build", () => {
+    it("should build with defaults", async () => {
+      const status = await build({}, callback);
+      expect(checkLinkedModules).toHaveBeenCalled();
+      expect(callback).toHaveBeenCalledWith(1);
+      expect(status).toBe(1);
+    });
+    it("should build with defined props", async () => {
+      LexConfig.config = {
+        ...defaultConfigValues,
+        useTypescript: true
+      };
+      const status = await build({
+        bundler: "esbuild",
+        remove: true
+      }, callback);
+      expect(checkLinkedModules).toHaveBeenCalled();
+      expect(removeFiles).toHaveBeenCalled();
+      expect(LexConfig.checkTypescriptConfig).toHaveBeenCalled();
+      expect(callback).toHaveBeenCalledWith(1);
+      expect(status).toBe(1);
+    });
+    it("should error on bad variables value", async () => {
+      const status = await build({
+        bundler: "esbuild",
+        variables: "test"
+      }, callback);
+      expect(callback).toHaveBeenCalledWith(1);
+      expect(status).toBe(1);
+    });
   });
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2NvbW1hbmRzL2J1bGlkLnRlc3QudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbImltcG9ydCB7YnVpbGR9IGZyb20gJy4vYnVpbGQuanMnO1xuXG5kZXNjcmliZSgnYnVpbGQnLCAoKSA9PiB7XG4gIGl0KCdzaG91bGQnLCBhc3luYyAoKSA9PiB7XG4gICAgY29uc3Qgc3RhdHVzOiBudW1iZXIgPSBhd2FpdCBidWlsZCh7Y2xpTmFtZTogJ1Rlc3QnfSwgUHJvbWlzZS5yZXNvbHZlKTtcbiAgICBleHBlY3Qoc3RhdHVzKS50b0JlKDEpO1xuICB9KTtcbn0pO1xuIl0sCiAgIm1hcHBpbmdzIjogIkFBQUEsU0FBUSxhQUFZO0FBRXBCLFNBQVMsU0FBUyxNQUFNO0FBQ3RCLEtBQUcsVUFBVSxZQUFZO0FBQ3ZCLFVBQU0sU0FBaUIsTUFBTSxNQUFNLEVBQUMsU0FBUyxPQUFNLEdBQUcsUUFBUSxPQUFPO0FBQ3JFLFdBQU8sTUFBTSxFQUFFLEtBQUssQ0FBQztBQUFBLEVBQ3ZCLENBQUM7QUFDSCxDQUFDOyIsCiAgIm5hbWVzIjogW10KfQo=
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/commands/bulid.test.ts"],
  "sourcesContent": ["import {build as esBuild} from 'esbuild';\nimport {execa} from 'execa';\n\nimport {build, buildWithEsBuild, buildWithWebpack} from './build.js';\nimport {LexConfig, defaultConfigValues} from '../LexConfig.js';\nimport {checkLinkedModules, removeFiles} from '../utils/app';\n\njest.mock('esbuild', () => ({\n  ...jest.requireActual('esbuild'),\n  build: jest.fn(() => Promise.resolve({}))\n}));\n\njest.mock('execa', () => ({\n  ...jest.requireActual('execa'),\n  execa: jest.fn(() => Promise.resolve({}))\n}));\n\njest.mock('@luckycatfactory/esbuild-graphql-loader', () => ({\n  ...jest.requireActual('@luckycatfactory/esbuild-graphql-loader'),\n  __esModule: true,\n  default: jest.fn(() => 'esbuildGraphqlLoader')\n}));\n\njest.mock('../utils/app', () => ({\n  ...jest.requireActual('../utils/app'),\n  checkLinkedModules: jest.fn(),\n  removeFiles: jest.fn(() => Promise.resolve())\n}));\n\njest.mock('../LexConfig', () => ({\n  LexConfig: {\n    config: {},\n    checkTypescriptConfig: jest.fn(),\n    parseConfig: jest.fn()\n  }\n}));\n\ndescribe('build', () => {\n  let callback: jest.Mock;\n  let spinner: any;\n  let oldConsole;\n\n  beforeAll(() => {\n    oldConsole = {...console};\n    console = {\n      ...oldConsole,\n      debug: jest.fn(),\n      error: jest.fn(),\n      warn: jest.fn()\n    };\n  });\n\n  beforeEach(() => {\n    LexConfig.config = {\n      ...defaultConfigValues\n    };\n\n    callback = jest.fn();\n    spinner = {\n      succeed: jest.fn(),\n      fail: jest.fn()\n    };\n  });\n\n  afterAll(() => {\n    console = {...oldConsole};\n    jest.resetAllMocks();\n  });\n\n  describe('buildWithEsBuild', () => {\n    beforeEach(() => {\n      (esBuild as jest.Mock).mockImplementation(() => Promise.resolve({}));\n    });\n\n    it('should build using default config', async () => {\n      const status: number = await buildWithEsBuild(spinner, {}, callback);\n      expect(esBuild).toHaveBeenCalledWith({\n        bundle: true,\n        color: true,\n        entryPoints: [undefined],\n        loader: {\n          '.js': 'js'\n        },\n        outdir: undefined,\n        platform: 'node',\n        plugins: [],\n        sourcemap: 'inline',\n        target: 'es2016',\n        watch: false\n      });\n      expect(spinner.succeed).toHaveBeenCalled();\n      expect(spinner.fail).not.toHaveBeenCalled();\n      expect(callback).toHaveBeenCalledWith(0);\n      expect(status).toBe(0);\n    });\n\n    it('should build for node', async () => {\n      LexConfig.config = {\n        ...defaultConfigValues,\n        targetEnvironment: 'node'\n      };\n      const status: number = await buildWithEsBuild(spinner, {}, callback);\n      expect(esBuild).toHaveBeenCalledWith({\n        bundle: true,\n        color: true,\n        entryPoints: [undefined],\n        loader: {\n          '.js': 'js'\n        },\n        outdir: undefined,\n        platform: 'node',\n        plugins: [],\n        sourcemap: 'inline',\n        target: 'node18',\n        watch: false\n      });\n      expect(spinner.succeed).toHaveBeenCalled();\n      expect(spinner.fail).not.toHaveBeenCalled();\n      expect(callback).toHaveBeenCalledWith(0);\n      expect(status).toBe(0);\n    });\n\n    it('should build using typescript', async () => {\n      LexConfig.config = {\n        ...defaultConfigValues,\n        useTypescript: true\n      };\n      const callback = jest.fn();\n      const status: number = await buildWithEsBuild(spinner, {cliName: 'Test'}, callback);\n      expect(esBuild).toHaveBeenCalledWith({\n        bundle: true,\n        color: true,\n        entryPoints: [undefined],\n        loader: {\n          '.js': 'js',\n          '.ts': 'ts',\n          '.tsx': 'tsx'\n        },\n        outdir: undefined,\n        platform: 'node',\n        plugins: [],\n        sourcemap: 'inline',\n        target: 'es2016',\n        watch: false\n      });\n      expect(spinner.succeed).toHaveBeenCalled();\n      expect(spinner.fail).not.toHaveBeenCalled();\n      expect(callback).toHaveBeenCalledWith(0);\n      expect(status).toBe(0);\n    });\n\n    it('should build using graphql', async () => {\n      LexConfig.config = {\n        ...defaultConfigValues,\n        useGraphQl: true\n      };\n      const status: number = await buildWithEsBuild(spinner, {cliName: 'Test'}, callback);\n\n      expect(esBuild).toHaveBeenCalledWith({\n        bundle: true,\n        color: true,\n        entryPoints: [undefined],\n        loader: {\n          '.js': 'js'\n        },\n        outdir: undefined,\n        platform: 'node',\n        plugins: ['esbuildGraphqlLoader'],\n        sourcemap: 'inline',\n        target: 'es2016',\n        watch: false\n      });\n      expect(spinner.succeed).toHaveBeenCalled();\n      expect(spinner.fail).not.toHaveBeenCalled();\n      expect(callback).toHaveBeenCalledWith(0);\n      expect(status).toBe(0);\n    });\n\n    it('should handle errors', async () => {\n      (esBuild as jest.Mock).mockImplementation(() => Promise.reject(new Error('Mock Error')));\n      const status: number = await buildWithEsBuild(spinner, {cliName: 'Test'}, callback);\n\n      expect(spinner.succeed).not.toHaveBeenCalled();\n      expect(spinner.fail).toHaveBeenCalled();\n      expect(callback).toHaveBeenCalledWith(1);\n      expect(status).toBe(1);\n    });\n  });\n\n  describe('buildWithWebpack', () => {\n    beforeEach(() => {\n      (execa as jest.Mock).mockImplementation(() => Promise.resolve({}));\n    });\n\n    it('should build using default config', async () => {\n      const status: number = await buildWithWebpack(spinner, {}, callback);\n      expect(execa).toHaveBeenCalledWith(\n        expect.stringContaining('/node_modules/webpack-cli/bin/cli.js'),\n        [\n          '--color',\n          '--progress',\n          '--config', '/webpack.config.js'\n        ],\n        {encoding: 'utf8', stdio: 'inherit'}\n      );\n      expect(spinner.succeed).toHaveBeenCalled();\n      expect(spinner.fail).not.toHaveBeenCalled();\n      expect(callback).toHaveBeenCalledWith(0);\n      expect(status).toBe(0);\n    });\n\n    it('should build using custom options', async () => {\n      LexConfig.config = {\n        ...defaultConfigValues,\n        useTypescript: true\n      };\n      const callback = jest.fn();\n      const cmd = {\n        analyze: true,\n        cliName: 'Lex',\n        config: 'config.js',\n        configName: 'configName',\n        defineProcessEnvNodeEnv: 'development',\n        devtool: 'devtool',\n        disableInterpret: true,\n        entry: 'entry',\n        env: 'env',\n        failOnWarnings: true,\n        json: 'json',\n        merge: 'merge',\n        mode: 'mode',\n        name: 'name',\n        nodeEnv: 'nodeEnv',\n        noDevtool: true,\n        noStats: true,\n        noTarget: true,\n        noWatch: true,\n        noWatchOptionsStdin: true,\n        outputPath: 'outputPath',\n        quiet: false,\n        stats: 'stats',\n        target: 'target',\n        watch: true,\n        watchOptionsStdin: true\n      };\n      const status: number = await buildWithWebpack(spinner, cmd, callback);\n      expect(execa).toHaveBeenLastCalledWith(\n        expect.stringContaining('/node_modules/webpack-cli/bin/cli.js'),\n        [\n          '--color',\n          '--progress',\n          '--config', 'config.js',\n          '--analyze',\n          '--config-name', 'configName',\n          '--define-process-env-node-env', 'development',\n          '--devtool', 'devtool',\n          '--disable-interpret',\n          '--entry', 'entry',\n          '--env', 'env',\n          '--fail-on-warnings',\n          '--json', 'json',\n          '--mode', 'mode',\n          '--merge',\n          '--name', 'name',\n          '--no-devtool',\n          '--no-stats',\n          '--no-target',\n          '--no-watch',\n          '--no-watch-options-stdin',\n          '--node-env', 'nodeEnv',\n          '--output-path', 'outputPath',\n          '--stats', 'stats',\n          '--target', 'target',\n          '--watch',\n          '--watch-options-stdin'\n        ],\n        {encoding: 'utf8', stdio: 'inherit'}\n      );\n      expect(spinner.succeed).toHaveBeenCalled();\n      expect(spinner.fail).not.toHaveBeenCalled();\n      expect(callback).toHaveBeenCalledWith(0);\n      expect(status).toBe(0);\n    });\n\n    it('should handle errors', async () => {\n      (execa as jest.Mock).mockImplementation(() => Promise.reject(new Error('Mock Error')));\n      const status: number = await buildWithWebpack(spinner, {cliName: 'Test'}, callback);\n\n      expect(spinner.succeed).not.toHaveBeenCalled();\n      expect(spinner.fail).toHaveBeenCalled();\n      expect(callback).toHaveBeenCalledWith(1);\n      expect(status).toBe(1);\n    });\n  });\n\n  describe('build', () => {\n    it('should build with defaults', async () => {\n      const status: number = await build({}, callback);\n      expect(checkLinkedModules).toHaveBeenCalled();\n      expect(callback).toHaveBeenCalledWith(1);\n      expect(status).toBe(1);\n    });\n\n    it('should build with defined props', async () => {\n      LexConfig.config = {\n        ...defaultConfigValues,\n        useTypescript: true\n      };\n      const status: number = await build({\n        bundler: 'esbuild',\n        remove: true\n      }, callback);\n      expect(checkLinkedModules).toHaveBeenCalled();\n      expect(removeFiles).toHaveBeenCalled();\n      expect(LexConfig.checkTypescriptConfig).toHaveBeenCalled();\n      expect(callback).toHaveBeenCalledWith(1);\n      expect(status).toBe(1);\n    });\n\n    it('should error on bad variables value', async () => {\n      const status: number = await build({\n        bundler: 'esbuild',\n        variables: 'test'\n      }, callback);\n      expect(callback).toHaveBeenCalledWith(1);\n      expect(status).toBe(1);\n    });\n  });\n});\n"],
  "mappings": "AAAA,SAAQ,SAAS,eAAc;AAC/B,SAAQ,aAAY;AAEpB,SAAQ,OAAO,kBAAkB,wBAAuB;AACxD,SAAQ,WAAW,2BAA0B;AAC7C,SAAQ,oBAAoB,mBAAkB;AAE9C,KAAK,KAAK,WAAW,OAAO;AAAA,EAC1B,GAAG,KAAK,cAAc,SAAS;AAAA,EAC/B,OAAO,KAAK,GAAG,MAAM,QAAQ,QAAQ,CAAC,CAAC,CAAC;AAC1C,EAAE;AAEF,KAAK,KAAK,SAAS,OAAO;AAAA,EACxB,GAAG,KAAK,cAAc,OAAO;AAAA,EAC7B,OAAO,KAAK,GAAG,MAAM,QAAQ,QAAQ,CAAC,CAAC,CAAC;AAC1C,EAAE;AAEF,KAAK,KAAK,2CAA2C,OAAO;AAAA,EAC1D,GAAG,KAAK,cAAc,yCAAyC;AAAA,EAC/D,YAAY;AAAA,EACZ,SAAS,KAAK,GAAG,MAAM,sBAAsB;AAC/C,EAAE;AAEF,KAAK,KAAK,gBAAgB,OAAO;AAAA,EAC/B,GAAG,KAAK,cAAc,cAAc;AAAA,EACpC,oBAAoB,KAAK,GAAG;AAAA,EAC5B,aAAa,KAAK,GAAG,MAAM,QAAQ,QAAQ,CAAC;AAC9C,EAAE;AAEF,KAAK,KAAK,gBAAgB,OAAO;AAAA,EAC/B,WAAW;AAAA,IACT,QAAQ,CAAC;AAAA,IACT,uBAAuB,KAAK,GAAG;AAAA,IAC/B,aAAa,KAAK,GAAG;AAAA,EACvB;AACF,EAAE;AAEF,SAAS,SAAS,MAAM;AACtB,MAAI;AACJ,MAAI;AACJ,MAAI;AAEJ,YAAU,MAAM;AACd,iBAAa,EAAC,GAAG,QAAO;AACxB,cAAU;AAAA,MACR,GAAG;AAAA,MACH,OAAO,KAAK,GAAG;AAAA,MACf,OAAO,KAAK,GAAG;AAAA,MACf,MAAM,KAAK,GAAG;AAAA,IAChB;AAAA,EACF,CAAC;AAED,aAAW,MAAM;AACf,cAAU,SAAS;AAAA,MACjB,GAAG;AAAA,IACL;AAEA,eAAW,KAAK,GAAG;AACnB,cAAU;AAAA,MACR,SAAS,KAAK,GAAG;AAAA,MACjB,MAAM,KAAK,GAAG;AAAA,IAChB;AAAA,EACF,CAAC;AAED,WAAS,MAAM;AACb,cAAU,EAAC,GAAG,WAAU;AACxB,SAAK,cAAc;AAAA,EACrB,CAAC;AAED,WAAS,oBAAoB,MAAM;AACjC,eAAW,MAAM;AACf,MAAC,QAAsB,mBAAmB,MAAM,QAAQ,QAAQ,CAAC,CAAC,CAAC;AAAA,IACrE,CAAC;AAED,OAAG,qCAAqC,YAAY;AAClD,YAAM,SAAiB,MAAM,iBAAiB,SAAS,CAAC,GAAG,QAAQ;AACnE,aAAO,OAAO,EAAE,qBAAqB;AAAA,QACnC,QAAQ;AAAA,QACR,OAAO;AAAA,QACP,aAAa,CAAC,MAAS;AAAA,QACvB,QAAQ;AAAA,UACN,OAAO;AAAA,QACT;AAAA,QACA,QAAQ;AAAA,QACR,UAAU;AAAA,QACV,SAAS,CAAC;AAAA,QACV,WAAW;AAAA,QACX,QAAQ;AAAA,QACR,OAAO;AAAA,MACT,CAAC;AACD,aAAO,QAAQ,OAAO,EAAE,iBAAiB;AACzC,aAAO,QAAQ,IAAI,EAAE,IAAI,iBAAiB;AAC1C,aAAO,QAAQ,EAAE,qBAAqB,CAAC;AACvC,aAAO,MAAM,EAAE,KAAK,CAAC;AAAA,IACvB,CAAC;AAED,OAAG,yBAAyB,YAAY;AACtC,gBAAU,SAAS;AAAA,QACjB,GAAG;AAAA,QACH,mBAAmB;AAAA,MACrB;AACA,YAAM,SAAiB,MAAM,iBAAiB,SAAS,CAAC,GAAG,QAAQ;AACnE,aAAO,OAAO,EAAE,qBAAqB;AAAA,QACnC,QAAQ;AAAA,QACR,OAAO;AAAA,QACP,aAAa,CAAC,MAAS;AAAA,QACvB,QAAQ;AAAA,UACN,OAAO;AAAA,QACT;AAAA,QACA,QAAQ;AAAA,QACR,UAAU;AAAA,QACV,SAAS,CAAC;AAAA,QACV,WAAW;AAAA,QACX,QAAQ;AAAA,QACR,OAAO;AAAA,MACT,CAAC;AACD,aAAO,QAAQ,OAAO,EAAE,iBAAiB;AACzC,aAAO,QAAQ,IAAI,EAAE,IAAI,iBAAiB;AAC1C,aAAO,QAAQ,EAAE,qBAAqB,CAAC;AACvC,aAAO,MAAM,EAAE,KAAK,CAAC;AAAA,IACvB,CAAC;AAED,OAAG,iCAAiC,YAAY;AAC9C,gBAAU,SAAS;AAAA,QACjB,GAAG;AAAA,QACH,eAAe;AAAA,MACjB;AACA,YAAMA,YAAW,KAAK,GAAG;AACzB,YAAM,SAAiB,MAAM,iBAAiB,SAAS,EAAC,SAAS,OAAM,GAAGA,SAAQ;AAClF,aAAO,OAAO,EAAE,qBAAqB;AAAA,QACnC,QAAQ;AAAA,QACR,OAAO;AAAA,QACP,aAAa,CAAC,MAAS;AAAA,QACvB,QAAQ;AAAA,UACN,OAAO;AAAA,UACP,OAAO;AAAA,UACP,QAAQ;AAAA,QACV;AAAA,QACA,QAAQ;AAAA,QACR,UAAU;AAAA,QACV,SAAS,CAAC;AAAA,QACV,WAAW;AAAA,QACX,QAAQ;AAAA,QACR,OAAO;AAAA,MACT,CAAC;AACD,aAAO,QAAQ,OAAO,EAAE,iBAAiB;AACzC,aAAO,QAAQ,IAAI,EAAE,IAAI,iBAAiB;AAC1C,aAAOA,SAAQ,EAAE,qBAAqB,CAAC;AACvC,aAAO,MAAM,EAAE,KAAK,CAAC;AAAA,IACvB,CAAC;AAED,OAAG,8BAA8B,YAAY;AAC3C,gBAAU,SAAS;AAAA,QACjB,GAAG;AAAA,QACH,YAAY;AAAA,MACd;AACA,YAAM,SAAiB,MAAM,iBAAiB,SAAS,EAAC,SAAS,OAAM,GAAG,QAAQ;AAElF,aAAO,OAAO,EAAE,qBAAqB;AAAA,QACnC,QAAQ;AAAA,QACR,OAAO;AAAA,QACP,aAAa,CAAC,MAAS;AAAA,QACvB,QAAQ;AAAA,UACN,OAAO;AAAA,QACT;AAAA,QACA,QAAQ;AAAA,QACR,UAAU;AAAA,QACV,SAAS,CAAC,sBAAsB;AAAA,QAChC,WAAW;AAAA,QACX,QAAQ;AAAA,QACR,OAAO;AAAA,MACT,CAAC;AACD,aAAO,QAAQ,OAAO,EAAE,iBAAiB;AACzC,aAAO,QAAQ,IAAI,EAAE,IAAI,iBAAiB;AAC1C,aAAO,QAAQ,EAAE,qBAAqB,CAAC;AACvC,aAAO,MAAM,EAAE,KAAK,CAAC;AAAA,IACvB,CAAC;AAED,OAAG,wBAAwB,YAAY;AACrC,MAAC,QAAsB,mBAAmB,MAAM,QAAQ,OAAO,IAAI,MAAM,YAAY,CAAC,CAAC;AACvF,YAAM,SAAiB,MAAM,iBAAiB,SAAS,EAAC,SAAS,OAAM,GAAG,QAAQ;AAElF,aAAO,QAAQ,OAAO,EAAE,IAAI,iBAAiB;AAC7C,aAAO,QAAQ,IAAI,EAAE,iBAAiB;AACtC,aAAO,QAAQ,EAAE,qBAAqB,CAAC;AACvC,aAAO,MAAM,EAAE,KAAK,CAAC;AAAA,IACvB,CAAC;AAAA,EACH,CAAC;AAED,WAAS,oBAAoB,MAAM;AACjC,eAAW,MAAM;AACf,MAAC,MAAoB,mBAAmB,MAAM,QAAQ,QAAQ,CAAC,CAAC,CAAC;AAAA,IACnE,CAAC;AAED,OAAG,qCAAqC,YAAY;AAClD,YAAM,SAAiB,MAAM,iBAAiB,SAAS,CAAC,GAAG,QAAQ;AACnE,aAAO,KAAK,EAAE;AAAA,QACZ,OAAO,iBAAiB,sCAAsC;AAAA,QAC9D;AAAA,UACE;AAAA,UACA;AAAA,UACA;AAAA,UAAY;AAAA,QACd;AAAA,QACA,EAAC,UAAU,QAAQ,OAAO,UAAS;AAAA,MACrC;AACA,aAAO,QAAQ,OAAO,EAAE,iBAAiB;AACzC,aAAO,QAAQ,IAAI,EAAE,IAAI,iBAAiB;AAC1C,aAAO,QAAQ,EAAE,qBAAqB,CAAC;AACvC,aAAO,MAAM,EAAE,KAAK,CAAC;AAAA,IACvB,CAAC;AAED,OAAG,qCAAqC,YAAY;AAClD,gBAAU,SAAS;AAAA,QACjB,GAAG;AAAA,QACH,eAAe;AAAA,MACjB;AACA,YAAMA,YAAW,KAAK,GAAG;AACzB,YAAM,MAAM;AAAA,QACV,SAAS;AAAA,QACT,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,YAAY;AAAA,QACZ,yBAAyB;AAAA,QACzB,SAAS;AAAA,QACT,kBAAkB;AAAA,QAClB,OAAO;AAAA,QACP,KAAK;AAAA,QACL,gBAAgB;AAAA,QAChB,MAAM;AAAA,QACN,OAAO;AAAA,QACP,MAAM;AAAA,QACN,MAAM;AAAA,QACN,SAAS;AAAA,QACT,WAAW;AAAA,QACX,SAAS;AAAA,QACT,UAAU;AAAA,QACV,SAAS;AAAA,QACT,qBAAqB;AAAA,QACrB,YAAY;AAAA,QACZ,OAAO;AAAA,QACP,OAAO;AAAA,QACP,QAAQ;AAAA,QACR,OAAO;AAAA,QACP,mBAAmB;AAAA,MACrB;AACA,YAAM,SAAiB,MAAM,iBAAiB,SAAS,KAAKA,SAAQ;AACpE,aAAO,KAAK,EAAE;AAAA,QACZ,OAAO,iBAAiB,sCAAsC;AAAA,QAC9D;AAAA,UACE;AAAA,UACA;AAAA,UACA;AAAA,UAAY;AAAA,UACZ;AAAA,UACA;AAAA,UAAiB;AAAA,UACjB;AAAA,UAAiC;AAAA,UACjC;AAAA,UAAa;AAAA,UACb;AAAA,UACA;AAAA,UAAW;AAAA,UACX;AAAA,UAAS;AAAA,UACT;AAAA,UACA;AAAA,UAAU;AAAA,UACV;AAAA,UAAU;AAAA,UACV;AAAA,UACA;AAAA,UAAU;AAAA,UACV;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UAAc;AAAA,UACd;AAAA,UAAiB;AAAA,UACjB;AAAA,UAAW;AAAA,UACX;AAAA,UAAY;AAAA,UACZ;AAAA,UACA;AAAA,QACF;AAAA,QACA,EAAC,UAAU,QAAQ,OAAO,UAAS;AAAA,MACrC;AACA,aAAO,QAAQ,OAAO,EAAE,iBAAiB;AACzC,aAAO,QAAQ,IAAI,EAAE,IAAI,iBAAiB;AAC1C,aAAOA,SAAQ,EAAE,qBAAqB,CAAC;AACvC,aAAO,MAAM,EAAE,KAAK,CAAC;AAAA,IACvB,CAAC;AAED,OAAG,wBAAwB,YAAY;AACrC,MAAC,MAAoB,mBAAmB,MAAM,QAAQ,OAAO,IAAI,MAAM,YAAY,CAAC,CAAC;AACrF,YAAM,SAAiB,MAAM,iBAAiB,SAAS,EAAC,SAAS,OAAM,GAAG,QAAQ;AAElF,aAAO,QAAQ,OAAO,EAAE,IAAI,iBAAiB;AAC7C,aAAO,QAAQ,IAAI,EAAE,iBAAiB;AACtC,aAAO,QAAQ,EAAE,qBAAqB,CAAC;AACvC,aAAO,MAAM,EAAE,KAAK,CAAC;AAAA,IACvB,CAAC;AAAA,EACH,CAAC;AAED,WAAS,SAAS,MAAM;AACtB,OAAG,8BAA8B,YAAY;AAC3C,YAAM,SAAiB,MAAM,MAAM,CAAC,GAAG,QAAQ;AAC/C,aAAO,kBAAkB,EAAE,iBAAiB;AAC5C,aAAO,QAAQ,EAAE,qBAAqB,CAAC;AACvC,aAAO,MAAM,EAAE,KAAK,CAAC;AAAA,IACvB,CAAC;AAED,OAAG,mCAAmC,YAAY;AAChD,gBAAU,SAAS;AAAA,QACjB,GAAG;AAAA,QACH,eAAe;AAAA,MACjB;AACA,YAAM,SAAiB,MAAM,MAAM;AAAA,QACjC,SAAS;AAAA,QACT,QAAQ;AAAA,MACV,GAAG,QAAQ;AACX,aAAO,kBAAkB,EAAE,iBAAiB;AAC5C,aAAO,WAAW,EAAE,iBAAiB;AACrC,aAAO,UAAU,qBAAqB,EAAE,iBAAiB;AACzD,aAAO,QAAQ,EAAE,qBAAqB,CAAC;AACvC,aAAO,MAAM,EAAE,KAAK,CAAC;AAAA,IACvB,CAAC;AAED,OAAG,uCAAuC,YAAY;AACpD,YAAM,SAAiB,MAAM,MAAM;AAAA,QACjC,SAAS;AAAA,QACT,WAAW;AAAA,MACb,GAAG,QAAQ;AACX,aAAO,QAAQ,EAAE,qBAAqB,CAAC;AACvC,aAAO,MAAM,EAAE,KAAK,CAAC;AAAA,IACvB,CAAC;AAAA,EACH,CAAC;AACH,CAAC;",
  "names": ["callback"]
}


package/dist/commands/clean.js

@@ -5,7 +5,7 @@ const clean = async (cmd, callback = () => ({})) => {
   const { cliName = "Lex", quiet, snapshots } = cmd;
   const spinner = createSpinner(quiet);
   log(`${cliName} cleaning directory...`, "info", quiet);
-  LexConfig.parseConfig(cmd);
+  await LexConfig.parseConfig(cmd);
   spinner.start("Cleaning files...");
   try {
     await removeModules();
@@ -21,11 +21,11 @@ const clean = async (cmd, callback = () => ({})) => {
     log(`
 ${cliName} Error: ${error.message}`, "error", quiet);
     spinner.fail("Failed to clean project.");
-    callback(error.status);
-    return error.status;
+    callback(1);
+    return 1;
   }
 };
 export {
   clean
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/clean.test.js

@@ -0,0 +1,63 @@
+import { clean } from "./clean";
+import { LexConfig, defaultConfigValues } from "../LexConfig.js";
+import { removeFiles, removeModules } from "../utils/app.js";
+jest.mock("../utils/app", () => ({
+  ...jest.requireActual("../utils/app"),
+  removeFiles: jest.fn(() => Promise.resolve()),
+  removeModules: jest.fn(() => Promise.resolve())
+}));
+jest.mock("../LexConfig", () => ({
+  LexConfig: {
+    config: {},
+    checkTypescriptConfig: jest.fn(),
+    parseConfig: jest.fn()
+  }
+}));
+describe("clean", () => {
+  let callback;
+  let oldConsole;
+  beforeAll(() => {
+    oldConsole = { ...console };
+    console = {
+      ...oldConsole,
+      debug: jest.fn(),
+      error: jest.fn(),
+      warn: jest.fn()
+    };
+  });
+  beforeEach(() => {
+    callback = jest.fn();
+    LexConfig.config = {
+      ...defaultConfigValues
+    };
+  });
+  afterAll(() => {
+    console = { ...oldConsole };
+    jest.resetAllMocks();
+  });
+  it("should clean using default config", async () => {
+    const status = await clean({}, callback);
+    expect(LexConfig.parseConfig).toHaveBeenCalled();
+    expect(removeFiles).toHaveBeenCalled();
+    expect(removeModules).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(0);
+    expect(status).toBe(0);
+  });
+  it("should clean using config", async () => {
+    const status = await clean({
+      snapshots: true
+    }, callback);
+    expect(LexConfig.parseConfig).toHaveBeenCalled();
+    expect(removeFiles).toHaveBeenCalled();
+    expect(removeModules).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(0);
+    expect(status).toBe(0);
+  });
+  it("should error on removing files", async () => {
+    removeFiles.mockImplementation(() => Promise.reject(new Error("Remove Error")));
+    const status = await clean({}, callback);
+    expect(callback).toHaveBeenCalledWith(1);
+    expect(status).toBe(1);
+  });
+});
+//# sourceMappingURL=data:application/json;base64,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