@teambit/generator 0.0.553 → 0.0.557

package/generator.main.runtime.ts

@@ -1,279 +0,0 @@
-import { GraphqlAspect, GraphqlMain } from '@teambit/graphql';
-import { CLIAspect, CLIMain, MainRuntime } from '@teambit/cli';
-import WorkspaceAspect, { Workspace } from '@teambit/workspace';
-import { EnvsAspect, EnvsMain } from '@teambit/envs';
-import { ConsumerNotFound } from '@teambit/legacy/dist/consumer/exceptions';
-import { Component } from '@teambit/component';
-import { ComponentID } from '@teambit/component-id';
-import { loadBit } from '@teambit/bit';
-import { Slot, SlotRegistry } from '@teambit/harmony';
-import { BitError } from '@teambit/bit-error';
-import { InvalidScopeName, isValidScopeName } from '@teambit/legacy-bit-id';
-import AspectLoaderAspect, { AspectLoaderMain } from '@teambit/aspect-loader';
-import { ComponentTemplate } from './component-template';
-import { GeneratorAspect } from './generator.aspect';
-import { CreateCmd, CreateOptions } from './create.cmd';
-import { TemplatesCmd } from './templates.cmd';
-import { generatorSchema } from './generator.graphql';
-import { ComponentGenerator, GenerateResult } from './component-generator';
-import { WorkspaceGenerator } from './workspace-generator';
-import { WorkspaceTemplate } from './workspace-template';
-import { NewCmd, NewOptions } from './new.cmd';
-import { componentGeneratorTemplate } from './templates/component-generator';
-import { workspaceGeneratorTemplate } from './templates/workspace-generator';
-
-export type ComponentTemplateSlot = SlotRegistry<ComponentTemplate[]>;
-export type WorkspaceTemplateSlot = SlotRegistry<WorkspaceTemplate[]>;
-
-export type TemplateDescriptor = { aspectId: string; name: string; description?: string; hidden?: boolean };
-
-export type GeneratorConfig = {
-  /**
-   * array of aspects to include in the list of templates.
-   */
-  aspects: string[];
-};
-
-export class GeneratorMain {
-  private aspectLoaded = false;
-  constructor(
-    private componentTemplateSlot: ComponentTemplateSlot,
-    private workspaceTemplateSlot: WorkspaceTemplateSlot,
-    private config: GeneratorConfig,
-    private workspace: Workspace,
-    private envs: EnvsMain,
-    private aspectLoader: AspectLoaderMain
-  ) {}
-
-  /**
-   * register a new component template.
-   */
-  registerComponentTemplate(templates: ComponentTemplate[]) {
-    this.componentTemplateSlot.register(templates);
-    return this;
-  }
-
-  /**
-   * register a new component template.
-   */
-  registerWorkspaceTemplate(templates: WorkspaceTemplate[]) {
-    this.workspaceTemplateSlot.register(templates);
-    return this;
-  }
-
-  /**
-   * list all component templates registered in the workspace or workspace templates in case the
-   * workspace is not available
-   */
-  async listTemplates(): Promise<TemplateDescriptor[]> {
-    const getTemplateDescriptor = ({
-      id,
-      template,
-    }: {
-      id: string;
-      template: WorkspaceTemplate | ComponentTemplate;
-    }) => ({
-      aspectId: id,
-      name: template.name,
-      description: template.description,
-      hidden: template.hidden,
-    });
-    return this.isRunningInsideWorkspace()
-      ? this.getAllComponentTemplatesFlattened().map(getTemplateDescriptor)
-      : this.getAllWorkspaceTemplatesFlattened().map(getTemplateDescriptor);
-  }
-
-  /**
-   * @deprecated use this.listTemplates()
-   */
-  async listComponentTemplates(): Promise<TemplateDescriptor[]> {
-    return this.listTemplates();
-  }
-
-  isRunningInsideWorkspace(): boolean {
-    return Boolean(this.workspace);
-  }
-
-  /**
-   * get all component templates registered by a specific aspect ID.
-   */
-  getComponentTemplateByAspect(aspectId: string): ComponentTemplate[] {
-    return this.componentTemplateSlot.get(aspectId) || [];
-  }
-
-  /**
-   * returns a specific component template.
-   */
-  getComponentTemplate(name: string, aspectId?: string): ComponentTemplate | undefined {
-    const templates = this.getAllComponentTemplatesFlattened();
-    const found = templates.find(({ id, template }) => {
-      if (aspectId && id !== aspectId) return false;
-      return template.name === name;
-    });
-    return found?.template;
-  }
-
-  /**
-   * in the case the aspect-id is given and this aspect doesn't exist locally, import it to the
-   * global scope and load it from the capsule
-   */
-  async findTemplateInGlobalScope(aspectId: string, name?: string): Promise<WorkspaceTemplate | undefined> {
-    const aspects = await this.aspectLoader.loadAspectsFromGlobalScope([aspectId]);
-    const fullAspectId = aspects[0].id.toString();
-    return this.searchRegisteredWorkspaceTemplate(name, fullAspectId);
-  }
-
-  async findTemplateInOtherWorkspace(workspacePath: string, name: string, aspectId?: string) {
-    if (!aspectId)
-      throw new BitError(
-        `to load a template from a different workspace, please provide the aspect-id using --aspect flag`
-      );
-    const harmony = await loadBit(workspacePath);
-    let workspace: Workspace;
-    try {
-      workspace = harmony.get<Workspace>(WorkspaceAspect.id);
-    } catch (err: any) {
-      throw new Error(`fatal: "${workspacePath}" is not a valid Bit workspace, make sure the path is correct`);
-    }
-    const aspectComponentId = await workspace.resolveComponentId(aspectId);
-    await workspace.loadAspects([aspectId], true);
-    const aspectFullId = aspectComponentId.toString();
-    const generator = harmony.get<GeneratorMain>(GeneratorAspect.id);
-    return generator.searchRegisteredWorkspaceTemplate(name, aspectFullId);
-  }
-
-  /**
-   * returns a specific workspace template.
-   */
-  async getWorkspaceTemplate(
-    name: string,
-    aspectId?: string
-  ): Promise<{ workspaceTemplate: WorkspaceTemplate; aspect?: Component }> {
-    const registeredTemplate = await this.searchRegisteredWorkspaceTemplate(name, aspectId);
-    if (registeredTemplate) {
-      return { workspaceTemplate: registeredTemplate };
-    }
-    if (!aspectId) {
-      throw new BitError(`template "${name}" was not found, if this is a custom-template, please use --aspect flag`);
-    }
-    const aspects = await this.aspectLoader.loadAspectsFromGlobalScope([aspectId]);
-    const aspect = aspects[0];
-    const fullAspectId = aspect.id.toString();
-    const fromGlobal = await this.searchRegisteredWorkspaceTemplate(name, fullAspectId);
-    if (fromGlobal) {
-      return { workspaceTemplate: fromGlobal, aspect };
-    }
-    throw new BitError(`template "${name}" was not found`);
-  }
-
-  async searchRegisteredWorkspaceTemplate(name?: string, aspectId?: string): Promise<WorkspaceTemplate | undefined> {
-    const templates = this.getAllWorkspaceTemplatesFlattened();
-    const found = templates.find(({ id, template }) => {
-      if (aspectId && name) return aspectId === id && name === template.name;
-      if (aspectId) return aspectId === id;
-      if (name) return name === template.name;
-      throw new Error(`searchRegisteredWorkspaceTemplate expects to get "name" or "aspectId"`);
-    });
-    return found?.template;
-  }
-
-  async generateComponentTemplate(
-    componentNames: string[],
-    templateName: string,
-    options: CreateOptions
-  ): Promise<GenerateResult[]> {
-    if (!this.workspace) throw new ConsumerNotFound();
-    await this.loadAspects();
-    const { namespace, aspect: aspectId } = options;
-    const template = this.getComponentTemplate(templateName, aspectId);
-    if (!template) throw new BitError(`template "${templateName}" was not found`);
-    const scope = options.scope || this.workspace.defaultScope;
-    if (!isValidScopeName(scope)) {
-      throw new InvalidScopeName(scope);
-    }
-    if (!scope) throw new BitError(`failed finding defaultScope`);
-
-    const componentIds = componentNames.map((componentName) => {
-      const fullComponentName = namespace ? `${namespace}/${componentName}` : componentName;
-      return ComponentID.fromObject({ name: fullComponentName }, scope);
-    });
-
-    const componentGenerator = new ComponentGenerator(this.workspace, componentIds, options, template, this.envs);
-    return componentGenerator.generate();
-  }
-
-  async generateWorkspaceTemplate(workspaceName: string, templateName: string, options: NewOptions) {
-    if (this.workspace) {
-      throw new BitError('Error: unable to generate a new workspace inside of an existing workspace');
-    }
-    const { aspect: aspectId, loadFrom } = options;
-    let template: WorkspaceTemplate | undefined;
-    let aspectComponent: Component | undefined;
-    if (loadFrom) {
-      template = await this.findTemplateInOtherWorkspace(loadFrom, templateName, aspectId);
-    } else {
-      const { workspaceTemplate, aspect } = await this.getWorkspaceTemplate(templateName, aspectId);
-      template = workspaceTemplate;
-      aspectComponent = aspect;
-    }
-    if (!template) throw new BitError(`template "${templateName}" was not found`);
-    const workspaceGenerator = new WorkspaceGenerator(workspaceName, options, template, aspectComponent);
-    const workspacePath = await workspaceGenerator.generate();
-
-    return workspacePath;
-  }
-
-  private getAllComponentTemplatesFlattened(): Array<{ id: string; template: ComponentTemplate }> {
-    const templatesByAspects = this.componentTemplateSlot.toArray();
-    return templatesByAspects.flatMap(([id, componentTemplates]) => {
-      return componentTemplates.map((template) => ({
-        id,
-        template,
-      }));
-    });
-  }
-
-  private getAllWorkspaceTemplatesFlattened(): Array<{ id: string; template: WorkspaceTemplate }> {
-    const templatesByAspects = this.workspaceTemplateSlot.toArray();
-    return templatesByAspects.flatMap(([id, workspaceTemplates]) => {
-      return workspaceTemplates.map((template) => ({
-        id,
-        template,
-      }));
-    });
-  }
-
-  private async loadAspects() {
-    if (this.aspectLoaded) return;
-    await this.workspace.loadAspects(this.config.aspects);
-    this.aspectLoaded = true;
-  }
-
-  static slots = [Slot.withType<ComponentTemplate[]>(), Slot.withType<WorkspaceTemplate[]>()];
-
-  static dependencies = [WorkspaceAspect, CLIAspect, GraphqlAspect, EnvsAspect, AspectLoaderAspect];
-
-  static runtime = MainRuntime;
-
-  static async provider(
-    [workspace, cli, graphql, envs, aspectLoader]: [Workspace, CLIMain, GraphqlMain, EnvsMain, AspectLoaderMain],
-    config: GeneratorConfig,
-    [componentTemplateSlot, workspaceTemplateSlot]: [ComponentTemplateSlot, WorkspaceTemplateSlot]
-  ) {
-    const generator = new GeneratorMain(
-      componentTemplateSlot,
-      workspaceTemplateSlot,
-      config,
-      workspace,
-      envs,
-      aspectLoader
-    );
-    const commands = [new CreateCmd(generator), new TemplatesCmd(generator), new NewCmd(generator)];
-    cli.register(...commands);
-    graphql.register(generatorSchema(generator));
-    generator.registerComponentTemplate([componentGeneratorTemplate, workspaceGeneratorTemplate]);
-    return generator;
-  }
-}
-
-GeneratorAspect.addRuntime(GeneratorMain);

