@teambit/lanes 0.0.126 → 0.0.130

package/dist/lanes.main.runtime.d.ts

@@ -44,6 +44,12 @@ export declare class LanesMain {
         force: boolean;
     }): Promise<string[]>;
     mergeLane(laneName: string, options: MergeLaneOptions): Promise<ApplyVersionResults>;
+    /**
+     * the values array may include zero to two values and will be processed as following:
+     * [] => diff between the current lane and default lane. (only inside workspace).
+     * [to] => diff between the current lane (or default-lane when in scope) and "to" lane.
+     * [from, to] => diff between "from" lane and "to" lane.
+     */
     getDiff(values: string[], diffOptions?: DiffOptions): Promise<{
         newComps: string[];
         compsWithDiff: import("@teambit/legacy/dist/consumer/component-ops/components-diff").DiffResults[];

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/lanes",
-  "version": "0.0.126",
+  "version": "0.0.130",
   "homepage": "https://bit.dev/teambit/lanes/lanes",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.lanes",
     "name": "lanes",
-    "version": "0.0.126"
+    "version": "0.0.130"
   },
   "dependencies": {
     "chalk": "2.4.2",
@@ -14,12 +14,12 @@
     "graphql-tag": "2.12.1",
     "@babel/runtime": "7.12.18",
     "core-js": "^3.0.0",
-    "@teambit/bit-error": "0.0.371",
-    "@teambit/cli": "0.0.385",
-    "@teambit/scope": "0.0.554",
-    "@teambit/workspace": "0.0.554",
-    "@teambit/graphql": "0.0.554",
-    "@teambit/lanes.modules.diff": "0.0.78"
+    "@teambit/bit-error": "0.0.374",
+    "@teambit/cli": "0.0.388",
+    "@teambit/scope": "0.0.558",
+    "@teambit/workspace": "0.0.558",
+    "@teambit/graphql": "0.0.558",
+    "@teambit/lanes.modules.diff": "0.0.81"
   },
   "devDependencies": {
     "@types/mocha": "5.2.7",
@@ -30,7 +30,7 @@
     "@types/node": "12.20.4"
   },
   "peerDependencies": {
-    "@teambit/legacy": "1.0.171",
+    "@teambit/legacy": "1.0.174",
     "react-dom": "^16.8.0 || ^17.0.0",
     "react": "^16.8.0 || ^17.0.0"
   },
@@ -58,12 +58,20 @@
         "react": "-"
       },
       "peerDependencies": {
-        "@teambit/legacy": "1.0.171",
+        "@teambit/legacy": "1.0.174",
         "react-dom": "^16.8.0 || ^17.0.0",
         "react": "^16.8.0 || ^17.0.0"
       }
     }
   },
+  "files": [
+    "dist",
+    "!dist/tsconfig.tsbuildinfo",
+    "README.md",
+    "README.mdx",
+    "*.js",
+    "*.json"
+  ],
   "private": false,
   "engines": {
     "node": ">=12.22.0"

package/tsconfig.json

@@ -15,9 +15,9 @@
     "skipLibCheck": true,
     "moduleResolution": "node",
     "esModuleInterop": true,
-    "outDir": "dist",
     "composite": true,
     "emitDeclarationOnly": true,
+    "outDir": "dist",
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
     "allowSyntheticDefaultImports": true,
@@ -25,7 +25,6 @@
     "strict": true,
     "noImplicitAny": false,
     "rootDir": ".",
-    "removeComments": true,
     "preserveConstEnums": true,
     "resolveJsonModule": true
   },

package/index.ts

@@ -1,5 +0,0 @@
-import { LanesAspect } from './lanes.aspect';
-
-export type { LanesMain } from './lanes.main.runtime';
-export default LanesAspect;
-export { LanesAspect };

package/lane.cmd.ts

