@teambit/insights 0.0.566 → 0.0.570

package/all-insights/duplicate-dependencies.ts

@@ -0,0 +1,149 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { GraphBuilder, VersionSubgraph } from '@teambit/graph';
+import { rcompare } from 'semver';
+// import { ComponentID } from '../../../component/component-id';
+import { ComponentID } from '@teambit/component';
+import { Insight, InsightResult, RawResult } from '../insight';
+// import NoDataForInsight from '../exceptions/no-data-for-insight';
+
+export const INSIGHT_NAME = 'duplicate dependencies';
+
+type Dependent = {
+  id: string;
+  usedVersion: string;
+};
+
+type VersionWithDependents = {
+  version: string;
+  compId: string;
+  dependents: Dependent[];
+};
+
+type FormattedEntry = {
+  dependencyId: string;
+  latestVersion: string;
+  totalOutdatedDependents: string;
+  dependentsByVersion: VersionWithDependents[];
+};
+export default class DuplicateDependencies implements Insight {
+  name = INSIGHT_NAME;
+  description = 'Get all duplicate dependencies in component graph';
+  graphBuilder: GraphBuilder;
+  constructor(graphBuilder: GraphBuilder) {
+    this.graphBuilder = graphBuilder;
+  }
+  private async runInsight(): Promise<RawResult> {
+    const graph = await this.graphBuilder.getGraph();
+    if (!graph) {
+      return {
+        message: 'No graph found',
+        data: undefined,
+      };
+    }
+    const duplicates = graph.findDuplicateDependencies();
+    const lenDependencies = [...duplicates.keys()].length;
+    if (lenDependencies === 1) {
+      return {
+        message: `Found ${lenDependencies} duplicate dependency.`,
+        data: duplicates,
+      };
+    }
+    return {
+      message: `Found ${lenDependencies} duplicate dependencies.`,
+      data: duplicates,
+    };
+  }
+
+  private formatData(data: any): FormattedEntry[] {
+    const formatted: FormattedEntry[] = [];
+    for (const [dependency, depData] of data.entries()) {
+      const { totalOutdatedDependents, dependentsByVersion } = this.getDependents(depData.priorVersions);
+      formatted.push({
+        dependencyId: dependency,
+        latestVersion: depData.latestVersionId,
+        totalOutdatedDependents: totalOutdatedDependents.toString(),
+        dependentsByVersion,
+      });
+    }
+    return formatted;
+  }
+
+  private getDependents(
+    priorVersions: VersionSubgraph[]
+  ): { totalOutdatedDependents: number; dependentsByVersion: VersionWithDependents[] } {
+    let totalOutdatedDependents = 0;
+    const dependentsByVersion: VersionWithDependents[] = [];
+    priorVersions.forEach((pVersion: VersionSubgraph) => {
+      const dependents: Dependent[] = [];
+      const version = ComponentID.fromString(pVersion.versionId).version || pVersion.versionId.split('@')[1];
+      pVersion.immediateDependents.forEach((dependent: string) => {
+        dependents.push({
+          id: dependent,
+          usedVersion: pVersion.versionId,
+        });
+      });
+      dependentsByVersion.push({
+        compId: pVersion.versionId,
+        version,
+        dependents,
+      });
+      totalOutdatedDependents += pVersion.immediateDependents.length;
+    });
+    dependentsByVersion.sort(this.revreseCompareVersions);
+    return { totalOutdatedDependents, dependentsByVersion };
+  }
+
+  revreseCompareVersions(v1: VersionWithDependents, v2: VersionWithDependents) {
+    return rcompare(v1.version, v2.version);
+  }
+
+  private stringifyDependents(dependents: Dependent[]): string {
+    const string = dependents
+      .map((dependent) => {
+        return `- ${dependent.id} => ${dependent.usedVersion}`;
+      })
+      .join('\n');
+    return string;
+  }
+
+  private stringifyDependentsByVersion(versions: VersionWithDependents[]): string {
+    const string = versions
+      .map((version) => {
+        return `- ${version.compId} has ${version.dependents.length} dependents`;
+      })
+      .join('\n');
+    return string;
+  }
+
+  private renderData(data: FormattedEntry[]) {
+    const string = data
+      .map((obj) => {
+        return `\n\nFound ${obj.totalOutdatedDependents} outdated dependents for ${obj.dependencyId}
+The latest version is "${obj.latestVersion}"
+Outdated dependents:
+${this.stringifyDependentsByVersion(obj.dependentsByVersion)}`;
+      })
+      .join('\n');
+    return string;
+  }
+
+  async run(): Promise<InsightResult> {
+    const bareResult = await this.runInsight();
+    const formattedData = this.formatData(bareResult.data);
+    const renderedData = this.renderData(formattedData);
+    const result: InsightResult = {
+      metaData: {
+        name: this.name,
+        description: this.description,
+      },
+      data: formattedData,
+      message: bareResult.message,
+      renderedData,
+    };
+
+    if (bareResult.message) {
+      result.message = bareResult.message;
+    }
+    return result;
+  }
+}

