@teambit/generator 0.0.555 → 0.0.556

package/templates.cmd.ts

@@ -1,48 +0,0 @@
-import { Command, CommandOptions } from '@teambit/cli';
-import chalk from 'chalk';
-import { groupBy } from 'lodash';
-import { GeneratorMain, TemplateDescriptor } from './generator.main.runtime';
-
-export type TemplatesOptions = {
-  showAll?: boolean;
-};
-
-export class TemplatesCmd implements Command {
-  name = 'templates';
-  description =
-    'list components templates when inside bit-workspace (for bit-create), otherwise, list workspace templates (for bit-new)';
-  shortDescription = 'list templates for "bit create" and "bit new"';
-  alias = '';
-  loader = true;
-  group = 'development';
-  options = [['s', 'show-all', 'show hidden templates']] as CommandOptions;
-
-  constructor(private generator: GeneratorMain) {}
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async report(args: [], templatesOptions: TemplatesOptions) {
-    let results = await this.generator.listTemplates();
-
-    // Make sure that we don't list hidden templates
-    if (!templatesOptions.showAll) {
-      results = results.filter((template) => !template.hidden);
-    }
-
-    const grouped = groupBy(results, 'aspectId');
-    const titleStr = this.generator.isRunningInsideWorkspace()
-      ? `The following template(s) are available with the command bit create:  \nExample - bit create <template-name> <component-name>`
-      : `The following template(s) are available with the command bit new: \nExample - bit new <template-name> <workspace-name>`;
-    const title = chalk.green(`\n${titleStr}\n`);
-    const templateOutput = (template: TemplateDescriptor) => {
-      const desc = template.description ? ` (${template.description})` : '';
-      return `    ${template.name}${chalk.dim(desc)}`;
-    };
-    const output = Object.keys(grouped)
-      .map((aspectId) => {
-        const names = grouped[aspectId].map(templateOutput).join('\n');
-        return `${chalk.blue.bold(aspectId)}\n${names}\n`;
-      })
-      .join('\n');
-    return title + output;
-  }
-}

package/tsconfig.json

@@ -1,34 +0,0 @@
-{
-  "compilerOptions": {
-    "lib": [
-      "es2019",
-      "DOM",
-      "ES6",
-      "DOM.Iterable",
-      "ScriptHost"
-    ],
-    "target": "es2015",
-    "module": "commonjs",
-    "jsx": "react",
-    "declaration": true,
-    "sourceMap": true,
-    "skipLibCheck": true,
-    "moduleResolution": "node",
-    "esModuleInterop": true,
-    "outDir": "dist",
-    "composite": true,
-    "emitDeclarationOnly": true,
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
-    "allowSyntheticDefaultImports": true,
-    "strictPropertyInitialization": false,
-    "strict": true,
-    "noImplicitAny": false,
-    "rootDir": ".",
-    "preserveConstEnums": true,
-    "resolveJsonModule": true
-  },
-  "exclude": [
-    "dist"
-  ]
-}

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;
-}

package/types.ts

@@ -1,3 +0,0 @@
-export interface CreateExtConfig {
-  template: string;
-}

package/workspace-generator.ts