package/index.ts

@@ -1,4 +0,0 @@
-export type { GeneratorMain } from './generator.main.runtime';
-export { ComponentContext, ComponentTemplate, ComponentFile } from './component-template';
-export { WorkspaceContext, WorkspaceTemplate, WorkspaceFile } from './workspace-template';
-export { GeneratorAspect } from './generator.aspect';

package/new.cmd.ts

@@ -1,79 +0,0 @@
-import { Command, CommandOptions } from '@teambit/cli';
-import chalk from 'chalk';
-import { GeneratorMain } from './generator.main.runtime';
-
-export type NewOptions = {
-  aspect?: string;
-  defaultScope?: string;
-  skipGit?: boolean;
-  loadFrom?: string;
-  empty?: boolean;
-};
-
-export class NewCmd implements Command {
-  name = 'new <templateName> <workspaceName>';
-  description = 'Create a new workspace from a template';
-  shortDescription = '';
-  alias = '';
-  loader = true;
-  group = 'start';
-  options = [
-    [
-      'a',
-      'aspect <string>',
-      'aspect-id of the template. mandatory for non-core aspects. helpful for core aspects in case of a name collision',
-    ],
-    ['d', 'default-scope <string>', `set defaultScope in the new workspace.jsonc`],
-    ['', 'standalone', 'DEPRECATED. use --skip-git instead'],
-    ['s', 'skip-git', 'skip generation of Git repository'],
-    ['e', 'empty', 'empty workspace with no components (relevant for templates that add components by default)'],
-    [
-      '',
-      'load-from <string>',
-      'path to the workspace containing the template. helpful during a development of a workspace-template',
-    ],
-  ] as CommandOptions;
-
-  constructor(private generator: GeneratorMain) {}
-
-  async report([templateName, workspaceName]: [string, string], options: NewOptions & { standalone: boolean }) {
-    options.skipGit = options.skipGit ?? options.standalone;
-    const results = await this.generator.generateWorkspaceTemplate(workspaceName, templateName, options);
-    return chalk.white(
-      `${chalk.green(`
-
-Congrats! A new workspace has been created successfully at '${results}'`)}
-
-Inside the directory '${workspaceName}' you can run various commands including:
-
-      ${chalk.yellow('bit start')}
-        Starts the workspace in development mode
-
-      ${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!")}
-
-      ${chalk.yellow(`cd ${workspaceName}`)}
-      ${chalk.yellow(`bit start`)}
-
-      `
-    );
-  }
-}

