@teambit/lanes 1.0.106 → 1.0.108

package/lanes.restore.route.ts

@@ -0,0 +1,28 @@
+import { Route, Verb, Request, Response } from '@teambit/express';
+import { Logger } from '@teambit/logger';
+import { LanesMain } from './lanes.main.runtime';
+
+export class LanesRestoreRoute implements Route {
+  constructor(private lanes: LanesMain, private logger: Logger) {}
+
+  method = 'post';
+  route = this.lanes.restoreRoutePath;
+  verb = Verb.WRITE;
+
+  middlewares = [
+    async (req: Request, res: Response) => {
+      const { body } = req;
+      const laneHash = body.hash;
+      if (!laneHash) {
+        return res.status(400).send('Missing hash in body');
+      }
+      try {
+        const result = await this.lanes.restoreLane(laneHash);
+        return res.json(result);
+      } catch (e: any) {
+        this.logger.error(e.toString());
+        return res.status(500).send(e.toString());
+      }
+    },
+  ];
+}

package/lanes.spec.ts

@@ -0,0 +1,201 @@
+import { loadAspect } from '@teambit/harmony.testing.load-aspect';
+import SnappingAspect, { SnappingMain } from '@teambit/snapping';
+import { ExportAspect, ExportMain } from '@teambit/export';
+import { mockWorkspace, destroyWorkspace, WorkspaceData } from '@teambit/workspace.testing.mock-workspace';
+import { mockComponents, modifyMockedComponents } from '@teambit/component.testing.mock-components';
+import { ChangeType } from '@teambit/lanes.entities.lane-diff';
+import { LanesAspect } from './lanes.aspect';
+import { LanesMain } from './lanes.main.runtime';
+
+describe('LanesAspect', function () {
+  describe('getLanes()', () => {
+    let lanes: LanesMain;
+    let workspaceData: WorkspaceData;
+    beforeAll(async () => {
+      workspaceData = mockWorkspace();
+      const { workspacePath } = workspaceData;
+      await mockComponents(workspacePath);
+      lanes = await loadAspect(LanesAspect, workspacePath);
+      await lanes.createLane('stage');
+    }, 30000);
+    afterAll(async () => {
+      await destroyWorkspace(workspaceData);
+    });
+    it('should list all lanes', async () => {
+      const currentLanes = await lanes.getLanes({});
+      expect(currentLanes.length).toEqual(1);
+      expect(currentLanes[0].name).toEqual('stage');
+    });
+  });
+
+  describe('isLaneUpToDate', () => {
+    let lanes: LanesMain;
+    let snapping: SnappingMain;
+    let workspaceData: WorkspaceData;
+    beforeAll(async () => {
+      workspaceData = mockWorkspace();
+      const { workspacePath } = workspaceData;
+      await mockComponents(workspacePath);
+      snapping = await loadAspect(SnappingAspect, workspacePath);
+      await snapping.tag({ ids: ['comp1'], build: false, ignoreIssues: 'MissingManuallyConfiguredPackages' });
+      const exporter: ExportMain = await loadAspect(ExportAspect, workspacePath);
+      await exporter.export();
+      lanes = await loadAspect(LanesAspect, workspacePath);
+      await lanes.createLane('stage');
+      await modifyMockedComponents(workspacePath, 'v2');
+      const result = await snapping.snap({
+        pattern: 'comp1',
+        build: false,
+        ignoreIssues: 'MissingManuallyConfiguredPackages',
+      });
+      // intermediate step, make sure it is snapped
+      expect(result?.snappedComponents.length).toEqual(1);
+    }, 30000);
+    afterAll(async () => {
+      await destroyWorkspace(workspaceData);
+    });
+    it('should return that the lane is up to date when the lane is ahead of main', async () => {
+      const currentLane = await lanes.getCurrentLane();
+      if (!currentLane) throw new Error('unable to get the current lane');
+      const isUpToDate = (
+        await lanes.diffStatus(currentLane.toLaneId(), undefined, { skipChanges: true })
+      ).componentsStatus.every((c) => c.upToDate);
+
+      expect(isUpToDate).toEqual(true);
+    });
+    it('should return that the lane is not up to date when main is ahead', async () => {
+      const currentLane = await lanes.getCurrentLane();
+      if (!currentLane) throw new Error('unable to get the current lane');
+      await lanes.switchLanes('main', { skipDependencyInstallation: true });
+      await snapping.snap({
+        pattern: 'comp1',
+        build: false,
+        unmodified: true,
+        ignoreIssues: 'MissingManuallyConfiguredPackages',
+      });
+      const isUpToDate = (
+        await lanes.diffStatus(currentLane.toLaneId(), undefined, { skipChanges: true })
+      ).componentsStatus.every((c) => c.upToDate);
+
+      expect(isUpToDate).toEqual(false);
+    });
+  });
+
+  describe('laneDiff', () => {
+    let lanes: LanesMain;
+    let snapping: SnappingMain;
+    let workspaceData: WorkspaceData;
+    beforeAll(async () => {
+      workspaceData = mockWorkspace();
+      const { workspacePath } = workspaceData;
+      await mockComponents(workspacePath);
+      snapping = await loadAspect(SnappingAspect, workspacePath);
+      await snapping.tag({ ids: ['comp1'], build: false });
+      const exporter: ExportMain = await loadAspect(ExportAspect, workspacePath);
+      await exporter.export();
+      lanes = await loadAspect(LanesAspect, workspacePath);
+      await lanes.createLane('stage');
+      const result = await snapping.snap({ pattern: 'comp1', build: false, unmodified: true });
+      // intermediate step, make sure it is snapped
+      expect(result?.snappedComponents.length).toEqual(1);
+    }, 30000);
+    afterAll(async () => {
+      await destroyWorkspace(workspaceData);
+    });
+    it('should return that the lane is up to date when the lane is ahead of main', async () => {
+      const currentLane = await lanes.getCurrentLane();
+      if (!currentLane) throw new Error('unable to get the current lane');
+      const laneDiffResults = await lanes.diffStatus(currentLane.toLaneId());
+      expect(laneDiffResults.componentsStatus[0].upToDate).toEqual;
+      expect(laneDiffResults.componentsStatus[0].changeType).toEqual(ChangeType.NONE);
+    });
+    it('should return that the lane is not up to date when main is ahead', async () => {
+      const currentLane = await lanes.getCurrentLane();
+      if (!currentLane) throw new Error('unable to get the current lane');
+      await lanes.switchLanes('main', { skipDependencyInstallation: true });
+      await snapping.snap({ pattern: 'comp1', build: false, unmodified: true });
+
+      const laneDiffResults = await lanes.diffStatus(currentLane.toLaneId());
+      expect(laneDiffResults.componentsStatus[0].upToDate).toEqual(false);
+      expect(laneDiffResults.componentsStatus[0].changeType).toEqual(ChangeType.NONE);
+    });
+  });
+
+  describe('restoreLane()', () => {
+    let lanes: LanesMain;
+    let workspaceData: WorkspaceData;
+    beforeAll(async () => {
+      workspaceData = mockWorkspace();
+      const { workspacePath } = workspaceData;
+      await mockComponents(workspacePath);
+      lanes = await loadAspect(LanesAspect, workspacePath);
+      await lanes.createLane('stage');
+
+      // as an intermediate step, make sure the lane was created
+      const currentLanes = await lanes.getLanes({});
+      expect(currentLanes.length).toEqual(1);
+
+      await lanes.switchLanes('main', { skipDependencyInstallation: true });
+      await lanes.removeLanes(['stage']);
+
+      // as an intermediate step, make sure the lane was removed
+      const lanesAfterDelete = await lanes.getLanes({});
+      expect(lanesAfterDelete.length).toEqual(0);
+
+      await lanes.restoreLane(currentLanes[0].hash);
+    }, 30000);
+    afterAll(async () => {
+      await destroyWorkspace(workspaceData);
+    });
+    it('should restore the deleted lane', async () => {
+      const currentLanes = await lanes.getLanes({});
+      expect(currentLanes.length).toEqual(1);
+      expect(currentLanes[0].id.name).toEqual('stage');
+    });
+    describe('delete restored lane', () => {
+      let output: string[];
+      beforeAll(async () => {
+        output = await lanes.removeLanes(['stage']);
+      });
+      it('should not throw', () => {
+        expect(output.length).toEqual(1);
+      });
+    });
+  });
+
+  describe('restore lane when an existing lane has the same id', () => {
+    let lanes: LanesMain;
+    let workspaceData: WorkspaceData;
+    let laneHash: string;
+    beforeAll(async () => {
+      workspaceData = mockWorkspace();
+      const { workspacePath } = workspaceData;
+      await mockComponents(workspacePath);
+      lanes = await loadAspect(LanesAspect, workspacePath);
+      await lanes.createLane('stage');
+
+      // as an intermediate step, make sure the lane was created
+      const currentLanes = await lanes.getLanes({});
+      expect(currentLanes.length).toEqual(1);
+
+      await lanes.switchLanes('main', { skipDependencyInstallation: true });
+      await lanes.removeLanes(['stage']);
+
+      await lanes.createLane('stage');
+      laneHash = currentLanes[0].hash;
+    }, 30000);
+    afterAll(async () => {
+      await destroyWorkspace(workspaceData);
+    });
+    it('should throw when restoring the lane', async () => {
+      let error: Error | undefined;
+      try {
+        await lanes.restoreLane(laneHash);
+      } catch (err: any) {
+        error = err;
+      }
+      expect(error).toBeInstanceOf(Error);
+      expect(error?.message).toMatch(/unable to restore lane/);
+    });
+  });
+});

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/lanes",
-  "version": "1.0.106",
+  "version": "1.0.108",
   "homepage": "https://bit.cloud/teambit/lanes/lanes",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.lanes",
     "name": "lanes",
