@teambit/generator 1.0.107 → 1.0.109

package/new.cmd.ts

@@ -0,0 +1,120 @@
+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/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/generator",
-  "version": "1.0.107",
+  "version": "1.0.109",
   "homepage": "https://bit.cloud/teambit/generator/generator",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.generator",
     "name": "generator",
-    "version": "1.0.107"
+    "version": "1.0.109"
   },
   "dependencies": {
     "camelcase": "6.2.0",
@@ -17,47 +17,43 @@
     "graphql-tag": "2.12.1",
     "lodash": "4.17.21",
     "execa": "2.1.0",
-    "core-js": "^3.0.0",
-    "@babel/runtime": "7.20.0",
     "@teambit/bit-error": "0.0.404",
     "@teambit/component-id": "1.2.0",
     "@teambit/harmony": "0.4.6",
     "@teambit/git.modules.git-ignore": "1.0.2",
-    "@teambit/envs": "1.0.106",
-    "@teambit/logger": "0.0.932",
-    "@teambit/new-component-helper": "1.0.106",
-    "@teambit/tracker": "1.0.106",
-    "@teambit/workspace-config-files": "1.0.106",
-    "@teambit/workspace.modules.node-modules-linker": "0.0.157",
-    "@teambit/workspace": "1.0.106",
-    "@teambit/component": "1.0.106",
-    "@teambit/cli": "0.0.839",
-    "@teambit/graphql": "1.0.106",
-    "@teambit/aspect-loader": "1.0.106",
-    "@teambit/bit": "1.5.37",
-    "@teambit/git": "1.0.106",
-    "@teambit/compiler": "1.0.106",
-    "@teambit/forking": "1.0.106",
-    "@teambit/importer": "1.0.106",
-    "@teambit/install": "1.0.106",
-    "@teambit/ui": "1.0.106",
-    "@teambit/config": "0.0.857"
+    "@teambit/envs": "1.0.108",
+    "@teambit/logger": "0.0.933",
+    "@teambit/new-component-helper": "1.0.108",
+    "@teambit/tracker": "1.0.108",
+    "@teambit/workspace-config-files": "1.0.108",
+    "@teambit/workspace.modules.node-modules-linker": "0.0.158",
+    "@teambit/workspace": "1.0.108",
+    "@teambit/component": "1.0.108",
+    "@teambit/cli": "0.0.840",
+    "@teambit/graphql": "1.0.108",
+    "@teambit/aspect-loader": "1.0.108",
+    "@teambit/bit": "1.6.1",
+    "@teambit/git": "1.0.108",
+    "@teambit/compiler": "1.0.108",
+    "@teambit/forking": "1.0.108",
+    "@teambit/importer": "1.0.108",
+    "@teambit/install": "1.0.108",
+    "@teambit/ui": "1.0.108",
+    "@teambit/config": "0.0.859"
   },
   "devDependencies": {
     "@types/fs-extra": "9.0.7",
-    "@types/react": "^17.0.8",
     "@types/lodash": "4.14.165",
     "@types/mocha": "9.1.0",
-    "@types/node": "12.20.4",
-    "@types/react-dom": "^17.0.5",
-    "@types/jest": "^26.0.0",
-    "@types/testing-library__jest-dom": "5.9.5",
+    "@types/jest": "^29.2.2",
+    "@types/testing-library__jest-dom": "^5.9.5",
+    "@teambit/harmony.envs.core-aspect-env": "0.0.13",
     "@teambit/generator.aspect-docs.generator": "0.0.169"
   },
   "peerDependencies": {
-    "@teambit/legacy": "1.0.624",
-    "react": "^16.8.0 || ^17.0.0",
-    "react-dom": "^16.8.0 || ^17.0.0"
+    "react": "^17.0.0 || ^18.0.0",
+    "@types/react": "^18.2.12",
+    "@teambit/legacy": "1.0.624"
   },
   "license": "Apache-2.0",
   "optionalDependencies": {},
@@ -71,7 +67,7 @@
   },
   "private": false,
   "engines": {
-    "node": ">=12.22.0"
+    "node": ">=16.0.0"
   },
   "repository": {
     "type": "git",
@@ -80,12 +76,9 @@
   "keywords": [
     "bit",
     "bit-aspect",
+    "bit-core-aspect",
     "components",
     "collaboration",
-    "web",
-    "react",
-    "react-components",
-    "angular",
-    "angular-components"
+    "web"
   ]
 }

package/starter-list.ts

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

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

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

@@ -0,0 +1,57 @@
+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/tsconfig.json

@@ -1,38 +1,33 @@
 {
   "compilerOptions": {
     "lib": [
-      "es2019",
-      "DOM",
-      "ES6",
-      "DOM.Iterable",
-      "ScriptHost"
+      "esnext",
+      "dom",
+      "dom.Iterable"
     ],
-    "target": "es2015",
-    "module": "CommonJS",
-    "jsx": "react",
-    "allowJs": true,
-    "composite": true,
+    "target": "es2020",
+    "module": "es2020",
+    "jsx": "react-jsx",
     "declaration": true,
     "sourceMap": true,
-    "skipLibCheck": true,
     "experimentalDecorators": true,
-    "outDir": "dist",
+    "skipLibCheck": true,
     "moduleResolution": "node",
     "esModuleInterop": true,
-    "rootDir": ".",
     "resolveJsonModule": true,
-    "emitDeclarationOnly": true,
-    "emitDecoratorMetadata": true,
-    "allowSyntheticDefaultImports": true,
-    "strictPropertyInitialization": false,
-    "strict": true,
-    "noImplicitAny": false,
-    "preserveConstEnums": true
+    "allowJs": true,
+    "outDir": "dist",
+    "emitDeclarationOnly": true
   },
   "exclude": [
+    "artifacts",
+    "public",
     "dist",
+    "node_modules",
+    "package.json",
     "esm.mjs",
-    "package.json"
+    "**/*.cjs",
+    "./dist"
   ],
   "include": [
     "**/*",

package/types/asset.d.ts

@@ -5,12 +5,12 @@ declare module '*.png' {
 declare module '*.svg' {
   import type { FunctionComponent, SVGProps } from 'react';
 
-  export const ReactComponent: FunctionComponent<SVGProps<SVGSVGElement> & { title?: string }>;
+  export const ReactComponent: FunctionComponent<
+    SVGProps<SVGSVGElement> & { title?: string }
+  >;
   const src: string;
   export default src;
 }
-
-// @TODO Gilad
 declare module '*.jpg' {
   const value: any;
   export = value;
@@ -27,3 +27,15 @@ 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.ts

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

package/workspace-generator.ts

@@ -0,0 +1,220 @@
+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();
+  }
+}