package/templates/component-generator/files/aspect-file.ts

@@ -1,10 +0,0 @@
-import { ComponentContext } from '@teambit/generator';
-
-export function aspectFile({ namePascalCase, componentId }: ComponentContext) {
-  return `import { Aspect } from '@teambit/harmony';
-
-export const ${namePascalCase}Aspect = Aspect.create({
-  id: '${componentId}',
-});
-  `;
-}

package/templates/component-generator/files/docs-file.ts

@@ -1,54 +0,0 @@
-export function docsFile() {
-  return `### Configuring your Generator
-
-Edit your \`workspace.jsonc\` file and set this component to use the \`teambit.harmony/aspect\` env under the variants object.
-
-\`\`\`json
-"teambit.workspace/variants": {
-  "{my-components}": {
-    "teambit.harmony/aspect": {}
-  },
-}
-\`\`\`
-
-To check if your component is using the correct env you can run \`bit envs\` or \`bit show my-components\`
-
-Edit your \`workspace.jsonc\` file and add the component id, (scope name / component name) to teambit generator. This should go at root level. The component id can be found in the \`aspect.ts\` file:
-
-\`\`\`json
-{
-  "teambit.generator/generator": {
-    "aspects": ["my-scope-name/my-components"]
-  },
-}
-\`\`\`
-
-This registers the component aspect so that your templates will appear in the CLI when you run \`bit templates\`.
-
-### Modifying your Generator
-
-The \`my-components.main.runtime.ts\` file contains an array of templates that you can modify and add to to create different templates and numerous files to be generated.
-
-### Using your Generator
-
-Use your generator to create the component files
-
-\`\`\`bash
-bit create my-components component1
-\`\`\`
-
-### Exporting your Generator
-
-Tag and export your generator component so you can use it in any other workspace. Make sure the scope name is set correctly in the \`aspect.ts\` file before tagging and exporting. Once you have tagged and exported the component you can add it to the \`workspace.jsonc\` file in the workspace where you want to use this generator.
-
-\`\`\`json
-{
-  "teambit.generator/generator": {
-    "aspects": ["my-scope-name/my-components"]
-  },
-}
-\`\`\`
-
-Run \`bit templates\` to see your generator and then use it to generate you components.
-`;
-}