-    "version": "1.0.106"
+    "version": "1.0.108"
   },
   "dependencies": {
     "lodash": "4.17.21",
@@ -16,8 +16,6 @@
     "graphql-tag": "2.12.1",
     "p-map-series": "2.1.0",
     "p-map": "4.0.0",
-    "core-js": "^3.0.0",
-    "@babel/runtime": "7.20.0",
     "@teambit/bit-error": "0.0.404",
     "@teambit/component-version": "1.0.3",
     "@teambit/lane-id": "0.0.311",
@@ -38,44 +36,40 @@
     "@teambit/ui-foundation.ui.menu": "0.0.502",
     "@teambit/ui-foundation.ui.react-router.slot-router": "0.0.506",
     "@teambit/ui-foundation.ui.react-router.use-query": "0.0.501",
-    "@teambit/scope": "1.0.106",
-    "@teambit/snapping": "1.0.106",
-    "@teambit/workspace": "1.0.106",
-    "@teambit/cli": "0.0.839",
-    "@teambit/express": "0.0.938",
-    "@teambit/logger": "0.0.932",
-    "@teambit/graphql": "1.0.106",
-    "@teambit/checkout": "1.0.106",
-    "@teambit/component-compare": "1.0.106",
-    "@teambit/component-writer": "1.0.106",
-    "@teambit/component": "1.0.106",
-    "@teambit/export": "1.0.106",
-    "@teambit/importer": "1.0.106",
-    "@teambit/lanes.entities.lane-diff": "0.0.164",
+    "@teambit/scope": "1.0.108",
+    "@teambit/snapping": "1.0.108",
+    "@teambit/workspace": "1.0.108",
+    "@teambit/cli": "0.0.840",
+    "@teambit/express": "0.0.939",
+    "@teambit/logger": "0.0.933",
+    "@teambit/graphql": "1.0.108",
+    "@teambit/checkout": "1.0.108",
+    "@teambit/component-compare": "1.0.108",
+    "@teambit/component-writer": "1.0.108",
+    "@teambit/component": "1.0.108",
+    "@teambit/export": "1.0.108",
+    "@teambit/importer": "1.0.108",
     "@teambit/lanes.modules.diff": "0.0.438",
-    "@teambit/merging": "1.0.106",
-    "@teambit/remove": "1.0.106",
-    "@teambit/ui": "1.0.106"
+    "@teambit/merging": "1.0.108",
+    "@teambit/remove": "1.0.108",
+    "@teambit/lanes.entities.lane-diff": "0.0.164",
+    "@teambit/ui": "1.0.108"
   },
   "devDependencies": {
     "@types/lodash": "4.14.165",
-    "@types/react": "^17.0.8",
-    "@types/chai": "4.2.15",
-    "chai": "4.3.0",
     "@types/mocha": "9.1.0",
-    "@types/node": "12.20.4",
-    "@types/react-dom": "^17.0.5",
-    "@types/jest": "^26.0.0",
-    "@types/testing-library__jest-dom": "5.9.5",
-    "@teambit/component.testing.mock-components": "0.0.179",
-    "@teambit/harmony.testing.load-aspect": "0.0.178",
+    "@types/jest": "^29.2.2",
+    "@types/testing-library__jest-dom": "^5.9.5",
+    "@teambit/harmony.envs.core-aspect-env": "0.0.13",
+    "@teambit/component.testing.mock-components": "0.0.180",
+    "@teambit/harmony.testing.load-aspect": "0.0.179",
     "@teambit/workspace.testing.mock-workspace": "0.0.18"
   },
   "peerDependencies": {
-    "react-router-dom": "^6.0.0",
-    "@teambit/legacy": "1.0.624",
-    "react": "^16.8.0 || ^17.0.0",
-    "react-dom": "^16.8.0 || ^17.0.0"
+    "react": "^17.0.0 || ^18.0.0",
+    "react-router-dom": "^6.8.1",
+    "@types/react": "^18.2.12",
+    "@teambit/legacy": "1.0.624"
   },
   "license": "Apache-2.0",
   "optionalDependencies": {},