@@ -1,246 +0,0 @@
-import fs from 'fs-extra';
-import { isBinaryFile } from 'isbinaryfile';
-import { loadBit } from '@teambit/bit';
-import { Harmony } from '@teambit/harmony';
-import { Component } from '@teambit/component';
-import execa from 'execa';
-import { BitId } from '@teambit/legacy-bit-id';
-import pMapSeries from 'p-map-series';
-import UIAspect, { UiMain } from '@teambit/ui';
-import { Logger, LoggerAspect, LoggerMain } from '@teambit/logger';
-import { WorkspaceAspect, Workspace } from '@teambit/workspace';
-import { PkgAspect, PkgMain } from '@teambit/pkg';
-import { init } from '@teambit/legacy/dist/api/consumer';
-import { CompilerAspect, CompilerMain } from '@teambit/compiler';
-import getGitExecutablePath from '@teambit/legacy/dist/utils/git/git-executable';
-import GitNotFound from '@teambit/legacy/dist/utils/git/exceptions/git-not-found';
-import path from 'path';
-import { DependencyResolverMain, DependencyResolverAspect } from '@teambit/dependency-resolver';
-import { ComponentID } from '@teambit/component-id';
-import { WorkspaceTemplate } from './workspace-template';
-import { NewOptions } from './new.cmd';
-import { GeneratorAspect } from './generator.aspect';
-
-export type GenerateResult = { id: ComponentID; dir: string; files: string[]; envId: string };
-
-type CompToImportResolved = {
-  id: ComponentID;
-  path: string;
-  targetName?: string;
-};
-
-export class WorkspaceGenerator {
-  private workspacePath: string;
-  private harmony: Harmony;
-  private workspace: Workspace;
-  private logger: Logger;
-  constructor(
-    private workspaceName: string,
-    private options: NewOptions,
-    private template: WorkspaceTemplate,
-    private aspectComponent?: Component
-  ) {
-    this.workspacePath = path.resolve(this.workspaceName);
-  }
-
-  async generate(): Promise<string> {
-    if (fs.existsSync(this.workspacePath)) {
-      throw new Error(`unable to create a workspace at "${this.workspaceName}", this path already exist`);
-    }
-    await fs.ensureDir(this.workspacePath);
-    try {
-      process.chdir(this.workspacePath);
-      await this.initGit();
-      await init(this.workspacePath, this.options.skipGit, false, false, false, false, {});
-      await this.writeWorkspaceFiles();
-      await this.reloadBitInWorkspaceDir();
-      await this.addComponentsFromRemote();
-      await this.workspace.install(undefined, {
-        dedupe: true,
-        import: false,
-        copyPeerToRuntimeOnRoot: true,
-        copyPeerToRuntimeOnComponents: false,
-        updateExisting: false,
-      });
-      // await this.buildUI(); // disabled for now. it takes too long
-    } catch (err: any) {
-      await fs.remove(this.workspacePath);
-      throw err;
-    }
-
-    return this.workspacePath;
-  }
-
-  private async initGit() {
-    if (this.options.skipGit) return;
-    const gitExecutablePath = getGitExecutablePath();
-    const params = ['init'];
-    try {
-      await execa(gitExecutablePath, params);
-    } catch (err: any) {
-      if (err.exitCodeName === 'ENOENT') {
-        throw new GitNotFound(gitExecutablePath, err);
-      }
-      throw err;
-    }
-  }
-
-  private async buildUI() {
-    const uiMain = this.harmony.get<UiMain>(UIAspect.id);
-    await uiMain.createRuntime({});
-  }
-
-  /**
-   * writes the generated template files to the default directory set in the workspace config
-   */
-  private async writeWorkspaceFiles(): Promise<void> {
-    const workspaceContext = {
-      name: this.workspaceName,
-      defaultScope: this.options.defaultScope,
-      empty: this.options.empty,
-      aspectComponent: this.aspectComponent,
-    };
-    const templateFiles = await this.template.generateFiles(workspaceContext);
-    await Promise.all(
-      templateFiles.map(async (templateFile) => {
-        await fs.outputFile(path.join(this.workspacePath, templateFile.relativePath), templateFile.content);
-      })
-    );
-  }
-
-  private async reloadBitInWorkspaceDir() {
-    this.harmony = await loadBit(this.workspacePath);
-    this.workspace = this.harmony.get<Workspace>(WorkspaceAspect.id);
-    const loggerMain = this.harmony.get<LoggerMain>(LoggerAspect.id);
-    this.logger = loggerMain.createLogger(GeneratorAspect.id);
-  }
-
-  private async addComponentsFromRemote() {
-    if (this.options.empty) return;
-    const componentsToImport = this.template?.importComponents?.();
-    if (!componentsToImport || !componentsToImport.length) return;
-    const dependencyResolver = this.harmony.get<DependencyResolverMain>(DependencyResolverAspect.id);
-
-    const componentsToImportResolved = await Promise.all(
-      componentsToImport.map(async (c) => ({
-        id: ComponentID.fromLegacy(BitId.parse(c.id, true)),
-        path: c.path,
-        targetName: c.targetName,
-      }))
-    );
-    const componentIds = componentsToImportResolved.map((c) => c.id);
-    // @todo: improve performance by changing `getRemoteComponent` api to accept multiple ids
-    const components = await Promise.all(componentIds.map((id) => this.workspace.scope.getRemoteComponent(id)));
-    const oldAndNewPackageNames = this.getNewPackageNames(components, componentsToImportResolved);
-    const oldAndNewComponentIds = this.getNewComponentIds(components, componentsToImportResolved);
-    await Promise.all(
-      components.map((comp) =>
-        this.replaceOriginalPackageNameWithNew(comp, oldAndNewPackageNames, oldAndNewComponentIds)
-      )
-    );
-    await pMapSeries(components, async (comp) => {
-      const compData = componentsToImportResolved.find((c) => c.id._legacy.isEqualWithoutVersion(comp.id._legacy));
-      if (!compData) throw new Error(`workspace-generator, unable to find ${comp.id.toString()} in the given ids`);
-      await this.workspace.write(compData.path, comp);
-      await this.workspace.track({
-        rootDir: compData.path,
-        componentName: compData.targetName || compData.id.fullName,
-        mainFile: comp.state._consumer.mainFile,
-      });
-      const deps = await dependencyResolver.getDependencies(comp);
-
-      const currentPackages = Object.keys(oldAndNewPackageNames);
-      // only bring auto-resolved dependencies, others should be set in the workspace.jsonc template
-      const workspacePolicyEntries = deps
-        .filter((dep) => dep.source === 'auto')
-        .map((dep) => ({
-          dependencyId: dep.getPackageName?.() || dep.id,
-          lifecycleType: dep.lifecycle === 'dev' ? 'runtime' : dep.lifecycle,
-          value: {
-            version: dep.version,
-          },
-        }))
-        .filter((entry) => !currentPackages.includes(entry.dependencyId)); // remove components that are now imported
-      dependencyResolver.addToRootPolicy(workspacePolicyEntries, { updateExisting: true });
-    });
-    await this.workspace.writeBitMap();
-    await dependencyResolver.persistConfig(this.workspace.path);
-    this.workspace.clearCache();
-    await this.compileComponents();
-  }
-
-  private async compileComponents() {
-    const compiler = this.harmony.get<CompilerMain>(CompilerAspect.id);
-    await compiler.compileOnWorkspace();
-  }
-
-  private getNewPackageNames(
-    components: Component[],
-    compsData: CompToImportResolved[]
-  ): { [oldPackageName: string]: string } {
-    const pkg = this.harmony.get<PkgMain>(PkgAspect.id);
-    const packageToReplace = {};
-    const scopeToReplace = this.workspace.defaultScope.replace('.', '/');
-    components.forEach((comp) => {
-      const newId = this.resolveNewCompId(comp, compsData);
-      const currentPackageName = pkg.getPackageName(comp);
-      const newName = newId.fullName.replace(/\//g, '.');
-      const newPackageName = `@${scopeToReplace}.${newName}`;
-      packageToReplace[currentPackageName] = newPackageName;
-    });
-    return packageToReplace;
-  }
-
-  private getNewComponentIds(
-    components: Component[],
-    compsData: CompToImportResolved[]
-  ): { [oldComponentId: string]: string } {
-    const componentToReplace = {};
-    components.forEach((comp) => {
-      const newId = this.resolveNewCompId(comp, compsData);
-      componentToReplace[comp.id.toStringWithoutVersion()] = newId.toStringWithoutVersion();
-    });
-    return componentToReplace;
-  }
-
-  private resolveNewCompId(comp: Component, compsData: CompToImportResolved[]): ComponentID {
-    const scopeToReplace = this.workspace.defaultScope;
-    const compData = compsData.find((c) => c.id._legacy.isEqualWithoutScopeAndVersion(comp.id._legacy));
-    if (!compData) {
-      throw new Error(`workspace-generator: unable to find data for "${comp.id._legacy.toString()}"`);
-    }
-    return compData.targetName
-      ? ComponentID.fromLegacy(BitId.parse(compData.targetName, false).changeScope(scopeToReplace))
-      : comp.id.changeScope(scopeToReplace);
-  }
-
-  private async replaceOriginalPackageNameWithNew(
-    comp: Component,
-    packageToReplace: Record<string, string>,
-    oldAndNewComponentIds: Record<string, string>
-  ) {
-    await Promise.all(
-      comp.filesystem.files.map(async (file) => {
-        const isBinary = await isBinaryFile(file.contents);
-        if (isBinary) return;
-        const strContent = file.contents.toString();
-        let newContent = strContent;
-        Object.keys(packageToReplace).forEach((currentPackage) => {
-          if (strContent.includes(currentPackage)) {
-            const currentPkgRegex = new RegExp(currentPackage, 'g');
-            newContent = newContent.replace(currentPkgRegex, packageToReplace[currentPackage]);
-          }
-        });
-        Object.keys(oldAndNewComponentIds).forEach((currentId) => {
-          if (strContent.includes(currentId)) {
-            const currentIdRegex = new RegExp(currentId, 'g');
-            newContent = newContent.replace(currentIdRegex, oldAndNewComponentIds[currentId]);
-          }
-        });
-        if (strContent !== newContent) {
-          file.contents = Buffer.from(newContent);
-        }
-      })
-    );
-  }
-}

package/workspace-template.ts

@@ -1,82 +0,0 @@
-import type { Component } from '@teambit/component';
-
-export interface WorkspaceFile {
-  /**
-   * relative path of the file within the workspace.
-   */
-  relativePath: string;
-
-  /**
-   * file content
-   */
-  content: string;
-}
-
-export interface WorkspaceContext {
-  /**
-   * workspace-name as entered by the user, e.g. `react-app`.
-   * it is used as the directory name for the workspace.
-   */
-  name: string;
-
-  /**
-   * default scope as entered by the user.
-   * it will be set in the workspace.jsonc and be used for components
-   */
-  defaultScope?: string;
-
-  /**
-   * whether user entered `--empty` flag in `bit new` to avoid creating components.
-   */
-  empty?: boolean;
-
-  /**
-   * in case the "--aspect" flag used to import a remote aspect, this is populated with that aspect.
-   * useful to get the aspect-id and other info.
-   */
-  aspectComponent?: Component;
-}
-
-export interface ComponentToImport {
-  /**
-   * full component id
-   */
-  id: string;
-
-  /**
-   * path where to write the component
-   */
-  path: string;
-
-  /**
-   * a new component name. if not specified, use the original id (without the scope)
-   */
-  targetName?: string;
-}
-
-export interface WorkspaceTemplate {
-  /**
-   * name of the workspace template. for example: `react-workspace`.
-   */
-  name: string;
-
-  /**
-   * short description of the template. shown in the `bit templates` command when outside of bit-workspace.
-   */
-  description?: string;
-
-  /**
-   * hide this template so that it is not listed with `bit templates`
-   */
-  hidden?: boolean;
-
-  /**
-   * template function for generating the template files,
-   */
-  generateFiles(context: WorkspaceContext): Promise<WorkspaceFile[]>;
-
-  /**
-   * populate existing components into the new workspace and add them as new components
-   */
-  importComponents?: () => ComponentToImport[];
-}