@@ -1,365 +0,0 @@
-// eslint-disable-next-line max-classes-per-file
-import chalk from 'chalk';
-import { ScopeMain } from '@teambit/scope';
-import { Workspace } from '@teambit/workspace';
-import { Command, CommandOptions } from '@teambit/cli';
-import { BASE_DOCS_DOMAIN } from '@teambit/legacy/dist/constants';
-import { LaneData } from '@teambit/legacy/dist/scope/lanes/lanes';
-import { getMergeStrategy } from '@teambit/legacy/dist/consumer/versions-ops/merge-version';
-import { mergeReport } from '@teambit/legacy/dist/cli/commands/public-cmds/merge-cmd';
-import { BUILD_ON_CI, isFeatureEnabled } from '@teambit/legacy/dist/api/consumer/lib/feature-toggle';
-import { BitError } from '@teambit/bit-error';
-import { removePrompt } from '@teambit/legacy/dist/prompts';
-import { CreateLaneOptions, LanesMain } from './lanes.main.runtime';
-
-type LaneOptions = {
-  details?: boolean;
-  remote?: string;
-  merged?: boolean;
-  notMerged?: boolean;
-  json?: boolean;
-};
-
-export class LaneListCmd implements Command {
-  name = 'list';
-  description = `list lanes`;
-  alias = '';
-  options = [
-    ['d', 'details', 'show more details on the state of each component in each lane'],
-    ['j', 'json', 'show lanes details in json format'],
-    ['r', 'remote <string>', 'show remote lanes'],
-    ['', 'merged', 'show merged lanes'],
-    ['', 'not-merged', 'show not merged lanes'],
-  ] as CommandOptions;
-  loader = true;
-  private = true;
-  migration = true;
-  remoteOp = true;
-  skipWorkspace = true;
-
-  constructor(private lanes: LanesMain, private workspace: Workspace, private scope: ScopeMain) {}
-
-  async report(args, laneOptions: LaneOptions): Promise<string> {
-    const { details, remote, merged, notMerged } = laneOptions;
-
-    const lanes = await this.lanes.getLanes({
-      remote,
-      merged,
-      notMerged,
-    });
-    if (merged) {
-      const mergedLanes = lanes.filter((l) => l.isMerged);
-      if (!mergedLanes.length) return chalk.green('None of the lanes is merged');
-      return chalk.green(mergedLanes.map((m) => m.name).join('\n'));
-    }
-    if (notMerged) {
-      const unmergedLanes = lanes.filter((l) => !l.isMerged);
-      if (!unmergedLanes.length) return chalk.green('All lanes are merged');
-      return chalk.green(unmergedLanes.map((m) => m.name).join('\n'));
-    }
-    const currentLane = this.lanes.getCurrentLane();
-    let currentLaneStr = currentLane ? `current lane - ${chalk.bold(currentLane as string)}` : '';
-    if (details) {
-      const laneDataOfCurrentLane = lanes.find((l) => l.name === currentLane);
-      const remoteOfCurrentLane = laneDataOfCurrentLane ? laneDataOfCurrentLane.remote : null;
-      const currentLaneComponents = laneDataOfCurrentLane ? outputComponents(laneDataOfCurrentLane.components) : '';
-      if (currentLaneStr) {
-        currentLaneStr += `${outputRemoteLane(remoteOfCurrentLane)}\n${currentLaneComponents}`;
-      }
-    }
-
-    const availableLanes = lanes
-      .filter((l) => l.name !== currentLane)
-      // @ts-ignore
-      .map((laneData) => {
-        if (details) {
-          const laneTitle = `> ${chalk.green(laneData.name)}${outputRemoteLane(laneData.remote)}\n`;
-          const components = outputComponents(laneData.components);
-          return laneTitle + components;
-        }
-        return `    > ${chalk.green(laneData.name)} (${laneData.components.length} components)`;
-      })
-      .join('\n');
-
-    const outputFooter = () => {
-      let footer = '\n';
-      if (details) {
-        footer += 'You can use --merged and --not-merged to see which of the lanes is fully merged.';
-      } else {
-        footer +=
-          "to get more info on all lanes in workspace use 'bit lane list --details' or 'bit lane show <lane-name>' for a specific lane.";
-      }
-      if (!remote && this.workspace) footer += `\nswitch lanes using 'bit switch <name>'.`;
-
-      return footer;
-    };
-
-    return outputCurrentLane() + outputAvailableLanes() + outputFooter();
-
-    function outputCurrentLane() {
-      return currentLaneStr ? `${currentLaneStr}\n` : '';
-    }
-
-    function outputAvailableLanes() {
-      if (!availableLanes) return '';
-      return remote ? `${availableLanes}\n` : `\nAvailable lanes:\n${availableLanes}\n`;
-    }
-  }
-  async json(args, laneOptions: LaneOptions) {
-    const { remote, merged = false, notMerged = false } = laneOptions;
-
-    const lanes = await this.lanes.getLanes({
-      remote,
-      showDefaultLane: true,
-      merged,
-      notMerged,
-    });
-    const currentLane = this.lanes.getCurrentLane();
-    return { lanes, currentLane };
-  }
-}
-
-export class LaneShowCmd implements Command {
-  name = 'show <name>';
-  description = `show lane details`;
-  alias = '';
-  options = [
-    ['j', 'json', 'show the lane details in json format'],
-    ['r', 'remote <string>', 'show remote lanes'],
-  ] as CommandOptions;
-  loader = true;
-  private = true;
-  migration = true;
-  remoteOp = true;
-  skipWorkspace = true;
-
-  constructor(private lanes: LanesMain, private workspace: Workspace, private scope: ScopeMain) {}
-
-  async report([name]: [string], laneOptions: LaneOptions): Promise<string> {
-    const { remote } = laneOptions;
-
-    const lanes = await this.lanes.getLanes({
-      name,
-      remote,
-    });
-
-    const onlyLane = lanes[0];
-    const title = `showing information for ${chalk.bold(name)}${outputRemoteLane(onlyLane.remote)}\n`;
-    return title + outputComponents(onlyLane.components);
-  }
-
-  async json([name]: [string], laneOptions: LaneOptions) {
-    const { remote } = laneOptions;
-
-    const lanes = await this.lanes.getLanes({
-      name,
-      remote,
-    });
-    return lanes[0];
-  }
-}
-
-export class LaneCreateCmd implements Command {
-  name = 'create <name>';
-  description = `create and switch to a new lane`;
-  alias = '';
-  options = [
-    [
-      '',
-      'remote-scope <string>',
-      'remote scope where this lane will be exported to (can be changed later with "bit lane track")',
-    ],
-    [
-      '',
-      'remote-name <string>',
-      'lane name on the remote, default to the local name (can be changed later with "bit lane track")',
-    ],
-  ] as CommandOptions;
-  loader = true;
-  private = true;
-  migration = true;
-
-  constructor(private lanes: LanesMain) {}
-
-  async report([name]: [string], createLaneOptions: CreateLaneOptions): Promise<string> {
-    const result = await this.lanes.createLane(name, createLaneOptions);
-    const remoteScopeOrDefaultScope = createLaneOptions.remoteScope
-      ? `the remote scope ${chalk.bold(createLaneOptions.remoteScope)}`
-      : `the default-scope ${chalk.bold(result.remoteScope)}. to change it, please run "bit lane track" command`;
-    const title = chalk.green(`successfully added a new lane ${chalk.bold(result.localLane)}`);
-    const remoteScopeOutput = `this lane will be exported to ${remoteScopeOrDefaultScope}`;
-    return `${title}\n${remoteScopeOutput}`;
-  }
-}
-
-export class LaneTrackCmd implements Command {
-  name = 'track <local-name> <remote-scope> [remote-name]';
-  description = `change the remote scope or remote lane of the local lane`;
-  alias = '';
-  options = [] as CommandOptions;
-  loader = true;
-  private = true;
-  migration = true;
-
-  constructor(private lanes: LanesMain) {}
-
-  async report([localName, remoteScope, remoteName]: [string, string, string]): Promise<string> {
-    const { beforeTrackData, afterTrackData } = await this.lanes.trackLane(localName, remoteScope, remoteName);
-    const remoteScopeChanges =
-      afterTrackData.remoteScope === beforeTrackData?.remoteScope
-        ? `the remote-scope has not been changed`
-        : `the remote-scope has been changed from ${chalk.bold(
-            beforeTrackData?.remoteScope || '<n/a>'
-          )} to ${chalk.bold(afterTrackData.remoteScope)}`;
-    const remoteNameChanges =
-      afterTrackData.remoteLane === beforeTrackData?.remoteLane
-        ? `the remote-name has not been changed`
-        : `the remote-name has been changed from ${chalk.bold(beforeTrackData?.remoteLane || '<n/a>')} to ${chalk.bold(
-            afterTrackData.remoteLane
-          )}`;
-
-    return `${remoteScopeChanges}\n${remoteNameChanges}`;
-  }
-}
-
-export class LaneMergeCmd implements Command {
-  name = 'merge <lane>';
-  description = `merge a local or a remote lane`;
-  alias = '';
-  options = [
-    ['', 'remote <name>', 'remote scope name'],
-    ['', 'ours', 'in case of a conflict, override the used version with the current modification'],
-    ['', 'theirs', 'in case of a conflict, override the current modification with the specified version'],
-    ['', 'manual', 'in case of a conflict, leave the files with a conflict state to resolve them manually later'],
-    ['', 'existing', 'checkout only components in a lane that exist in the workspace'],
-    ['', 'no-snap', 'do not auto snap in case the merge completed without conflicts'],
-    ['', 'build', 'in case of snap during the merge, run the build-pipeline (similar to bit snap --build)'],
-    ['m', 'message <message>', 'override the default message for the auto snap'],
-  ] as CommandOptions;
-  loader = true;
-  private = true;
-  migration = true;
-  remoteOp = true;
-
-  constructor(private lanes: LanesMain) {}
-
-  async report(
-    [name]: [string],
-    {
-      ours = false,
-      theirs = false,
-      manual = false,
-      remote: remoteName,
-      build,
-      existing: existingOnWorkspaceOnly = false,
-      noSnap = false,
-      message: snapMessage = '',
-    }: {
-      ours: boolean;
-      theirs: boolean;
-      manual: boolean;
-      remote?: string;
-      existing?: boolean;
-      build?: boolean;
-      noSnap: boolean;
-      message: string;
-    }
-  ): Promise<string> {
-    build = isFeatureEnabled(BUILD_ON_CI) ? Boolean(build) : true;
-    const mergeStrategy = getMergeStrategy(ours, theirs, manual);
-    if (noSnap && snapMessage) throw new BitError('unable to use "noSnap" and "message" flags together');
-
-    const results = await this.lanes.mergeLane(name, {
-      // @ts-ignore
-      remoteName,
-      build,
-      // @ts-ignore
-      mergeStrategy,
-      existingOnWorkspaceOnly,
-      noSnap,
-      snapMessage,
-    });
-    return mergeReport(results);
-  }
-}
-
-export class LaneRemoveCmd implements Command {
-  name = 'remove <lane...>';
-  description = `remove lanes`;
-  alias = '';
-  options = [
-    ['r', 'remote', 'remove a remote lane (in the lane arg, use remote/lane-id syntax)'],
-    [
-      'f',
-      'force',
-      'removes the component from the scope, even if used as a dependency. WARNING: components that depend on this component will corrupt',
-    ],
-    ['s', 'silent', 'skip confirmation'],
-  ] as CommandOptions;
-  loader = true;
-  private = true;
-  migration = true;
-
-  constructor(private lanes: LanesMain) {}
-
-  async report(
-    [names]: [string[]],
-    {
-      remote = false,
-      force = false,
-      silent = false,
-    }: {
-      remote: boolean;
-      force: boolean;
-      silent: boolean;
-    }
-  ): Promise<string> {
-    if (!silent) {
-      const removePromptResult = await removePrompt();
-      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
-      if (!yn(removePromptResult.shouldRemove)) {
-        throw new BitError('the operation has been canceled');
-      }
-    }
-    const laneResults = await this.lanes.removeLanes(names, { remote, force });
-    return chalk.green(`successfully removed the following lane(s): ${chalk.bold(laneResults.join(', '))}`);
-  }
-}
-
-export class LaneCmd implements Command {
-  name = 'lane [name]';
-  shortDescription = 'show lanes details';
-  description = `show lanes details
-https://${BASE_DOCS_DOMAIN}/docs/lanes`;
-  alias = '';
-  options = [
-    ['d', 'details', 'show more details on the state of each component in each lane'],
-    ['j', 'json', 'show lanes details in json format'],
-    ['r', 'remote <string>', 'show remote lanes'],
-    ['', 'merged', 'show merged lanes'],
-    ['', 'not-merged', 'show not merged lanes'],
-  ] as CommandOptions;
-  loader = true;
-  private = true;
-  migration = true;
-  remoteOp = true;
-  skipWorkspace = true;
-  commands: Command[] = [];
-
-  constructor(private lanes: LanesMain, private workspace: Workspace, private scope: ScopeMain) {}
-
-  async report([name]: [string], laneOptions: LaneOptions): Promise<string> {
-    return new LaneListCmd(this.lanes, this.workspace, this.scope).report([name], laneOptions);
-  }
-}
-
-function outputComponents(components: LaneData['components']): string {
-  const componentsTitle = `\tcomponents (${components.length})\n`;
-  const componentsStr = components.map((c) => `\t  ${c.id.toString()} - ${c.head}`).join('\n');
-  return componentsTitle + componentsStr;
-}
-
-function outputRemoteLane(remoteLane: string | null | undefined): string {
-  if (!remoteLane) return '';
-  return ` - (remote lane - ${remoteLane})`;
-}

