@teambit/component-issues 0.0.0-de14d08f36c2ec7aca9f216f61bc447c5aeb9859

package/issues-list.ts

@@ -0,0 +1,172 @@
+import { ComponentIssue, IssueObject } from './component-issue';
+import { ImportNonMainFiles } from './import-non-main-files';
+import { MissingDependenciesOnFs } from './missing-dependencies-on-fs';
+import { MissingDists } from './missing-dists';
+import { MissingPackagesDependenciesOnFs } from './missing-packages-dependencies-on-fs';
+import { MissingManuallyConfiguredPackages } from './missing-manually-configured-packages';
+import { ParseErrors } from './parse-errors';
+import { RelativeComponents } from './relative-components';
+import { RelativeComponentsAuthored } from './relative-components-authored';
+import { ResolveErrors } from './resolve-errors';
+import { UntrackedDependencies } from './untracked-dependencies';
+import { LegacyInsideHarmony } from './legacy-inside-harmony';
+import { MultipleEnvs } from './multiple-envs';
+import { MissingLinksFromNodeModulesToSrc } from './missing-links-from-nm-to-src';
+import { CircularDependencies } from './circular-dependencies';
+import { DuplicateComponentAndPackage } from './duplicate-component-and-package';
+import { MergeConfigHasConflict } from './merge-config-has-conflict';
+import { NonLoadedEnv } from './non-loaded-env';
+import { ExternalEnvWithoutVersion } from './external-env-without-version';
+import { RemovedDependencies } from './removed-dependencies';
+import { SelfReference } from './self-reference';
+import { ImportFromDirectory } from './import-from-directory';
+import { DeprecatedDependencies } from './deprecated-dependencies';
+import { RemovedEnv } from './removed-env';
+
+export const IssuesClasses = {
+  MissingPackagesDependenciesOnFs,
+  MissingManuallyConfiguredPackages,
+  UntrackedDependencies,
+  ResolveErrors,
+  RelativeComponents,
+  RelativeComponentsAuthored,
+  ParseErrors,
+  MissingDists,
+  LegacyInsideHarmony,
+  MissingDependenciesOnFs,
+  ImportNonMainFiles,
+  MultipleEnvs,
+  MissingLinksFromNodeModulesToSrc,
+  CircularDependencies,
+  DuplicateComponentAndPackage,
+  MergeConfigHasConflict,
+  NonLoadedEnv,
+  ExternalEnvWithoutVersion,
+  RemovedDependencies,
+  RemovedEnv,
+  DeprecatedDependencies,
+  SelfReference,
+  ImportFromDirectory,
+};
+export type IssuesNames = keyof typeof IssuesClasses;
+
+export class IssuesList {
+  constructor(
+    /**
+     * only reason to have "issues" as public is to avoid the error "Types have separate declarations of a private property"
+     * because it is used in the legacy as well. it's possible to remove it from bit-repo and install as a package, but it's not
+     * convenient for now.
+     */
+    public _issues: ComponentIssue[] = []
+  ) {}
+
+  get count() {
+    return this._issues.length;
+  }
+
+  isEmpty() {
+    return this._issues.length === 0;
+  }
+
+  outputForCLI() {
+    return this._issues.map((issue) => issue.outputForCLI()).join('');
+  }
+
+  toObject(): { type: string; description: string; data: any }[] {
+    return this._issues.map((issue) => issue.toObject());
+  }
+
+  /**
+   * @deprecated use toObjectIncludeDataAsString instead
+   * this method changes the "data" prop to string, which can be unexpected, and at times both are needed, the raw and the string.
+   * if you change to use `toObjectIncludeDataAsString`, make sure to call "dataAsString" instead of "data" when needed.
+   */
+  toObjectWithDataAsString(): { type: string; description: string; data: string }[] {
+    return this._issues.map((issue) => ({
+      ...issue.toObject(),
+      data: issue.dataToString().trim(),
+    }));
+  }
+
+  add(issue: ComponentIssue) {
+    this._issues.push(issue);
+  }
+
+  delete(IssueClass: typeof ComponentIssue) {
+    this._issues = this._issues.filter((issue) => issue.constructor.name !== IssueClass.name);
+  }
+
+  hasTagBlockerIssues(): boolean {
+    return this._issues.some((issue) => issue.isTagBlocker);
+  }
+
+  getIssue<T extends ComponentIssue>(IssueClass: { new (): T }): T | undefined {
+    // don't use instanceof, e.g. `this._issues.find((issue) => issue instanceof IssueClass)`
+    // the "component-issues" package can come from different sources, so the "instanceof" won't work.
+    // use only getIssueByName for this.
+    return this.getIssueByName(IssueClass.name as IssuesNames);
+  }
+
+  getIssueByName<T extends ComponentIssue>(issueType: IssuesNames): T | undefined {
+    return this._issues.find((issue) => issue.constructor.name === issueType) as T | undefined;
+  }
+
+  getAllIssues(): ComponentIssue[] {
+    return this._issues;
+  }
+
+  getAllIssueNames(): string[] {
+    return this._issues.map((issue) => issue.constructor.name);
+  }
+
+  createIssue<T extends ComponentIssue>(IssueClass: { new (): T }): T {
+    const newIssue = new IssueClass();
+    this.add(newIssue);
+    return newIssue;
+  }
+
+  getOrCreate<T extends ComponentIssue>(IssueClass: { new (): T }): T {
+    return this.getIssue(IssueClass) || this.createIssue(IssueClass);
+  }
+
+  shouldBlockSavingInCache(): boolean {
+    return this._issues.some((issue) => issue.isCacheBlocker);
+  }
+
+  shouldBlockTagging(): boolean {
+    return this._issues.some((issue) => issue.isTagBlocker);
+  }
+
+  filterNonTagBlocking(): IssuesList {
+    return new IssuesList(this._issues.filter((issue) => issue.isTagBlocker));
+  }
+
+  toObjectIncludeDataAsString(): Array<IssueObject & { dataAsString: string }> {
+    return this._issues.map((issue) => ({
+      ...issue.toObject(),
+      dataAsString: issue.dataToString(),
+    }));
+  }
+
+  serialize() {
+    return this._issues.map((issue) => ({ type: issue.constructor.name, data: issue.serialize() }));
+  }
+
+  static deserialize(data: Record<string, any>) {
+    if (!Array.isArray(data)) {
+      // probably old format, ignore it and return an empty IssuesList
+      return new IssuesList();
+    }
+    const issues = data.map((issue) => {
+      const ClassName = issue.type;
+      if (!Object.keys(IssuesClasses).includes(ClassName)) {
+        throw new Error(`issue type "${ClassName}" is not recognized.
+the following are permitted ${Object.keys(IssuesClasses).join(', ')}`);
+      }
+      const issueInstance: ComponentIssue = new IssuesClasses[ClassName]();
+      issueInstance.data = issueInstance.deserialize(issue.data);
+      return issueInstance;
+    });
+    return new IssuesList(issues);
+  }
+}