package/templates/component-generator/files/index.ts

@@ -1,10 +0,0 @@
-import { ComponentContext } from '@teambit/generator';
-
-export function indexFile({ namePascalCase, name }: ComponentContext) {
-  return `import { ${namePascalCase}Aspect } from './${name}.aspect';
-
-export type { ${namePascalCase}Main } from './${name}.main.runtime';
-export default ${namePascalCase}Aspect;
-export { ${namePascalCase}Aspect };
-`;
-}

package/templates/component-generator/files/main-runtime.ts

@@ -1,125 +0,0 @@
-import { ComponentContext } from '@teambit/generator';
-
-export function mainRuntime({ name, namePascalCase }: ComponentContext) {
-  return `import { MainRuntime } from '@teambit/cli';
-import { GeneratorMain, GeneratorAspect, ComponentContext } from '@teambit/generator';
-import { ${namePascalCase}Aspect } from './${name}.aspect';
-
-export class ${namePascalCase}Main {
-  static slots = [];
-  static dependencies = [GeneratorAspect];
-  static runtime = MainRuntime;
-  static async provider([generator]: [GeneratorMain]) {
-  /**
-  * Array of templates. Add as many templates as you want
-  * Separate the templates to multiple files if you prefer
-  * Modify, add or remove files as needed
-  * See the docs file of this component for more info
-  */
-
-  generator.registerComponentTemplate([
-      {
-        name: 'component1',
-        description: 'description for component1',
-        generateFiles: (context: ComponentContext) => {
-          return [
-
-            // index file
-            {
-              relativePath: 'index.ts',
-              isMain: true,
-              content: \`export { \${context.namePascalCase} } from './\${context.name}';
-export type { \${context.namePascalCase}Props } from './\${context.name}';
-\`,
-            },
-
-            // component file
-            {
-              relativePath: \`\${context.name}.tsx\`,
-              content: \`import React from 'react';
-
-export type \${context.namePascalCase}Props = {
-  /**
-   * a text to be rendered in the component.
-   */
-  text: string
-};
-
-export function \${context.namePascalCase}({ text }: \${context.namePascalCase}Props) {
-  return (
-    <div>
-      {text}
-    </div>
-  );
-}\`,
-            },
-
-            // docs file
-            {
-              relativePath: \`\${context.name}.docs.mdx\`,
-              content: \`---
-description: 'A React Component for rendering text.'
-labels: ['text', 'ui']
----
-
-import { \${context.namePascalCase} } from './\${context.name}';
-\`
-            },
-
-            // composition file
-            {
-              relativePath: \`\${context.name}.composition.tsx\`,
-              content: \`import React from 'react';
-import { \${context.namePascalCase} } from './\${context.name}';
-
-export const Basic\${context.namePascalCase}  = () => (
-  <\${context.namePascalCase}  text="hello from \${context.namePascalCase} " />
-);
-\`
-            },
-
-            // test file
-            {
-              relativePath: \`\${context.name}.spec.tsx\`,
-              content: \`import React from 'react';
-import { render } from '@testing-library/react';
-import { Basic\${context.namePascalCase} } from './\${context.name}.composition';
-
-it('should render with the correct text', () => {
-  const { getByText } = render(<Basic\${context.namePascalCase} />);
-  const rendered = getByText('hello from \${context.namePascalCase}');
-  expect(rendered).toBeTruthy();
-});
-\`
-            },
-            // add more files here such as css/sass
-          ];
-        },
-      },
-
-    // component 2
-    {
-        name: 'component2',
-        description: 'description for component2',
-        generateFiles: (context: ComponentContext) => {
-          return [
-
-            // index file
-            {
-              relativePath: 'index.ts',
-              isMain: true,
-              content: \`export {} from '';
-\`,
-            },
-          ]
-        }
-      }
-    ]);
-
-    return new ${namePascalCase}Main();
-  }
-}
-
-${namePascalCase}Aspect.addRuntime(${namePascalCase}Main);
-`;
-}