package/lanes.aspect.ts

@@ -1,5 +0,0 @@
-import { Aspect } from '@teambit/harmony';
-
-export const LanesAspect = Aspect.create({
-  id: 'teambit.lanes/lanes',
-});

package/lanes.docs.md

@@ -1,80 +0,0 @@
-See more details about these two features here: [Lanes](https://github.com/teambit/bit/issues/1986). [Snaps](https://github.com/teambit/bit/issues/1985).
-
-The following describes the final implementation, which differs from the specification above.
-
-## Synopsis
-
-- create a snap: `bit snap` (synopsis similar to the `bit tag`).
-- create a new lane: `bit lane create <name>`
-- list lanes: `bit lane list`.
-- switch between lanes: `bit switch <name>`
-- merge lanes: `bit lane merge`.
-- show lane details: `bit lane show <name>`
-- diff between lanes: `bit lane diff <values>`
-- track local lane to a remote lane: `bit switch --as`
-- remove a lane `bit lane remove <name>`.
-- fetch lane objects (without the components): `bit fetch --lanes`.
-- import a lane: `bit switch <name> --remote`.
-- export current lane: `bit export`.
-- (internal) cat lane object: `bit cat-lane <name>`.
-
-## Remaining tasks
-
-- [ ] Remove components from a remote lane.
-- [ ] Bit import with no args. When bitmap has a remote lane, should import the lane.
-- [ ] Tag dependencies to include them in a lane.
-- [ ] Test bit-fetch components
-- [ ] Rename lanes.
-- [ ] Fix performance issue. Now it fetches all parents every time. It doesn't make sense.
-- [ ] Fix performance issue. Now it traverses all parents to see if a hash in there.
-
-## Important points
-
-### Performance consideration
-
-Currently, if it imports with no-deps, it doesn't ask for parents, if it imports with deps it imports with all parents. It is originated from src/api/scope/lib/fetch.ts: `const collectParents = !noDependencies;`. We need to make a decision here.
-
-### Model changes
-
-- `Version.parents`. This is added only if the lanes feature is enabled. (it doesn't change the hash).
-- `Component.head` This is added only if the lanes feature is enabled. (it doesn't change the hash).
-
-### Hash
-
-- Snap's hash is generated by a UUID and then converted into sha1. `sha1(v4())`.
-- Lane's hash is generated by a UUID and then converted into sha1. `sha1(v4())`.
-- Tag's hash stays the same. Generated by the `Version.id()`.
-
-### Lane Data
-
-Lane data, for the most cases is a map of component-id:snap-head, in other words, it saves per component the head snap. There are 3 different places where we store such data for different purposes.
-
-- `lane-object` "Lane" is saved in the scope `.bit/objects` (.bit can be .git/bit locally), it has a unique hash and contains a map of components and their heads. This object exists on both local and remote scopes. Its main purpose is to sync lane-data between scopes. See `Lane` class (in scope/model) for the implementation details.
-- `workspace-lane` (component and their heads) is saved in `.bit/workspace/lanes/lane-name`. Remote scopes don't have this data. Its main purpose is to store data that exists only locally and does not exist on the remote. See `WorkspaceLane` class for the implementation details.
-- `remote-lane` (component and their heads) is saved in `.bit/refs/remote/remote-name/lane-name`. These refs files are saved in both, local and remote scopes. Its main purpose is to keep track where the remote-heads are per lane. See `RemoteLanes` class for the implementation details.
-
-More places that stores lanes related data:
-
-- the currently checked out lane is saved in the scope.json file. (e.g. `{ lanes: { current: "lane-a", tracking: "remote/lane-a" } }`).
-- When switching to a remote lane, the .bitmap is updated as well with the remote-name, so then, when cloning the project, it's possible to fetch the remote lane data.
-
-Summary of when/what lanes data is saved per command:
-
-- `bit lane create`: creates a new lane-object and creates a new lane record in scope.json.
-- `bit snap`: adds an entry to the lane-object and to the workspace-lane.
-- `bit export`: 1) deletes all records from workspace-lane (as they're in sync with the remote). 2) pushes the lane-object to the remote. On the remote, the lane-object is created or updated/merged.
-- `bit switch --remote`: 1) creates/updates lane-object in the scope. 2) creates/updates remote-lane. the remote-lane is updated also for main.
-- `bit fetch` or `bit import --objects`: creates/updates remote-lane. the remote-lane is updated also for main. It doesn't update/merge the lane object.
-
-### Merge during import
-
-- When the remote is ahead, it's easy, just update the head to the remote-head.
-- When the local and remote have diverged, it's more complex. We need to create a snap-merge that has two parents, one point to the local head and one point to the remote head.
-- On `bit import --objects` (or `bit fetch`) we don't merge. The remote head is saved in the .bit/refs/remote dir. Then, `bit status` shows that these components are merge-pending.
-- On `bit import <id>` we do the merge.
-- in case the merge wasn't done and the user is trying to export, the remote blocks is as it finds out that its head doesn't exist on the incoming component.
-- in case the snap-merge failed due to a conflict, it saves the conflict and heads data into `.bit/unmerged.json` file.
-
-### Useful APIs
-
-- bit-map `getAllIdsAvailableOnLane()` filters the currently checked out lane.

package/lanes.graphql.ts

@@ -1,93 +0,0 @@
-import { Schema } from '@teambit/graphql';
-import gql from 'graphql-tag';
-import { LanesMain } from './lanes.main.runtime';
-
-export function lanesSchema(lanesMain: LanesMain): Schema {
-  return {
-    typeDefs: gql`
-      type CompLaneData {
-        id: String!
-        head: String!
-      }
-
-      type LanesData {
-        name: String!
-        components: [CompLaneData]
-        isMerged: Boolean
-      }
-
-      type FileDiff {
-        filePath: String!
-        diffOutput: String
-      }
-
-      type FieldsDiff {
-        fieldName: String!
-        diffOutput: String
-      }
-
-      type DiffResults {
-        id: String
-        hasDiff: Boolean
-        filesDiff: [FileDiff]
-        fieldsDiff: [FieldsDiff]
-      }
-
-      type GetDiffResult {
-        newComps: [String]
-        compsWithNoChanges: [String]
-        toLaneName: String
-        compsWithDiff: [DiffResults]
-      }
-
-      input DiffOptions {
-        color: Boolean
-      }
-
-      type Lanes {
-        getLanes: [LanesData]
-        getLaneByName(name: String): LanesData
-        getCurrentLaneName: String
-        getDiff(values: [String], options: DiffOptions): GetDiffResult
-      }
-
-      type Query {
-        lanes: Lanes
-      }
-    `,
-    resolvers: {
-      Lanes: {
-        getLanes: async (lanes: LanesMain) => {
-          const lanesResults = await lanes.getLanes({});
-          return lanesResults.map((lane) => ({
-            name: lane.name,
-            components: lane.components.map((c) => ({ id: c.id.toString(), head: c.head.toString() })),
-            isMerged: Boolean(lane.isMerged),
-          }));
-        },
-        getLaneByName: async (lanes: LanesMain, { name }: { name: string }) => {
-          const lanesResults = await lanes.getLanes({ name });
-          const laneResult = lanesResults[0];
-          return {
-            name: laneResult.name,
-            components: laneResult.components.map((c) => ({ id: c.id.toString(), head: c.head.toString() })),
-            isMerged: Boolean(laneResult.isMerged),
-          };
-        },
-        getCurrentLaneName: (lanes: LanesMain) => {
-          return lanes.getCurrentLane();
-        },
-        getDiff: async (lanes: LanesMain, { values, options }: { values: string[]; options: { color?: boolean } }) => {
-          const getDiffResults = await lanes.getDiff(values, options);
-          return {
-            ...getDiffResults,
-            compsWithDiff: getDiffResults.compsWithDiff.map((item) => ({ ...item, id: item.id.toString() })),
-          };
-        },
-      },
-      Query: {
-        lanes: () => lanesMain,
-      },
-    },
-  };
-}

package/lanes.main.runtime.ts

@@ -1,196 +0,0 @@
-import { CLIAspect, CLIMain, MainRuntime } from '@teambit/cli';
-import { ScopeMain, ScopeAspect } from '@teambit/scope';
-import { GraphqlAspect, GraphqlMain } from '@teambit/graphql';
-import { Workspace, WorkspaceAspect } from '@teambit/workspace';
-import getRemoteByName from '@teambit/legacy/dist/remotes/get-remote-by-name';
-import { LaneDiffCmd, LaneDiffGenerator } from '@teambit/lanes.modules.diff';
-import { LaneData } from '@teambit/legacy/dist/scope/lanes/lanes';
-import LaneId from '@teambit/legacy/dist/lane-id/lane-id';
-import { BitError } from '@teambit/bit-error';
-import createNewLane from '@teambit/legacy/dist/consumer/lanes/create-lane';
-import { mergeLanes } from '@teambit/legacy/dist/consumer/lanes/merge-lanes';
-import { DEFAULT_LANE } from '@teambit/legacy/dist/constants';
-import { DiffOptions } from '@teambit/legacy/dist/consumer/component-ops/components-diff';
-import { MergeStrategy, ApplyVersionResults } from '@teambit/legacy/dist/consumer/versions-ops/merge-version';
-import { TrackLane } from '@teambit/legacy/dist/scope/scope-json';
-import removeLanes from '@teambit/legacy/dist/consumer/lanes/remove-lanes';
-import { LanesAspect } from './lanes.aspect';
-import {
-  LaneCmd,
-  LaneCreateCmd,
-  LaneListCmd,
-  LaneMergeCmd,
-  LaneRemoveCmd,
-  LaneShowCmd,
-  LaneTrackCmd,
-} from './lane.cmd';
-import { lanesSchema } from './lanes.graphql';
-
-export type LaneResults = {
-  lanes: LaneData[];
-  currentLane?: string | null;
-};
-
-export type MergeLaneOptions = {
-  remoteName: string | null;
-  mergeStrategy: MergeStrategy;
-  noSnap: boolean;
-  snapMessage: string;
-  existingOnWorkspaceOnly: boolean;
-  build: boolean;
-};
-
-export type CreateLaneOptions = {
-  remoteScope?: string; // default to the defaultScope in workspace.jsonc
-  remoteName?: string; // default to the local lane
-};
-
-export class LanesMain {
-  constructor(private workspace: Workspace | undefined, private scope: ScopeMain) {}
-
-  async getLanes({
-    name,
-    remote,
-    merged,
-    showDefaultLane,
-    notMerged,
-  }: {
-    name?: string;
-    remote?: string;
-    merged?: boolean;
-    showDefaultLane?: boolean;
-    notMerged?: boolean;
-  }): Promise<LaneData[]> {
-    const showMergeData = Boolean(merged || notMerged);
-    const consumer = this.workspace?.consumer;
-    if (remote) {
-      const remoteObj = await getRemoteByName(remote, consumer);
-      const lanes = await remoteObj.listLanes(name, showMergeData);
-      return lanes;
-    }
-    const lanes = await this.scope.legacyScope.lanes.getLanesData(this.scope.legacyScope, name, showMergeData);
-
-    if (showDefaultLane) {
-      const defaultLane = this.getLaneDataOfDefaultLane();
-      if (defaultLane) lanes.push(defaultLane);
-    }
-
-    return lanes;
-  }
-
-  getCurrentLane(): string | null {
-    if (!this.workspace?.consumer) return null;
-    return this.scope.legacyScope.lanes.getCurrentLaneName();
-  }
-
-  async createLane(name: string, { remoteScope, remoteName }: CreateLaneOptions): Promise<TrackLane> {
-    if (!this.workspace) {
-      throw new BitError(`unable to create a lane outside of Bit workspace`);
-    }
-    await createNewLane(this.workspace.consumer, name);
-    this.scope.legacyScope.lanes.setCurrentLane(name);
-    const trackLaneData = {
-      localLane: name,
-      remoteLane: remoteName || name,
-      remoteScope: remoteScope || this.workspace.defaultScope,
-    };
-    this.scope.legacyScope.lanes.trackLane(trackLaneData);
-    await this.workspace.consumer.onDestroy();
-
-    return trackLaneData;
-  }
-
-  async trackLane(
-    localName: string,
-    remoteScope: string,
-    remoteName?: string
-  ): Promise<{ beforeTrackData?: TrackLane; afterTrackData: TrackLane }> {
-    if (!this.workspace) {
-      throw new BitError(`unable to track a lane outside of Bit workspace`);
-    }
-    const lane = await this.scope.legacyScope.lanes.loadLane(LaneId.from(localName));
-    if (!lane) {
-      throw new BitError(`unable to find a local lane "${localName}"`);
-    }
-    const beforeTrackData = this.scope.legacyScope.lanes.getRemoteTrackedDataByLocalLane(localName);
-    const beforeTrackDataCloned = beforeTrackData ? { ...beforeTrackData } : undefined;
-    const afterTrackData = {
-      localLane: localName,
-      remoteLane: remoteName || beforeTrackData?.remoteLane || localName,
-      remoteScope,
-    };
-    this.scope.legacyScope.lanes.trackLane(afterTrackData);
-    await this.workspace.consumer.onDestroy();
-
-    return { beforeTrackData: beforeTrackDataCloned, afterTrackData };
-  }
-
-  async removeLanes(laneNames: string[], { remote, force }: { remote: boolean; force: boolean }): Promise<string[]> {
-    const results = await removeLanes(this.workspace?.consumer, laneNames, remote, force);
-    if (this.workspace) await this.workspace.consumer.onDestroy();
-
-    return results.laneResults;
-  }
-
-  async mergeLane(laneName: string, options: MergeLaneOptions): Promise<ApplyVersionResults> {
-    if (!this.workspace) {
-      throw new BitError(`unable to merge a lane outside of Bit workspace`);
-    }
-    const mergeResults = await mergeLanes({
-      consumer: this.workspace.consumer,
-      laneName,
-      ...options,
-    });
-    await this.workspace.consumer.onDestroy();
-
-    return mergeResults;
-  }
-
-  /**
-   * the values array may include zero to two values and will be processed as following:
-   * [] => diff between the current lane and default lane. (only inside workspace).
-   * [to] => diff between the current lane (or default-lane when in scope) and "to" lane.
-   * [from, to] => diff between "from" lane and "to" lane.
-   */
-  public getDiff(values: string[], diffOptions: DiffOptions = {}) {
-    const laneDiffGenerator = new LaneDiffGenerator(this.workspace, this.scope);
-    return laneDiffGenerator.generate(values, diffOptions);
-  }
-
-  private getLaneDataOfDefaultLane(): LaneData | null {
-    const consumer = this.workspace?.consumer;
-    if (!consumer) return null;
-    const bitIds = consumer.bitMap.getAuthoredAndImportedBitIdsOfDefaultLane();
-    return {
-      name: DEFAULT_LANE,
-      remote: null,
-      components: bitIds.map((bitId) => ({ id: bitId, head: bitId.version as string })),
-      isMerged: null,
-    };
-  }
-
-  static slots = [];
-  static dependencies = [CLIAspect, ScopeAspect, WorkspaceAspect, GraphqlAspect];
-  static runtime = MainRuntime;
-  static async provider([cli, scope, workspace, graphql]: [CLIMain, ScopeMain, Workspace, GraphqlMain]) {
-    const lanesMain = new LanesMain(workspace, scope);
-    const isLegacy = workspace && workspace.consumer.isLegacy;
-    if (!isLegacy) {
-      const laneCmd = new LaneCmd(lanesMain, workspace, scope);
-      laneCmd.commands = [
-        new LaneListCmd(lanesMain, workspace, scope),
-        new LaneShowCmd(lanesMain, workspace, scope),
-        new LaneCreateCmd(lanesMain),
-        new LaneMergeCmd(lanesMain),
-        new LaneRemoveCmd(lanesMain),
-        new LaneTrackCmd(lanesMain),
-        new LaneDiffCmd(workspace, scope),
-      ];
-      cli.register(laneCmd);
-      graphql.register(lanesSchema(lanesMain));
-    }
-    return lanesMain;
-  }
-}
-
-LanesAspect.addRuntime(LanesMain);

package/types/asset.d.ts

@@ -1,29 +0,0 @@
-declare module '*.png' {
-  const value: any;
-  export = value;
-}
-declare module '*.svg' {
-  import type { FunctionComponent, SVGProps } from 'react';
-
-  export const ReactComponent: FunctionComponent<SVGProps<SVGSVGElement> & { title?: string }>;
-  const src: string;
-  export default src;
-}
-
-// @TODO Gilad
-declare module '*.jpg' {
-  const value: any;
-  export = value;
-}
-declare module '*.jpeg' {
-  const value: any;
-  export = value;
-}
-declare module '*.gif' {
-  const value: any;
-  export = value;
-}
-declare module '*.bmp' {
-  const value: any;
-  export = value;
-}

package/types/style.d.ts

@@ -1,42 +0,0 @@
-declare module '*.module.css' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-declare module '*.module.scss' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-declare module '*.module.sass' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.module.less' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.less' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.css' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.sass' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.scss' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.mdx' {
-  const component: any;
-  export default component;
-}