@teambit/aspect 1.0.108 → 1.0.109

package/aspect.main.runtime.ts

@@ -1,299 +0,0 @@
-import { Harmony } from '@teambit/harmony';
-import { AspectLoaderAspect, AspectLoaderMain } from '@teambit/aspect-loader';
-import { LoggerAspect, LoggerMain } from '@teambit/logger';
-import mergeDeepLeft from 'ramda/src/mergeDeepLeft';
-import { BuilderAspect, BuilderMain } from '@teambit/builder';
-import { compact } from 'lodash';
-import { EnvPolicyConfigObject } from '@teambit/dependency-resolver';
-import { BitError } from '@teambit/bit-error';
-import { CLIAspect, CLIMain, MainRuntime } from '@teambit/cli';
-import { EnvContext, Environment, EnvsAspect, EnvsMain, EnvTransformer } from '@teambit/envs';
-import { ReactAspect, ReactMain } from '@teambit/react';
-import { GeneratorAspect, GeneratorMain } from '@teambit/generator';
-import { BabelAspect, BabelMain } from '@teambit/babel';
-import { ComponentID } from '@teambit/component-id';
-import { AspectList } from '@teambit/component';
-import WorkerAspect, { WorkerMain } from '@teambit/worker';
-import WorkspaceAspect, { ExtensionsOrigin, Workspace } from '@teambit/workspace';
-import { CompilerAspect, CompilerMain } from '@teambit/compiler';
-import { AspectAspect } from './aspect.aspect';
-import { AspectEnv } from './aspect.env';
-import { CoreExporterTask } from './core-exporter.task';
-import { babelConfig } from './babel/babel-config';
-import {
-  AspectCmd,
-  GetAspectCmd,
-  ListAspectCmd,
-  SetAspectCmd,
-  SetAspectOptions,
-  UnsetAspectCmd,
-  UpdateAspectCmd,
-} from './aspect.cmd';
-import { getTemplates } from './aspect.templates';
-
-export type AspectSource = { aspectName: string; source: string; level: string };
-
-const tsconfig = require('./typescript/tsconfig.json');
-
-export class AspectMain {
-  constructor(readonly aspectEnv: AspectEnv, private envs: EnvsMain, private workspace: Workspace) {}
-
-  /**
-   * compose your own aspect environment.
-   */
-  compose(transformers: EnvTransformer[] = [], targetEnv: Environment = {}) {
-    return this.envs.compose(this.envs.merge(targetEnv, this.aspectEnv), transformers);
-  }
-
-  async listAspectsOfComponent(pattern?: string): Promise<{ [component: string]: AspectSource[] }> {
-    const getIds = async () => {
-      if (!pattern) return this.workspace.listIds();
-      return this.workspace.idsByPattern(pattern);
-    };
-    const componentIds = await getIds();
-    const results = {};
-    await Promise.all(
-      componentIds.map(async (id) => {
-        const aspectSources = await this.getAspectNamesForComponent(id);
-        results[id.toString()] = aspectSources;
-      })
-    );
-    return results;
-  }
-
-  get babelConfig() {
-    return babelConfig;
-  }
-
-  private async getAspectNamesForComponent(id: ComponentID): Promise<AspectSource[]> {
-    const componentFromScope = await this.workspace.scope.get(id);
-    const { beforeMerge } = await this.workspace.componentExtensions(id, componentFromScope);
-    const aspectSources: AspectSource[] = [];
-    beforeMerge.forEach((source) => {
-      source.extensions.forEach((ext) => {
-        const aspectName = ext.name || ext.extensionId?.toString() || '<no-name>';
-        const alreadySaved = aspectSources.find((_) => _.aspectName === aspectName);
-        if (alreadySaved) return;
-        aspectSources.push({ aspectName, source: source.origin, level: this.getLevelBySourceOrigin(source.origin) });
-      });
-    });
-    return aspectSources;
-  }
-
-  private getLevelBySourceOrigin(origin: ExtensionsOrigin) {
-    switch (origin) {
-      case 'BitmapFile':
-      case 'ComponentJsonFile':
-      case 'ModelSpecific':
-        return 'component';
-      default:
-        return 'workspace';
-    }
-  }
-
-  async setAspectsToComponents(
-    pattern: string,
-    aspectId: string,
-    config: Record<string, any> = {},
-    options: SetAspectOptions = {}
-  ): Promise<ComponentID[]> {
-    const componentIds = await this.workspace.idsByPattern(pattern);
-    await Promise.all(
-      componentIds.map(async (componentId) => {
-        await this.workspace.addSpecificComponentConfig(componentId, aspectId, config, {
-          shouldMergeWithExisting: options.merge,
-        });
-      })
-    );
-    await this.workspace.bitMap.write(`aspect-set (${aspectId})`);
-
-    return componentIds;
-  }
-
-  async unsetAspectsFromComponents(pattern: string, aspectIdStr: string): Promise<ComponentID[]> {
-    const componentIds = await this.workspace.idsByPattern(pattern);
-    const aspectId = await this.workspace.resolveComponentId(aspectIdStr);
-    const components = await this.workspace.getMany(componentIds);
-    const updatedCompIds: ComponentID[] = [];
-    await Promise.all(
-      components.map(async (component) => {
-        const existAspect = component.state.aspects.get(aspectId.toStringWithoutVersion());
-        if (!existAspect) return;
-        await this.workspace.removeSpecificComponentConfig(component.id, existAspect.id.toString(), true);
-        updatedCompIds.push(component.id);
-      })
-    );
-    await this.workspace.bitMap.write(`aspect-unset (${aspectId})`);
-    return updatedCompIds;
-  }
-
-  /**
-   * returns all aspects info of a component, include the config and the data.
-   */
-  async getAspectsOfComponent(id: string | ComponentID): Promise<AspectList> {
-    if (typeof id === 'string') {
-      id = await this.workspace.resolveComponentId(id);
-    }
-    const component = await this.workspace.get(id);
-    return component.state.aspects;
-  }
-
-  /**
-   * helps debugging why/how an aspect was set to a component
-   */
-  async getAspectsOfComponentForDebugging(id: string | ComponentID) {
-    if (typeof id === 'string') {
-      id = await this.workspace.resolveComponentId(id);
-    }
-    const componentFromScope = await this.workspace.scope.get(id);
-    const { extensions, beforeMerge } = await this.workspace.componentExtensions(id, componentFromScope);
-    const component = await this.workspace.get(id);
-    return {
-      aspects: component.state.aspects,
-      extensions,
-      beforeMerge,
-    };
-  }
-
-  async updateAspectsToComponents(
-    aspectId: string,
-    pattern?: string
-  ): Promise<{ updated: ComponentID[]; alreadyUpToDate: ComponentID[] }> {
-    let aspectCompId = await this.workspace.resolveComponentId(aspectId);
-    if (!aspectCompId.hasVersion()) {
-      try {
-        const fromRemote = await this.workspace.scope.getRemoteComponent(aspectCompId);
-        aspectCompId = aspectCompId.changeVersion(fromRemote.id.version);
-      } catch (err) {
-        throw new BitError(
-          `unable to find ${aspectId} in the remote. if this is a local aspect, please provide a version with your aspect (${aspectId}) to update to`
-        );
-      }
-    }
-    const allCompIds = pattern ? await this.workspace.idsByPattern(pattern) : await this.workspace.listIds();
-    const allComps = await this.workspace.getMany(allCompIds);
-    const alreadyUpToDate: ComponentID[] = [];
-    const updatedComponentIds = await Promise.all(
-      allComps.map(async (comp) => {
-        const aspect = comp.state.aspects.get(aspectCompId.toStringWithoutVersion());
-        if (!aspect) return undefined;
-        if (aspect.id.version === aspectCompId.version) {
-          // nothing to update
-          alreadyUpToDate.push(comp.id);
-          return undefined;
-        }
-        // don't mark with minus if not exist in .bitmap. it's not needed. when the component is loaded, the
-        // merge-operation of the aspects removes duplicate aspect-id with different versions.
-        await this.workspace.removeSpecificComponentConfig(comp.id, aspect.id.toString(), false);
-        await this.workspace.addSpecificComponentConfig(comp.id, aspectCompId.toString(), aspect.config);
-        return comp.id;
-      })
-    );
-    await this.workspace.bitMap.write(`aspect-update (${aspectCompId})`);
-    return { updated: compact(updatedComponentIds), alreadyUpToDate };
-  }
-
-  /**
-   * override the dependency configuration of the component environment.
-   */
-  overrideDependencies(dependencyPolicy: EnvPolicyConfigObject) {
-    return this.envs.override({
-      getDependencies: async () => {
-        const reactDeps = await this.aspectEnv.getDependencies();
-        return mergeDeepLeft(dependencyPolicy, reactDeps);
-      },
-    });
-  }
-
-  static runtime = MainRuntime;
-  static dependencies = [
-    ReactAspect,
-    EnvsAspect,
-    BuilderAspect,
-    AspectLoaderAspect,
-    CompilerAspect,
-    BabelAspect,
-    GeneratorAspect,
-    WorkspaceAspect,
-    CLIAspect,
-    LoggerAspect,
-    WorkerAspect,
-  ];
-
-  static async provider(
-    [react, envs, builder, aspectLoader, compiler, babel, generator, workspace, cli, loggerMain, workerMain]: [
-      ReactMain,
-      EnvsMain,
-      BuilderMain,
-      AspectLoaderMain,
-      CompilerMain,
-      BabelMain,
-      GeneratorMain,
-      Workspace,
-      CLIMain,
-      LoggerMain,
-      WorkerMain
-    ],
-    config,
-    slots,
-    harmony: Harmony
-  ) {
-    const logger = loggerMain.createLogger(AspectAspect.id);
-
-    const babelCompiler = babel.createCompiler({
-      babelTransformOptions: babelConfig,
-      distDir: 'dist',
-      distGlobPatterns: [`dist/**`, `!dist/**/*.d.ts`, `!dist/tsconfig.tsbuildinfo`],
-    });
-    const compilerOverride = envs.override({
-      getCompiler: () => {
-        return babelCompiler;
-      },
-    });
-
-    const transformer = (tsConfigMutator) => {
-      tsConfigMutator
-        .mergeTsConfig(tsconfig)
-        .setArtifactName('declaration')
-        .setDistGlobPatterns([`dist/**/*.d.ts`])
-        .setShouldCopyNonSupportedFiles(false);
-      return tsConfigMutator;
-    };
-    const tsCompiler = react.env.getCjsCompilerTask([transformer]);
-
-    const compilerTasksOverride = react.overrideCompilerTasks([
-      compiler.createTask('BabelCompiler', babelCompiler),
-      tsCompiler,
-    ]);
-
-    const aspectEnv = react.compose(
-      [compilerOverride, compilerTasksOverride],
-      new AspectEnv(react.reactEnv, aspectLoader, logger)
-    );
-
-    const coreExporterTask = new CoreExporterTask(aspectEnv, aspectLoader);
-    if (!__dirname.includes('@teambit/bit')) {
-      builder.registerBuildTasks([coreExporterTask]);
-    }
-
-    envs.registerEnv(aspectEnv);
-    if (generator) {
-      const envContext = new EnvContext(ComponentID.fromString(ReactAspect.id), loggerMain, workerMain, harmony);
-      generator.registerComponentTemplate(getTemplates(envContext));
-    }
-    const aspectMain = new AspectMain(aspectEnv as AspectEnv, envs, workspace);
-    const aspectCmd = new AspectCmd();
-    aspectCmd.commands = [
-      new ListAspectCmd(aspectMain),
-      new GetAspectCmd(aspectMain),
-      new SetAspectCmd(aspectMain),
-      new UnsetAspectCmd(aspectMain),
-      new UpdateAspectCmd(aspectMain),
-    ];
-    cli.register(aspectCmd);
-
-    return aspectMain;
-  }
-}
-
-AspectAspect.addRuntime(AspectMain);

