@teambit/generator 1.0.109 → 1.0.110

package/new.cmd.ts

@@ -1,120 +0,0 @@
-import { Command, CommandOptions } from '@teambit/cli';
-import chalk from 'chalk';
-import { GeneratorMain } from './generator.main.runtime';
-import { BaseWorkspaceOptions } from './workspace-template';
-
-/**
- * NewOptions combines foundational properties with additional options for creating a workspace.
- */
-export type NewOptions = BaseWorkspaceOptions;
-
-export class NewCmd implements Command {
-  name = 'new <template-name> <workspace-name>';
-  description = 'create a new workspace from a template';
-  arguments = [
-    {
-      name: 'template-name',
-      description:
-        "the name of the workspace template (run 'bit templates' outside of a workspace to get a list of available workspace templates)",
-    },
-    {
-      name: 'workspace-name',
-      description: 'the name for the new workspace and workspace directory that will be created',
-    },
-  ];
-  alias = '';
-  loader = true;
-  group = 'start';
-  options = [
-    [
-      'a',
-      'aspect <aspect-id>',
-      'id of the aspect that registered the template, mandatory for non-core aspects. helpful for core aspects in case of a name collision',
-    ],
-    ['t', 'template <env-id>', "env-id of the template's owner. Alias for --env."],
-    ['', 'env <env-id>', 'env-id of the template. Alias -t'],
-    ['d', 'default-scope <scope-name>', `set defaultScope in the new workspace's workspace.jsonc`],
-    ['', 'standalone', 'DEPRECATED. use --skip-git instead'],
-    ['s', 'skip-git', 'skip generation of Git repository in the new workspace'],
-    [
-      'e',
-      'empty',
-      "skip template's default component creation (relevant for templates that add components by default)",
-    ],
-    [
-      '',
-      'load-from <path-to-template>',
-      'local path to the workspace containing the template. Helpful during a development of a workspace-template',
-    ],
-    [
-      'c',
-      'current-dir',
-      'create the new workspace in current directory (default is to create a new directory, inside the current dir)',
-    ],
-  ] as CommandOptions;
-
-  constructor(private generator: GeneratorMain) {}
-
-  async report(
-    [templateName, workspaceName]: [string, string],
-    options: NewOptions & {
-      standalone: boolean;
-      env?: string;
-      template?: string;
-      aspect?: string;
-      currentDir?: boolean;
-    }
-  ) {
-    options.skipGit = options.skipGit ?? options.standalone;
-    options.aspect = options.aspect ?? options.env ?? options.template;
-    const { workspacePath, appName } = await this.generator.generateWorkspaceTemplate(
-      workspaceName,
-      templateName,
-      options
-    );
-    return chalk.white(
-      `${chalk.green(`
-
-Congrats! A new workspace has been created successfully at '${workspacePath}'`)}
-
-Inside the directory '${workspaceName}' you can run various commands including:
-
-      ${chalk.yellow('bit start')}
-        Starts the local dev server
-
-      ${chalk.yellow('bit install')}
-        Installs any missing dependencies
-
-      ${chalk.yellow('bit status')}
-        Shows the status of the components
-
-      ${chalk.yellow('bit compile')}
-        Compiles the components
-
-      ${chalk.yellow('bit test')}
-        Runs the tests on all your components
-
-      ${chalk.yellow('bit templates')}
-        Shows all available component templates
-
-      ${chalk.yellow('bit help')}
-        Shows all available commands
-
-
-${chalk.green.bold("Let's get started!")}
-
-      ${getBottomSection(workspaceName, appName)}
-      `
-    );
-  }
-}
-
-function getBottomSection(workspaceName: string, appName: string | undefined) {
-  const cdLine = chalk.yellow(`cd ${workspaceName}`);
-  const parts = [cdLine];
-  if (appName) {
-    parts.push(chalk.yellow(`      bit run ${appName}`));
-  }
-  parts.push(chalk.yellow(`      bit start`));
-  return parts.join('\n');
-}