@@ -89,7 +83,7 @@
   },
   "private": false,
   "engines": {
-    "node": ">=12.22.0"
+    "node": ">=16.0.0"
   },
   "repository": {
     "type": "git",
@@ -98,12 +92,9 @@
   "keywords": [
     "bit",
     "bit-aspect",
+    "bit-core-aspect",
     "components",
     "collaboration",
-    "web",
-    "react",
-    "react-components",
-    "angular",
-    "angular-components"
+    "web"
   ]
 }

package/switch-lanes.ts

@@ -0,0 +1,152 @@
+import { Consumer } from '@teambit/legacy/dist/consumer';
+import { LaneId, DEFAULT_LANE } from '@teambit/lane-id';
+import { ComponentID, ComponentIdList } from '@teambit/component-id';
+import { ApplyVersionResults } from '@teambit/merging';
+import { Lane } from '@teambit/legacy/dist/scope/models';
+import { CheckoutPropsLegacy, CheckoutProps } from '@teambit/checkout';
+import { Workspace } from '@teambit/workspace';
+import { Logger } from '@teambit/logger';
+import { BitError } from '@teambit/bit-error';
+import { LanesMain } from './lanes.main.runtime';
+import { throwForStagedComponents } from './create-lane';
+
+export type SwitchProps = {
+  laneName: string;
+  ids?: ComponentID[];
+  laneBitIds?: ComponentID[]; // only needed for the deprecated onLanesOnly prop. once this prop is removed, this prop can be removed as well.
+  pattern?: string;
+  existingOnWorkspaceOnly: boolean;
+  remoteLane?: Lane;
+  localTrackedLane?: string;
+  alias?: string;
+};
+
+export class LaneSwitcher {
+  private consumer: Consumer;
+  private laneIdToSwitchTo: LaneId; // populated by `this.populateSwitchProps()`
+  private laneToSwitchTo: Lane | undefined; // populated by `this.populateSwitchProps()`, if default-lane, it's undefined
+  constructor(
+    private workspace: Workspace,
+    private logger: Logger,
+    private switchProps: SwitchProps,
+    private checkoutProps: CheckoutPropsLegacy,
+    private Lanes: LanesMain
+  ) {
+    this.consumer = this.workspace.consumer;
+  }
+
+  async switch(): Promise<ApplyVersionResults> {
+    this.logger.setStatusLine(`switching lanes`);
+    if (this.workspace.isOnMain()) {
+      await throwForStagedComponents(this.consumer);
+    }
+    await this.populateSwitchProps();
+    const bitMapIds = this.workspace.consumer.bitmapIdsFromCurrentLaneIncludeRemoved;
+    const idsToSwitch = this.switchProps.ids || [];
+    const idsWithVersion = idsToSwitch.map((id) => {
+      const bitMapId = bitMapIds.searchWithoutVersion(id);
+      return bitMapId || id;
+    });
+    const ids = await this.workspace.resolveMultipleComponentIds(idsWithVersion);
+
+    const checkoutProps: CheckoutProps = {
+      ...this.checkoutProps,
+      ids,
+      allowAddingComponentsFromScope: true,
+      versionPerId: await this.workspace.resolveMultipleComponentIds(idsToSwitch),
+      lane: this.laneToSwitchTo,
+    };
+
+    const results = await this.Lanes.checkout.checkout(checkoutProps);
+
+    await this.saveLanesData();
+    await this.consumer.onDestroy('lane-switch');
+
+    return results;
+  }
+
+  private async populateSwitchProps() {
+    const laneId = await this.consumer.scope.lanes.parseLaneIdFromString(this.switchProps.laneName);
+
+    const localLane = await this.consumer.scope.loadLane(laneId);
+    const mainIds = await this.consumer.getIdsOfDefaultLane();
+    if (laneId.isDefault()) {
+      await this.populatePropsAccordingToDefaultLane();
+      this.switchProps.ids = mainIds;
+    } else {
+      const laneIds = localLane
+        ? this.populatePropsAccordingToLocalLane(localLane)
+        : await this.populatePropsAccordingToRemoteLane(laneId);
+      const idsOnLaneOnly = laneIds.filter((id) => !mainIds.find((i) => i.isEqualWithoutVersion(id)));
+      const idsOnMainOnly = mainIds.filter((id) => !laneIds.find((i) => i.isEqualWithoutVersion(id)));
+      this.switchProps.ids = [...idsOnMainOnly, ...laneIds];
+      this.switchProps.laneBitIds = idsOnLaneOnly;
+    }
+
+    if (this.switchProps.pattern) {
+      if (this.consumer.bitMap.getAllBitIdsFromAllLanes().length) {
+        // if the workspace is not empty, it's possible that it has components from lane-x, and is now switching
+        // partially to lane-y, while lane-y has the same components as lane-x. in which case, the user ends up with
+        // an invalid state of components from lane-x and lane-y together.
+        throw new BitError('error: use --pattern only when the workspace is empty');
+      }
+      const allIds = await this.workspace.resolveMultipleComponentIds(this.switchProps.ids || []);
+      const patternIds = await this.workspace.filterIdsFromPoolIdsByPattern(this.switchProps.pattern, allIds);
+      this.switchProps.ids = patternIds.map((id) => id);
+    }
+  }
+
+  private async populatePropsAccordingToRemoteLane(remoteLaneId: LaneId): Promise<ComponentID[]> {
+    this.laneIdToSwitchTo = remoteLaneId;
+    this.logger.debug(`populatePropsAccordingToRemoteLane, remoteLaneId: ${remoteLaneId.toString()}`);
+    this.throwForSwitchingToCurrentLane();
+    const remoteLane = await this.Lanes.fetchLaneWithItsComponents(remoteLaneId);
+    this.switchProps.laneName = remoteLaneId.name;
+    this.switchProps.localTrackedLane = this.consumer.scope.lanes.getAliasByLaneId(remoteLaneId) || undefined;
+    this.switchProps.remoteLane = remoteLane;
+    this.laneToSwitchTo = remoteLane;
+    this.logger.debug(`populatePropsAccordingToRemoteLane, completed`);
+    return remoteLane.components.map((l) => l.id.changeVersion(l.head.toString()));
+  }
+
+  private async populatePropsAccordingToDefaultLane() {
+    this.laneIdToSwitchTo = LaneId.from(DEFAULT_LANE, this.consumer.scope.name);
+    this.throwForSwitchingToCurrentLane();
+  }
+
+  private populatePropsAccordingToLocalLane(localLane: Lane): ComponentID[] {
+    this.laneIdToSwitchTo = localLane.toLaneId();
+    this.laneToSwitchTo = localLane;
+    this.throwForSwitchingToCurrentLane();
+    return localLane.components.map((c) => c.id.changeVersion(c.head.toString()));
+  }
+
+  private throwForSwitchingToCurrentLane() {
+    if (this.consumer.getCurrentLaneId().isEqual(this.laneIdToSwitchTo)) {
+      const laneIdStr = this.laneIdToSwitchTo.isDefault()
+        ? this.laneIdToSwitchTo.name
+        : this.laneIdToSwitchTo.toString();
+      throw new BitError(`already checked out to "${laneIdStr}".
+to be up to date with the remote lane, please run "bit checkout head""`);
+    }
+  }
+
+  private async saveLanesData() {
+    const localLaneName = this.switchProps.alias || this.laneIdToSwitchTo.name;
+    if (this.switchProps.remoteLane) {
+      if (!this.switchProps.localTrackedLane) {
+        this.consumer.scope.lanes.trackLane({
+          localLane: localLaneName,
+          remoteLane: this.laneIdToSwitchTo.name,
+          remoteScope: this.laneIdToSwitchTo.scope,
+        });
+      }
+    }
+
+    this.consumer.setCurrentLane(this.laneIdToSwitchTo, !this.laneToSwitchTo?.isNew);
+    this.consumer.bitMap.syncWithIds(
+      ComponentIdList.fromArray(this.switchProps.ids || []),
+      ComponentIdList.fromArray(this.switchProps.laneBitIds || [])
+    );
+  }
+}