package/legacy-inside-harmony.ts

@@ -0,0 +1,11 @@
+import { ComponentIssue, formatTitle } from './component-issue';
+
+export class LegacyInsideHarmony extends ComponentIssue {
+  description = 'legacy component inside Harmony workspace';
+  solution = 'remove the component and re-create it via Harmony';
+  data: boolean;
+  isTagBlocker = true;
+  outputForCLI() {
+    return formatTitle(this.descriptionWithSolution, false);
+  }
+}

package/merge-config-has-conflict.ts

@@ -0,0 +1,11 @@
+import { ComponentIssue, formatTitle } from './component-issue';
+
+export class MergeConfigHasConflict extends ComponentIssue {
+  description = 'merge-conflict file has unresolved conflicts';
+  solution = `edit the merge-conflict file in the workspace root and resolve the conflicts`;
+  data: boolean;
+  isTagBlocker = true;
+  outputForCLI() {
+    return formatTitle(this.descriptionWithSolution, false);
+  }
+}

package/missing-dependencies-on-fs.ts

@@ -0,0 +1,7 @@
+import { ComponentIssue, StringsPerFilePath } from './component-issue';
+
+export class MissingDependenciesOnFs extends ComponentIssue {
+  description = 'non-existing dependency files';
+  solution = 'make sure all files exists on your workspace';
+  data: StringsPerFilePath = {};
+}