package/templates/component-generator/index.ts

@@ -1,32 +0,0 @@
-import { ComponentContext, ComponentTemplate } from '@teambit/generator';
-import { indexFile } from './files/index';
-import { aspectFile } from './files/aspect-file';
-import { docsFile } from './files/docs-file';
-import { mainRuntime } from './files/main-runtime';
-
-export const componentGeneratorTemplate: ComponentTemplate = {
-  name: 'component-generator',
-  description:
-    'create your own component generator \nDocs: https://harmony-docs.bit.dev/extending-bit/creating-a-custom-generator',
-  generateFiles: (context: ComponentContext) => {
-    return [
-      {
-        relativePath: 'index.ts',
-        content: indexFile(context),
-        isMain: true,
-      },
-      {
-        relativePath: `${context.name}.aspect.ts`,
-        content: aspectFile(context),
-      },
-      {
-        relativePath: `${context.name}.docs.mdx`,
-        content: docsFile(),
-      },
-      {
-        relativePath: `${context.name}.main.runtime.ts`,
-        content: mainRuntime(context),
-      },
-    ];
-  },
-};

package/templates/workspace-generator/files/aspect-file.ts

@@ -1,10 +0,0 @@
-import { ComponentContext } from '@teambit/generator';
-
-export function aspectFile({ namePascalCase, componentId }: ComponentContext) {
-  return `import { Aspect } from '@teambit/harmony';
-
-export const ${namePascalCase}Aspect = Aspect.create({
-  id: '${componentId}',
-});
-`;
-}

package/templates/workspace-generator/files/docs-file.ts

@@ -1,37 +0,0 @@
-export function docsFile() {
-  return `---
-description: Generator for generating a workspace
-labels: ['generator', 'templates', 'workspace']
----
-
-## Registering your Workspace
-
-Register your workspace template under the aspect environment in the variants section of the workspace.jsonc file.
-
-\`\`\`json
-"teambit.workspace/variants": {
-    "{workspace-name}": {
-      "teambit.harmony/aspect": {}
-    }
-  }
-\`\`\`
-
-## Customizing your Workspace
-
-See the docs for more info on [Customizing your Generator](https://harmony-docs.bit.dev/extending-bit/creating-a-custom-workspace-generator)
-
-## Using the Workspace Generator
-
-How to use this generator locally, essentially for development purposes:
-
-\`\`\`js
-bit new <template-name> <workspace-name> --load-from /Users/me/path/to/this/dir --aspect <workspace-template-id>
-\`\`\`
-
-How to use this generator after exporting to a remote scope:
-
-\`\`\`js
-bit new <template-name> <workspace-name> --aspect <workspace-template-id>
-\`\`\`
-`;
-}