package/starter-list.ts

@@ -1,21 +0,0 @@
-import { EnvContext, EnvHandler } from '@teambit/envs';
-import { WorkspaceTemplate } from './workspace-template';
-
-export type StarterListOptions = {
-  name?: string;
-};
-
-export class StarterList {
-  constructor(readonly name: string, private starters: EnvHandler<WorkspaceTemplate>[], private context: EnvContext) {}
-
-  compute(): WorkspaceTemplate[] {
-    return this.starters.map((starter) => starter(this.context));
-  }
-
-  static from(starters: EnvHandler<WorkspaceTemplate>[], options: StarterListOptions = {}) {
-    return (context: EnvContext) => {
-      const name = options.name || 'starter-list';
-      return new StarterList(name, starters, context);
-    };
-  }
-}

package/starter.plugin.ts

@@ -1,16 +0,0 @@
-import { PluginDefinition } from '@teambit/aspect-loader';
-import { MainRuntime } from '@teambit/cli';
-import { GeneratorMain } from './generator.main.runtime';
-
-export class StarterPlugin implements PluginDefinition {
-  constructor(private generator: GeneratorMain) {}
-
-  pattern = '*.starter.*';
-
-  runtimes = [MainRuntime.name];
-
-  register(object: any) {
-    const templates = Array.isArray(object) ? object : [object];
-    return this.generator.registerWorkspaceTemplate(templates);
-  }
-}

package/template-list.ts

@@ -1,21 +0,0 @@
-import { EnvContext, EnvHandler } from '@teambit/envs';
-import { ComponentTemplate } from './component-template';
-
-export type TemplateListOptions = {
-  name?: string;
-};
-
-export class TemplateList {
-  constructor(readonly name: string, private templates: EnvHandler<ComponentTemplate>[], private context: EnvContext) {}
-
-  compute(): ComponentTemplate[] {
-    return this.templates.map((template) => template(this.context));
-  }
-
-  static from(templates: EnvHandler<ComponentTemplate>[], options: TemplateListOptions = {}) {
-    return (context: EnvContext) => {
-      const name = options.name || 'template-list';
-      return new TemplateList(name, templates, context);
-    };
-  }
-}

package/templates.cmd.ts

@@ -1,57 +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;
-  aspect?: string;
-};
-
-export class TemplatesCmd implements Command {
-  name = 'templates';
-  description = 'list available templates for "bit create" and "bit new"';
-  extendedDescription =
-    'list components templates when inside bit-workspace (for bit-create), otherwise, list workspace templates (for bit-new)';
-  alias = '';
-  loader = true;
-  group = 'development';
-  options = [
-    ['s', 'show-all', 'show hidden templates'],
-    ['a', 'aspect <aspect-id>', 'show templates provided by the aspect-id'],
-  ] 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(templatesOptions);
-
-    // 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');
-        const groupTitle = grouped[aspectId][0].titlePrefix
-          ? `${grouped[aspectId][0].titlePrefix} (${aspectId})`
-          : aspectId;
-        return `${chalk.blue.bold(groupTitle)}\n${names}\n`;
-      })
-      .join('\n');
-
-    const learnMore = `\nfind and add templates in https://bit.dev/reference/generator/use-component-generator`;
-    return title + output + learnMore;
-  }
-}

package/types.ts

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

package/workspace-generator.ts