package/switch.cmd.ts

@@ -0,0 +1,100 @@
+import chalk from 'chalk';
+import { applyVersionReport, installationErrorOutput, compilationErrorOutput } from '@teambit/merging';
+import { Command, CommandOptions } from '@teambit/cli';
+import { MergeStrategy } from '@teambit/legacy/dist/consumer/versions-ops/merge-version';
+import { COMPONENT_PATTERN_HELP } from '@teambit/legacy/dist/constants';
+import { LanesMain } from './lanes.main.runtime';
+
+export class SwitchCmd implements Command {
+  name = 'switch <lane>';
+  description = `switch to the specified lane`;
+  extendedDescription = ``;
+  private = true;
+  alias = '';
+  arguments = [
+    {
+      name: 'lane',
+      description: 'lane-name or lane-id (if lane is not local) to switch to',
+    },
+  ];
+  options = [
+    [
+      'n',
+      'alias <string>',
+      "relevant when the specified lane is a remote lane. create a local alias for the lane (doesnt affect the lane's name on the remote",
+    ],
+    [
+      'm',
+      'merge [strategy]',
+      'merge local changes with the checked out version. strategy should be "theirs", "ours" or "manual"',
+    ],
+    ['a', 'get-all', 'checkout all components in a lane, including those not currently in the workspace'],
+    ['x', 'skip-dependency-installation', 'do not install dependencies of the imported components'],
+    [
+      'p',
+      'pattern <component-pattern>',
+      `switch only the lane components matching the specified component-pattern. only works when the workspace is empty\n
+${COMPONENT_PATTERN_HELP}`,
+    ],
+    ['j', 'json', 'return the output as JSON'],
+  ] as CommandOptions;
+  loader = true;
+
+  constructor(private lanes: LanesMain) {}
+
+  async report(
+    [lane]: [string],
+    {
+      alias,
+      merge,
+      getAll = false,
+      skipDependencyInstallation = false,
+      pattern,
+      json = false,
+    }: {
+      alias?: string;
+      merge?: MergeStrategy;
+      getAll?: boolean;
+      skipDependencyInstallation?: boolean;
+      override?: boolean;
+      pattern?: string;
+      json?: boolean;
+    }
+  ) {
+    const { components, failedComponents, installationError, compilationError } = await this.lanes.switchLanes(lane, {
+      alias,
+      merge,
+      getAll,
+      pattern,
+      skipDependencyInstallation,
+    });
+    if (json) {
+      return JSON.stringify({ components, failedComponents }, null, 4);
+    }
+    const getFailureOutput = () => {
+      if (!failedComponents || !failedComponents.length) return '';
+      const title = 'the switch has been canceled for the following component(s)';
+      const body = failedComponents
+        .map((failedComponent) => {
+          const color = failedComponent.unchangedLegitimately ? 'white' : 'red';
+          return `${chalk.bold(failedComponent.id.toString())} - ${chalk[color](failedComponent.unchangedMessage)}`;
+        })
+        .join('\n');
+      return `${title}\n${body}\n\n`;
+    };
+    const getSuccessfulOutput = () => {
+      const laneSwitched = chalk.green(`\nsuccessfully set "${chalk.bold(lane)}" as the active lane`);
+      if (!components || !components.length) return `No components have been changed.${laneSwitched}`;
+      const title = `successfully switched ${components.length} components to the head of lane ${lane}\n`;
+      return chalk.bold(title) + applyVersionReport(components, true, false) + laneSwitched;
+    };
+    const failedOutput = getFailureOutput();
+    const successOutput = getSuccessfulOutput();
+    return (
+      failedOutput +
+      successOutput +
+      installationErrorOutput(installationError) +
+      compilationErrorOutput(compilationError)
+    );
+  }
+}