package/missing-dists.ts

@@ -0,0 +1,11 @@
+import { ComponentIssue, formatTitle } from './component-issue';
+
+export class MissingDists extends ComponentIssue {
+  description = 'missing dists';
+  solution = 'run "bit compile"';
+  data: boolean;
+  isTagBlocker = false;
+  outputForCLI() {
+    return formatTitle(this.descriptionWithSolution, false);
+  }
+}

package/missing-links-from-nm-to-src.ts

@@ -0,0 +1,11 @@
+import { ComponentIssue, formatTitle } from './component-issue';
+
+export class MissingLinksFromNodeModulesToSrc extends ComponentIssue {
+  description = 'missing links from node_modules to source';
+  solution = 'run "bit link"';
+  data: boolean;
+  isTagBlocker = false;
+  outputForCLI() {
+    return formatTitle(this.descriptionWithSolution, false);
+  }
+}

package/missing-manually-configured-packages.ts

@@ -0,0 +1,10 @@
+import { ComponentIssue, ISSUE_FORMAT_SPACE } from './component-issue';
+
+export class MissingManuallyConfiguredPackages extends ComponentIssue {
+  description = `missing packages that were manually set`;
+  solution = `run "bit install"`;
+  data: string[] = []; // package names
+  dataToString() {
+    return ISSUE_FORMAT_SPACE + this.data.join(', ');
+  }
+}

package/missing-packages-dependencies-on-fs.ts

@@ -0,0 +1,18 @@
+import { ComponentIssue, ISSUE_FORMAT_SPACE } from './component-issue';
+
+export type MissingPackagesData = {
+  filePath: string;
+  isDevFile: boolean;
+  missingPackages: string[];
+};
+
+export class MissingPackagesDependenciesOnFs extends ComponentIssue {
+  description = `missing packages or links from node_modules to the source`;
+  solution = `run "bit install --add-missing-deps" to fix both issues`;
+  data: MissingPackagesData[] = [];
+  dataToString(): string {
+    return this.data
+      .map((d) => `${ISSUE_FORMAT_SPACE}${d.filePath} -> ${this.formatDataFunction(d.missingPackages)}`)
+      .join('\n');
+  }
+}

package/multiple-envs.ts

@@ -0,0 +1,12 @@
+import { ComponentIssue, ISSUE_FORMAT_SPACE } from './component-issue';
+
+export class MultipleEnvs extends ComponentIssue {
+  description = 'multiple envs';
+  solution =
+    'set the desired env by running "bit env set <component> <env>", if it doesn\'t work, run "bit aspect unset <component> <unwanted-env-id>". to keep troubleshooting run "bit aspect list <component-id>"';
+  data: string[]; // env ids
+  isTagBlocker = true;
+  dataToString() {
+    return ISSUE_FORMAT_SPACE + this.data.join(', ');
+  }
+}

package/non-loaded-env.ts