package/all-insights/find-cycles.ts

@@ -0,0 +1,66 @@
+import { GraphBuilder } from '@teambit/graph';
+import { Insight, InsightResult, RawResult } from '../insight';
+
+export const INSIGHT_NAME = 'cyclic dependencies';
+
+export default class FindCycles implements Insight {
+  name = INSIGHT_NAME;
+  description = 'Get all cyclic dependencies in component graph';
+  graphBuilder: GraphBuilder;
+  constructor(graphBuilder: GraphBuilder) {
+    this.graphBuilder = graphBuilder;
+  }
+  private async runInsight(): Promise<RawResult> {
+    const graph = await this.graphBuilder.getGraph();
+    if (!graph) {
+      return {
+        message: '',
+        data: undefined,
+      };
+    }
+    const cycles = graph.findCycles();
+    if (cycles.length === 1) {
+      return {
+        message: `Found ${cycles.length} cycle.`,
+        data: cycles,
+      };
+    }
+    return {
+      message: `Found ${cycles.length} cycles.`,
+      data: cycles,
+    };
+  }
+
+  private renderData(data: RawResult) {
+    if (data.data.length === 0) {
+      return 'No cyclic dependencies';
+    }
+    const string = data.data
+      .map((cycle) => {
+        return `\nCyclic dependency
+-----------------
+- ${cycle.join('\n- ')}`;
+      })
+      .join('\n');
+    return string;
+  }
+
+  async run(): Promise<InsightResult> {
+    const bareResult = await this.runInsight();
+    const renderedData = this.renderData(bareResult);
+    const result: InsightResult = {
+      metaData: {
+        name: this.name,
+        description: this.description,
+      },
+      data: bareResult.data,
+      message: bareResult.message,
+      renderedData,
+    };
+
+    if (bareResult.message) {
+      result.message = bareResult.message;
+    }
+    return result;
+  }
+}

package/exceptions/insight-already-exists.ts

@@ -0,0 +1,7 @@
+import { BitError } from '@teambit/bit-error';
+
+export default class InsightAlreadyExists extends BitError {
+  constructor(readonly insightName: string) {
+    super(`Insight ${insightName} already exists`);
+  }
+}

package/exceptions/insight-not-found.ts

@@ -0,0 +1,7 @@
+import { BitError } from '@teambit/bit-error';
+
+export default class InsightNotFound extends BitError {
+  constructor(readonly insightName: string) {
+    super(`Insight ${insightName} not found`);
+  }
+}

package/exceptions/no-data-for-insight.ts

@@ -0,0 +1,7 @@
+import { BitError } from '@teambit/bit-error';
+
+export default class NoDataForInsight extends BitError {
+  constructor(readonly insightName: string) {
+    super(`No data for ${insightName}`);
+  }
+}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/insights",
-  "version": "0.0.566",
+  "version": "0.0.570",
   "homepage": "https://bit.dev/teambit/explorer/insights",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.explorer",
     "name": "insights",
-    "version": "0.0.566"
+    "version": "0.0.570"
   },
   "dependencies": {
     "@teambit/harmony": "0.2.11",
@@ -14,10 +14,10 @@
     "semver": "7.3.4",
     "@babel/runtime": "7.12.18",
     "core-js": "^3.0.0",
-    "@teambit/graph": "0.0.566",
-    "@teambit/cli": "0.0.393",
-    "@teambit/component": "0.0.566",
-    "@teambit/bit-error": "0.0.379"
+    "@teambit/graph": "0.0.570",
+    "@teambit/cli": "0.0.395",
+    "@teambit/component": "0.0.570",
+    "@teambit/bit-error": "0.0.381"
   },
   "devDependencies": {
     "@types/semver": "7.3.4",
@@ -29,7 +29,7 @@
     "@types/node": "12.20.4"
   },
   "peerDependencies": {
-    "@teambit/legacy": "1.0.179",
+    "@teambit/legacy": "1.0.181",
     "react-dom": "^16.8.0 || ^17.0.0",
     "react": "^16.8.0 || ^17.0.0"
   },
@@ -57,27 +57,12 @@
         "react": "-"
       },
       "peerDependencies": {
-        "@teambit/legacy": "1.0.179",
+        "@teambit/legacy": "1.0.181",
         "react-dom": "^16.8.0 || ^17.0.0",
         "react": "^16.8.0 || ^17.0.0"
       }
     }
   },
-  "files": [
-    "dist",
-    "!dist/tsconfig.tsbuildinfo",
-    "**/*.md",
-    "**/*.mdx",
-    "**/*.js",
-    "**/*.json",
-    "**/*.sass",
-    "**/*.scss",
-    "**/*.less",
-    "**/*.css",
-    "**/*.css",
-    "**/*.jpeg",
-    "**/*.gif"
-  ],
   "private": false,
   "engines": {
     "node": ">=12.22.0"

package/types/asset.d.ts

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,42 @@
+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;
+}