package/tsconfig.json

@@ -1,38 +1,33 @@
 {
   "compilerOptions": {
     "lib": [
-      "es2019",
-      "DOM",
-      "ES6",
-      "DOM.Iterable",
-      "ScriptHost"
+      "esnext",
+      "dom",
+      "dom.Iterable"
     ],
-    "target": "es2015",
-    "module": "CommonJS",
-    "jsx": "react",
-    "allowJs": true,
-    "composite": true,
+    "target": "es2020",
+    "module": "es2020",
+    "jsx": "react-jsx",
     "declaration": true,
     "sourceMap": true,
-    "skipLibCheck": true,
     "experimentalDecorators": true,
-    "outDir": "dist",
+    "skipLibCheck": true,
     "moduleResolution": "node",
     "esModuleInterop": true,
-    "rootDir": ".",
     "resolveJsonModule": true,
-    "emitDeclarationOnly": true,
-    "emitDecoratorMetadata": true,
-    "allowSyntheticDefaultImports": true,
-    "strictPropertyInitialization": false,
-    "strict": true,
-    "noImplicitAny": false,
-    "preserveConstEnums": true
+    "allowJs": true,
+    "outDir": "dist",
+    "emitDeclarationOnly": true
   },
   "exclude": [
+    "artifacts",
+    "public",
     "dist",
+    "node_modules",
+    "package.json",
     "esm.mjs",
-    "package.json"
+    "**/*.cjs",
+    "./dist"
   ],
   "include": [
     "**/*",