@@ -1,220 +0,0 @@
-import fs from 'fs-extra';
-import { loadBit } from '@teambit/bit';
-import { Harmony } from '@teambit/harmony';
-import { Component } from '@teambit/component';
-import execa from 'execa';
-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 ForkingAspect, { ForkingMain } from '@teambit/forking';
-import { init } from '@teambit/legacy/dist/api/consumer';
-import ImporterAspect, { ImporterMain } from '@teambit/importer';
-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 { resolve, join } from 'path';
-import { ComponentID } from '@teambit/component-id';
-import GitAspect, { GitMain } from '@teambit/git';
-import { InstallAspect, InstallMain } from '@teambit/install';
-import WorkspaceConfigFilesAspect, { WorkspaceConfigFilesMain } from '@teambit/workspace-config-files';
-// import { ComponentGenerator } from './component-generator';
-import { WorkspaceTemplate, WorkspaceContext } from './workspace-template';
-import { NewOptions } from './new.cmd';
-import { GeneratorAspect } from './generator.aspect';
-import { GeneratorMain } from './generator.main.runtime';
-
-export type GenerateResult = { id: ComponentID; dir: string; files: string[]; envId: string };
-
-export class WorkspaceGenerator {
-  private workspacePath: string;
-  private harmony: Harmony;
-  private workspace: Workspace;
-  private install: InstallMain;
-  private importer: ImporterMain;
-  private logger?: Logger;
-  private forking: ForkingMain;
-  private git: GitMain;
-  private wsConfigFiles: WorkspaceConfigFilesMain;
-  private generator: GeneratorMain;
-
-  // private componentGenerator?: ComponentGenerator;
-
-  constructor(
-    private workspaceName: string,
-    private options: NewOptions & { currentDir?: boolean },
-    private template: WorkspaceTemplate,
-    private aspectComponent?: Component
-  ) {
-    this.workspacePath = options.currentDir ? process.cwd() : resolve(this.workspaceName);
-  }
-
-  async generate(): Promise<string> {
-    if (!this.options.currentDir && 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, false, false, {});
-      await this.writeWorkspaceFiles();
-      await this.reloadBitInWorkspaceDir();
-      // Setting the workspace to be in install context to prevent errors during the workspace generation
-      // the workspace will be in install context until the end of the generation install process
-      this.workspace.inInstallContext = true;
-      await this.setupGitBitmapMergeDriver();
-      await this.createComponentsFromRemote();
-      await this.forkComponentsFromRemote();
-      await this.importComponentsFromRemote();
-      await this.workspace.clearCache();
-      await this.install.install(undefined, {
-        dedupe: true,
-        import: false,
-        copyPeerToRuntimeOnRoot: true,
-        copyPeerToRuntimeOnComponents: false,
-        updateExisting: false,
-      });
-
-      // compile the components again now that we have the dependencies installed
-      await this.compileComponents(true);
-      await this.wsConfigFiles.writeConfigFiles({});
-    } catch (err: any) {
-      this.logger?.error(`failed generating a new workspace, will delete the dir ${this.workspacePath}`, err);
-      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 setupGitBitmapMergeDriver() {
-    if (this.options.skipGit) return;
-    await this.git.setGitMergeDriver({ global: false });
-  }
-
-  private async buildUI() {
-    const uiMain = this.harmony.get<UiMain>(UIAspect.id);
-    await uiMain.createRuntime({});
-  }
-
-  private getWorkspaceContext(): WorkspaceContext {
-    return {
-      name: this.workspaceName,
-      defaultScope: this.options.defaultScope,
-      empty: this.options.empty,
-      aspectComponent: this.aspectComponent,
-      template: this.template,
-      skipGit: this.options.skipGit,
-    };
-  }
-
-  /**
-   * writes the generated template files to the default directory set in the workspace config
-   */
-  private async writeWorkspaceFiles(): Promise<void> {
-    const workspaceContext = this.getWorkspaceContext();
-    const templateFiles = await this.template.generateFiles(workspaceContext);
-    await Promise.all(
-      templateFiles.map(async (templateFile) => {
-        await fs.outputFile(join(this.workspacePath, templateFile.relativePath), templateFile.content);
-      })
-    );
-  }
-
-  private async reloadBitInWorkspaceDir() {
-    this.harmony = await loadBit(this.workspacePath);
-    this.workspace = this.harmony.get<Workspace>(WorkspaceAspect.id);
-    this.install = this.harmony.get<InstallMain>(InstallAspect.id);
-    const loggerMain = this.harmony.get<LoggerMain>(LoggerAspect.id);
-    this.logger = loggerMain.createLogger(GeneratorAspect.id);
-    this.importer = this.harmony.get<ImporterMain>(ImporterAspect.id);
-    this.forking = this.harmony.get<ForkingMain>(ForkingAspect.id);
-    this.git = this.harmony.get<GitMain>(GitAspect.id);
-    this.wsConfigFiles = this.harmony.get<WorkspaceConfigFilesMain>(WorkspaceConfigFilesAspect.id);
-    this.generator = this.harmony.get<GeneratorMain>(GeneratorAspect.id);
-  }
-
-  private async createComponentsFromRemote() {
-    if (this.options.empty || !this.template.create) return;
-    const workspaceContext = this.getWorkspaceContext();
-    const componentsToCreate = this.template.create(workspaceContext);
-    await pMapSeries(componentsToCreate, async (componentToCreate) => {
-      return this.generator.generateComponentTemplate(
-        [componentToCreate.componentName],
-        componentToCreate.templateName,
-        {
-          aspect: componentToCreate.aspect,
-          env: componentToCreate.env,
-          path: componentToCreate.path,
-          scope: componentToCreate.scope,
-        }
-      );
-    });
-  }
-
-  private async forkComponentsFromRemote() {
-    if (this.options.empty) return;
-    const workspaceContext = this.getWorkspaceContext();
-    const componentsToFork =
-      this.template?.importComponents?.(workspaceContext) || this.template?.fork?.(workspaceContext) || [];
-    if (!componentsToFork.length) return;
-    const componentsToForkRestructured = componentsToFork.map(({ id, targetName, path, env, config, targetScope }) => ({
-      sourceId: id,
-      targetId: targetName,
-      targetScope,
-      path,
-      env,
-      config,
-    }));
-    await this.forking.forkMultipleFromRemote(componentsToForkRestructured, {
-      scope: this.workspace.defaultScope,
-      refactor: true,
-      install: false,
-    });
-  }
-
-  private async importComponentsFromRemote() {
-    if (this.options.empty) return;
-    const workspaceContext = this.getWorkspaceContext();
-    const componentsToImport = this.template?.import?.(workspaceContext) || [];
-
-    if (!componentsToImport.length) return;
-
-    await pMapSeries(componentsToImport, async (componentToImport) => {
-      await this.importer.import(
-        {
-          ids: [componentToImport.id],
-          installNpmPackages: false,
-          writeConfigFiles: false,
-          writeToPath: componentToImport.path,
-        },
-        []
-      );
-    });
-
-    await this.workspace.bitMap.write('new');
-  }
-
-  private async compileComponents(clearCache = true) {
-    if (clearCache) {
-      await this.workspace.clearCache();
-    }
-    const compiler = this.harmony.get<CompilerMain>(CompilerAspect.id);
-    await compiler.compileOnWorkspace();
-  }
-}

package/workspace-template.ts

@@ -1,183 +0,0 @@
-import type { Component } from '@teambit/component';
-import { ComponentConfig } from './component-template';
-
-/**
- * BaseWorkspaceOptions describes the foundational properties for workspaces.
- */
-export interface BaseWorkspaceOptions {
-  /**
-   * The name of the workspace as provided by the user (e.g., `react-app`).
-   * This is also used as the directory name for the workspace.
-   */
-  name: string;
-
-  /**
-   * The default scope provided by the user.
-   * This is set in the workspace.jsonc and is utilized for components within the workspace.
-   */
-  defaultScope?: string;
-
-  /**
-   * Indicates whether the user has opted to avoid creating components (typically with a `--empty` flag).
-   */
-  empty?: boolean;
-
-  /**
-   * Represents the aspect in the context where a remote aspect is imported (often via the `--aspect` flag).
-   * This is useful for obtaining the aspect-id and other related information.
-   */
-  aspectComponent?: Component;
-
-  /**
-   * Represents the selected template to initialize or create the workspace.
-   */
-  template: WorkspaceTemplate;
-
-  /**
-   * Flag to check if Git repository generation should be skipped.
-   */
-  skipGit?: boolean;
-
-  /**
-   * Local path to the workspace template.
-   * Useful during the development of a workspace-template.
-   */
-  loadFrom?: string;
-}
-
-/**
- * WorkspaceContext represents foundational properties for a workspace context.
- */
-export type WorkspaceContext = BaseWorkspaceOptions;
-
-export interface WorkspaceFile {
-  /**
-   * relative path of the file within the workspace.
-   */
-  relativePath: string;
-
-  /**
-   * file content
-   */
-  content: string;
-}
-
-export interface CreateComponentInfo {
-  /**
-   * the template for generating the component
-   */
-  templateName: string;
-  /**
-   * component name to generate
-   */
-  componentName: string;
-  /**
-   * sets the component's scope-name. if not entered, the default-scope will be used
-   */
-  scope?: string;
-  /**
-   * relative path in the workspace. by default the path is `<scope>/<namespace>/<name>`
-   */
-  path?: string;
-  /**
-   * set the component's environment. (overrides the env from variants and the template)
-   */
-  env?: string;
-  /**
-   * aspect-id of the template.
-   */
-  aspect?: string;
-}
-
-export interface ForkComponentInfo extends ImportComponentInfo {
-  /**
-   * a new component name. if not specified, use the original id (without the scope)
-   */
-  targetName?: string;
-
-  /**
-   * a new scope for the component. if not specified, use the original scope
-   */
-  targetScope?: string;
-
-  /**
-   * env to use for the component.
-   */
-  env?: string;
-
-  /**
-   * component config. gets saved in the .bitmap file and overrides the workspace.jsonc config.
-   * for example, you can set the env that will be used for this component as follows:
-   * "teambit.envs/envs": {
-   *    "env": "teambit.harmony/aspect"
-   * },
-   */
-  config?: ComponentConfig;
-}
-
-/**
- * @deprecated use ForkComponentInfo instead.
- */
-export type ComponentToImport = ForkComponentInfo;
-
-export interface ImportComponentInfo {
-  /**
-   * full component id
-   */
-  id: string;
-
-  /**
-   * path where to write the component
-   */
-  path?: string;
-}
-
-export interface WorkspaceTemplate {
-  /**
-   * name of the workspace starter. for example: `react-workspace`.
-   */
-  name: string;
-
-  /**
-   * name of an app created in the workspace. for example: `my-app`.
-   * This will be used to instruct the user to run `bit run <appName>` in the new workspace.
-   */
-  appName?: string;
-
-  /**
-   * short description of the starter. shown in the `bit starter` command when outside of bit-workspace.
-   */
-  description?: string;
-
-  /**
-   * hide this starter so that it is not listed with `bit starter`
-   */
-  hidden?: boolean;
-
-  /**
-   * starter function for generating the template files,
-   */
-  generateFiles(context: WorkspaceContext): Promise<WorkspaceFile[]>;
-
-  /**
-   * @deprecated use `fork()` or `import()` instead
-   * this is working similarly to `fork()`
-   */
-  importComponents?: (context: WorkspaceContext) => ForkComponentInfo[];
-
-  /**
-   * import components into the new workspace, don't change their source code.
-   */
-  import?: (context: WorkspaceContext) => ImportComponentInfo[];
-
-  /**
-   * populate existing components into the new workspace and add them as new components.
-   * change their source code and update the dependency names according to the new component names.
-   */
-  fork?: (context: WorkspaceContext) => ForkComponentInfo[];
-
-  /**
-   * populate new components into the new workspace and add them as new components.
-   */
-  create?: (context: WorkspaceContext) => CreateComponentInfo[];
-}