@@ -0,0 +1,11 @@
+import { ComponentIssue, ISSUE_FORMAT_SPACE } from './component-issue';
+
+export class NonLoadedEnv extends ComponentIssue {
+  description = 'failed loading env';
+  solution = `run "bit install"`;
+  data: string;
+  isTagBlocker = true;
+  dataToString() {
+    return ISSUE_FORMAT_SPACE + this.data;
+  }
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@teambit/component-issues",
+  "version": "0.0.0-de14d08f36c2ec7aca9f216f61bc447c5aeb9859",
+  "homepage": "https://bit.cloud/teambit/component/component-issues",
+  "main": "dist/index.js",
+  "componentId": {
+    "scope": "teambit.component",
+    "name": "component-issues",
+    "version": "de14d08f36c2ec7aca9f216f61bc447c5aeb9859"
+  },
+  "dependencies": {
+    "chalk": "4.1.2",
+    "@teambit/component-id": "1.2.4"
+  },
+  "devDependencies": {
+    "@types/mocha": "9.1.0",
+    "chai": "4.3.0",
+    "@teambit/node.envs.node-babel-mocha": "0.1.18"
+  },
+  "peerDependencies": {},
+  "license": "Apache-2.0",
+  "optionalDependencies": {},
+  "peerDependenciesMeta": {},
+  "private": false,
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/teambit/bit"
+  },
+  "keywords": [
+    "bit",
+    "components",
+    "collaboration",
+    "web"
+  ]
+}

package/parse-errors.ts

@@ -0,0 +1,7 @@
+import { ComponentIssue } from './component-issue';
+
+export class ParseErrors extends ComponentIssue {
+  description = 'error found while parsing the file';
+  solution = 'edit the file and fix the parsing error';
+  data: { [filePath: string]: string } = {};
+}

package/relative-components-authored.ts

@@ -0,0 +1,49 @@
+import { ComponentID } from '@teambit/component-id';
+import { ComponentIssue } from './component-issue';
+
+export type RelativeComponentsAuthoredEntry = {
+  importSource: string;
+  componentId: ComponentID;
+  relativePath: {
+    sourceRelativePath: string;
+    importSpecifiers?: any[];
+  };
+};
+
+export class RelativeComponentsAuthored extends ComponentIssue {
+  description = 'components with relative import statements found';
+  solution = 'replace to module paths or use "bit link --rewire" to replace';
+  data: { [fileName: string]: RelativeComponentsAuthoredEntry[] } = {};
+  isCacheBlocker = false;
+  formatDataFunction = relativeComponentsAuthoredIssuesToString;
+
+  serialize(): string {
+    const obj = Object.keys(this.data).reduce((acc, fileName) => {
+      acc[fileName] = this.data[fileName].map((record) => ({
+        importSource: record.importSource,
+        componentId: record.componentId.serialize(),
+        relativePath: record.relativePath,
+      }));
+      return acc;
+    }, {});
+    return JSON.stringify(obj);
+  }
+
+  deserialize(dataStr: string) {
+    const data = JSON.parse(dataStr);
+    Object.keys(data).forEach((fileName) => {
+      data[fileName] = data[fileName].map((record) => ({
+        importSource: record.importSource,
+        componentId: ComponentID.deserialize(record.componentId),
+        relativePath: record.relativePath,
+      }));
+    });
+    return data;
+  }
+}
+
+function relativeComponentsAuthoredIssuesToString(relativeEntries: RelativeComponentsAuthoredEntry[]) {
+  const stringifyEntry = (entry: RelativeComponentsAuthoredEntry) =>
+    `"${entry.importSource}" (${entry.componentId.toString()})`;
+  return relativeEntries.map(stringifyEntry).join(', ');
+}

package/relative-components.ts

@@ -0,0 +1,12 @@
+import { ComponentID } from '@teambit/component-id';
+import { ComponentIssue, deserializeWithBitId } from './component-issue';
+
+export class RelativeComponents extends ComponentIssue {
+  description = 'components with relative import statements found';
+  solution = 'use module paths for imported components';
+  data: { [filePath: string]: ComponentID[] } = {};
+  isCacheBlocker = false;
+  deserialize(data: string) {
+    return deserializeWithBitId(data);
+  }
+}