package/aspect.templates.ts

@@ -1,24 +0,0 @@
-import {
-  HarmonyEnvTemplate,
-  HarmonyPlatformTemplate,
-  PlatformAspectTemplate,
-  HarmonyRuntimeTemplate,
-  AspectTemplate,
-} from '@bitdev/harmony.generators.harmony-templates';
-import { EnvContext } from '@teambit/envs';
-import { ComponentTemplate, TemplateList } from '@teambit/generator';
-import { aspectTemplate } from './templates/aspect';
-
-const templateListHandler = TemplateList.from([
-  HarmonyPlatformTemplate.from({ env: 'bitdev.harmony/harmony-env' }),
-  PlatformAspectTemplate.from({ env: 'bitdev.harmony/harmony-env' }),
-  HarmonyRuntimeTemplate.from({ env: 'bitdev.harmony/harmony-env' }),
-  AspectTemplate.from({ env: 'bitdev.harmony/harmony-env' }),
-  HarmonyEnvTemplate.from(),
-]);
-
-export function getTemplates(envContext: EnvContext): ComponentTemplate[] {
-  const templateList = templateListHandler(envContext);
-  const newTemplates = templateList.compute();
-  return [...newTemplates, aspectTemplate];
-}

package/core-exporter.task.ts

@@ -1,82 +0,0 @@
-import path from 'path';
-import fs from 'fs-extra';
-import { BuildContext, BuiltTaskResult, BuildTask, TaskLocation } from '@teambit/builder';
-import { AspectLoaderMain, getCoreAspectName, getCoreAspectPackageName } from '@teambit/aspect-loader';
-import { Capsule } from '@teambit/isolator';
-import { Environment } from '@teambit/envs';
-
-export class CoreExporterTask implements BuildTask {
-  constructor(private env: Environment, private aspectLoader: AspectLoaderMain) {}
-
-  location: TaskLocation = 'start';
-  readonly aspectId = 'teambit.harmony/aspect';
-  readonly name = 'CoreExporter';
-  readonly description = 'export all core aspects via the main aspects';
-
-  async execute(context: BuildContext): Promise<BuiltTaskResult> {
-    const mainAspect = this.aspectLoader.mainAspect;
-    const capsules = context.capsuleNetwork.seedersCapsules;
-    const mainAspectCapsule = capsules.find((capsule) => capsule.component.id.name === mainAspect.name);
-    if (mainAspectCapsule) {
-      const distDir = this.env.getCompiler().distDir;
-      await this.addFolderForAllCoreAspects(mainAspectCapsule, distDir);
-      await this.addFolderForHarmony(mainAspectCapsule, distDir);
-      await this.addFolderForLegacy(mainAspectCapsule, distDir);
-    }
-
-    return {
-      componentsResults: [],
-      artifacts: [],
-    };
-  }
-
-  private addFolderForAllCoreAspects(mainAspectCapsule: Capsule, distDir: string) {
-    const coreAspectsIds = this.aspectLoader.getCoreAspectIds();
-    const coreAspectsNamesPackages = coreAspectsIds.map((id) => {
-      return {
-        name: getCoreAspectName(id),
-        packageName: getCoreAspectPackageName(id),
-      };
-    });
-    const capsuleDir = mainAspectCapsule.path;
-    const createBarrelFilesP = coreAspectsNamesPackages.map(async ({ name, packageName }) => {
-      const newDirPath = path.join(capsuleDir, distDir, name);
-      await fs.ensureDir(newDirPath);
-      const barrelContent = generateBarrelFile(packageName);
-      await fs.writeFile(path.join(newDirPath, 'index.js'), barrelContent);
-    });
-    return Promise.all(createBarrelFilesP);
-  }
-
-  private async addFolderForNonAspectCorePackages(
-    mainAspectCapsule: Capsule,
-    distDir: string,
-    name: string,
-    packageName = `@teambit/${name}`
-  ) {
-    const capsuleDir = mainAspectCapsule.path;
-    const newDirPath = path.join(capsuleDir, distDir, name);
-    await fs.ensureDir(newDirPath);
-    const barrelContent = generateBarrelFile(packageName);
-    await fs.writeFile(path.join(newDirPath, 'index.js'), barrelContent);
-  }
-
-  private async addFolderForHarmony(mainAspectCapsule: Capsule, distDir: string) {
-    const name = 'harmony';
-    await this.addFolderForNonAspectCorePackages(mainAspectCapsule, distDir, name);
-  }
-
-  private async addFolderForLegacy(mainAspectCapsule: Capsule, distDir: string) {
-    const name = 'legacy';
-    await this.addFolderForNonAspectCorePackages(mainAspectCapsule, distDir, name);
-  }
-}
-
-function generateBarrelFile(packageName) {
-  return `
-Object.defineProperty(exports, "__esModule", { value: true });
-// const aspect = require("${packageName}");
-// module.exports = aspect;
-module.exports.path = require.resolve("${packageName}");
-`;
-}

package/index.ts

@@ -1,3 +0,0 @@
-export type { AspectMain } from './aspect.main.runtime';
-export { AspectAspect, AspectAspect as default } from './aspect.aspect';
-export type { AspectEnv } from './aspect.env';