package/removed-dependencies.ts

@@ -0,0 +1,12 @@
+import { ComponentIssue, ISSUE_FORMAT_SPACE } from './component-issue';
+
+export class RemovedDependencies extends ComponentIssue {
+  description = 'dependencies used in the code were deleted';
+  solution =
+    'if the dependencies are no longer needed, remove them from the code. otherwise, to get it installed from main run "bit install <missing dep>". to undo the delete, run "bit recover"';
+  data: string[]; // deps ids
+  isTagBlocker = true;
+  dataToString() {
+    return ISSUE_FORMAT_SPACE + this.data.join(', ');
+  }
+}

package/removed-env.ts

@@ -0,0 +1,12 @@
+import { ComponentIssue, ISSUE_FORMAT_SPACE } from './component-issue';
+
+export class RemovedEnv extends ComponentIssue {
+  description = 'the env of this component is deleted';
+  solution =
+    'use "bit env set/replace" to set a new env or a different version of this env. to undo the delete, run "bit recover"';
+  data: string; // env id
+  isTagBlocker = true;
+  dataToString() {
+    return ISSUE_FORMAT_SPACE + this.data;
+  }
+}

package/resolve-errors.ts

@@ -0,0 +1,7 @@
+import { ComponentIssue } from './component-issue';
+
+export class ResolveErrors extends ComponentIssue {
+  description = 'error found while resolving the file dependencies';
+  solution = 'see the log for the full error';
+  data: { [filePath: string]: string } = {};
+}

package/self-reference.ts

@@ -0,0 +1,8 @@
+import { ComponentIssue } from './component-issue';
+
+export class SelfReference extends ComponentIssue {
+  description = 'a component has an import statement that points to itself';
+  solution = 'edit the file and change the import statement to a relative path';
+  data: { [filePath: string]: string } = {};
+  isTagBlocker = true;
+}

package/types/asset.d.ts

@@ -0,0 +1,41 @@
+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;
+}
+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;
+}
+declare module '*.otf' {
+  const value: any;
+  export = value;
+}
+declare module '*.woff' {
+  const value: any;
+  export = value;
+}
+declare module '*.woff2' {
+  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;
+}

package/untracked-dependencies.ts

@@ -0,0 +1,41 @@
+import chalk from 'chalk';
+import { ComponentIssue, ISSUE_FORMAT_SPACE, ISSUE_FORMAT_SPACE_COUNT } from './component-issue';
+
+export const MISSING_NESTED_DEPS_SPACE = ' '.repeat(ISSUE_FORMAT_SPACE_COUNT + 2);
+
+interface UntrackedFileEntry {
+  relativePath: string;
+  existing: boolean;
+}
+
+export interface UntrackedFileDependencyEntry {
+  nested: boolean;
+  untrackedFiles: Array<UntrackedFileEntry>;
+}
+
+export class UntrackedDependencies extends ComponentIssue {
+  description = 'untracked file dependencies';
+  solution = 'use "bit add <file>" to track untracked files as components';
+  data: { [filePath: string]: UntrackedFileDependencyEntry } = {};
+  dataToString() {
+    return Object.keys(this.data)
+      .map((k) => {
+        let space = ISSUE_FORMAT_SPACE;
+        if (this.data[k].nested) {
+          space = MISSING_NESTED_DEPS_SPACE;
+        }
+        return `${space}${k} -> ${untrackedFilesComponentIssueToString(this.data[k])}`;
+      })
+      .join('\n');
+  }
+}
+
+function untrackedFilesComponentIssueToString(value: UntrackedFileDependencyEntry) {
+  const colorizedMap = value.untrackedFiles.map((curr) => {
+    if (curr.existing) {
+      return `${chalk.yellow(curr.relativePath)}`;
+    }
+    return curr.relativePath;
+  });
+  return colorizedMap.join(', ');
+}