@teambit/aspect-loader 1.0.227 → 1.0.229

package/dist/aspect-definition.d.ts

@@ -0,0 +1,62 @@
+import { Component } from '@teambit/component';
+export type AspectDefinitionProps = {
+    id?: string;
+    component?: Component;
+    aspectPath: string;
+    runtimePath: string | null;
+    aspectFilePath: string | null;
+    local?: boolean;
+};
+export declare class AspectDefinition {
+    /**
+     * path to the root directory of the aspect module.
+     */
+    readonly aspectPath: string;
+    /**
+     * path to the aspect file (.aspect).
+     */
+    readonly aspectFilePath: string | null;
+    /**
+     * path to the runtime entry
+     */
+    readonly runtimePath: string | null;
+    /**
+     * aspect component
+     */
+    readonly component?: Component | undefined;
+    /**
+     * id of the component (used instead of component in the case of core aspect)
+     */
+    readonly id?: string | undefined;
+    /**
+     * aspect defined using 'file://' protocol
+     */
+    readonly local?: boolean | undefined;
+    constructor(
+    /**
+     * path to the root directory of the aspect module.
+     */
+    aspectPath: string, 
+    /**
+     * path to the aspect file (.aspect).
+     */
+    aspectFilePath: string | null, 
+    /**
+     * path to the runtime entry
+     */
+    runtimePath: string | null, 
+    /**
+     * aspect component
+     */
+    component?: Component | undefined, 
+    /**
+     * id of the component (used instead of component in the case of core aspect)
+     */
+    id?: string | undefined, 
+    /**
+     * aspect defined using 'file://' protocol
+     */
+    local?: boolean | undefined);
+    get getId(): string | null;
+    static from({ component, aspectPath, aspectFilePath, runtimePath, id, local }: AspectDefinitionProps): AspectDefinition;
+}

package/dist/aspect-loader.aspect.d.ts

@@ -0,0 +1,3 @@
+import { Aspect } from '@teambit/harmony';
+export declare const AspectLoaderAspect: Aspect;
+export default AspectLoaderAspect;

package/dist/aspect-loader.composition.d.ts

@@ -0,0 +1 @@
+export declare const Logo: () => import("react/jsx-runtime").JSX.Element;

package/dist/aspect-loader.graphql.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from '@teambit/graphql';
+import { AspectLoaderMain } from './aspect-loader.main.runtime';
+export declare function aspectLoaderSchema(aspectLoaderMain: AspectLoaderMain): Schema;

package/dist/aspect-loader.main.runtime.d.ts

@@ -0,0 +1,208 @@
+import { ComponentID } from '@teambit/component-id';
+import { ExtensionManifest, Harmony, Aspect, SlotRegistry } from '@teambit/harmony';
+import type { LoggerMain } from '@teambit/logger';
+import { Component, FilterAspectsOptions } from '@teambit/component';
+import { Logger } from '@teambit/logger';
+import { RequireableComponent } from '@teambit/harmony.modules.requireable-component';
+import { EnvsMain } from '@teambit/envs';
+import { GraphqlMain } from '@teambit/graphql';
+import { AspectDefinition, AspectDefinitionProps } from './aspect-definition';
+import { PluginDefinition } from './plugin-definition';
+import { Plugins } from './plugins';
+export type PluginDefinitionSlot = SlotRegistry<PluginDefinition[]>;
+export type AspectDescriptor = {
+    /**
+     * name of the extension.
+     */
+    id: string;
+    /**
+     * icon of the extension.
+     */
+    icon?: string;
+};
+export type AspectResolver = (component: Component) => Promise<ResolvedAspect | undefined>;
+export type ResolvedAspect = {
+    aspectPath: string;
+    runtimePath: string | null;
+    aspectFilePath: string | null;
+};
+export type LoadExtByManifestContext = {
+    seeders?: string[];
+    neededFor?: string;
+};
+export type LoadExtByManifestOptions = {
+    throwOnError?: boolean;
+    hideMissingModuleError?: boolean;
+    ignoreErrors?: boolean;
+    /**
+     * If this is enabled then we will show loading error only once for a given extension
+     * (even if it was actually try to load it few times by different components for example)
+     */
+    unifyErrorsByExtId?: boolean;
+};
+type OnAspectLoadError = (err: Error, id: ComponentID) => Promise<boolean>;
+export type OnAspectLoadErrorSlot = SlotRegistry<OnAspectLoadError>;
+export type OnAspectLoadErrorHandler = (err: Error, component: Component) => Promise<boolean>;
+export type OnLoadRequireableExtension = (requireableExtension: RequireableComponent, manifest: ExtensionManifest | Aspect) => Promise<ExtensionManifest | Aspect>;
+/**
+ * A slot which run during loading the requirable extension (after first manifest calculation)
+ */
+export type OnLoadRequireableExtensionSlot = SlotRegistry<OnLoadRequireableExtension>;
+export type MainAspect = {
+    /**
+     * path to the main aspect.
+     */
+    path: string;
+    /**
+     * version of the aspect.
+     */
+    version: string | undefined;
+    /**
+     * package name of the aspect
+     */
+    packageName: string | undefined;
+    /**
+     * reference to aspect manifest.
+     */
+    aspect: Aspect;
+    /**
+     * The name of the aspect (without the scope prefix)
+     */
+    name: string;
+    /**
+     * The name of the aspect
+     */
+    id: string;
+};
+export declare class AspectLoaderMain {
+    private logger;
+    private envs;
+    private harmony;
+    private onAspectLoadErrorSlot;
+    private onLoadRequireableExtensionSlot;
+    private pluginSlot;
+    private inMemoryConfiguredAspects;
+    private failedToLoadExt;
+    private alreadyShownWarning;
+    constructor(logger: Logger, envs: EnvsMain, harmony: Harmony, onAspectLoadErrorSlot: OnAspectLoadErrorSlot, onLoadRequireableExtensionSlot: OnLoadRequireableExtensionSlot, pluginSlot: PluginDefinitionSlot);
+    getCoreAspectsPackagesAndIds(): Record<string, string>;
+    private getCompiler;
+    registerOnAspectLoadErrorSlot(onAspectLoadError: OnAspectLoadError): void;
+    registerOnLoadRequireableExtensionSlot(onLoadRequireableExtension: OnLoadRequireableExtension): void;
+    /**
+     * returns whether the aspect-load issue has been fixed.
+     */
+    triggerOnAspectLoadError(err: Error, component: Component): Promise<boolean>;
+    getRuntimePath(component: Component, modulePath: string, runtime: string): Promise<string | null>;
+    getAspectFilePath(component: Component, modulePath: string): Promise<string | null>;
+    isAspectLoaded(id: string): unknown;
+    getDescriptor(id: string): AspectDescriptor | undefined;
+    /**
+     * This is used when adding aspects to workspace.jsonc during the process (like in bit use command)
+     * and we want to make sure that follow operation (like bit install) will recognize those aspects
+     * but the harmony config is already in memory.
+     * Probably a better to do it is to make sure we can re-load the config somehow
+     * ideally by adding the config class in harmony a reload API
+     * @param aspectId
+     */
+    addInMemoryConfiguredAspect(aspectId: string): void;
+    /**
+     * get all the configured aspects in the config file (workspace.jsonc / bit.jsonc)
+     */
+    getConfiguredAspects(): string[];
+    getNotLoadedConfiguredExtensions(): string[];
+    loadDefinition(props: AspectDefinitionProps): AspectDefinition;
+    private _coreAspects;
+    get coreAspects(): Aspect[];
+    isCoreAspect(id: string): boolean;
+    setCoreAspects(aspects: Aspect[]): this;
+    getCoreAspectIds(): string[];
+    /**
+     * Get all the core envs ids which is still register in the bit manifest as core aspect
+     */
+    getCoreEnvsIds(): string[];
+    isCoreEnv(id: string): boolean;
+    private _reserved;
+    getUserAspects(): string[];
+    getCoreAspectDefs(runtimeName?: string): Promise<AspectDefinition[]>;
+    resolveAspects(components: Component[], resolver: AspectResolver): Promise<AspectDefinition[]>;
+    private _mainAspect;
+    get mainAspect(): MainAspect;
+    setMainAspect(mainAspect: MainAspect): this;
+    private failedLoadAspect;
+    get failedAspects(): string[];
+    resetFailedLoadAspects(): void;
+    private addFailure;
+    cloneManifest(manifest: any): any;
+    /**
+     * run "require" of the component code to get the manifest
+     */
+    doRequire(requireableExtension: RequireableComponent, runSubscribers?: boolean): Promise<ExtensionManifest | Aspect>;
+    /**
+     * in case the extension failed to load, prefer to throw an error, unless `throwOnError` param
+     * passed as `false`.
+     * there are cases when throwing an error blocks the user from doing anything else. for example,
+     * when a user develops an extension and deletes the node-modules, the extension on the workspace
+     * cannot be loaded anymore until "bit compile" is running. however, if this function throws an
+     * error, it'll throw for "bit compile" as well, which blocks the user.
+     * for the CI, it is important to throw an error because errors on console can be ignored.
+     * for now, when loading the extension from the workspace the throwOnError is passed as false.
+     * when loading from the scope (CI) it should be true.
+     *
+     * the console printing here is done directly by "console.error" and not by the logger. the reason
+     * is that the logger.console only prints when the loader started (which, btw, happens after
+     * entering this function, so it can't work) and here we want it to be printed regardless of the
+     * rules of starting the loader. e.g. if by mistake the CI got it as throwOnError=false, it's ok
+     * to break the output by the console.error.
+     *
+     * @todo: this is not the final word however about throwing/non throwing errors here.
+     * in some cases, such as "bit tag", it's better not to tag if an extension changes the model.
+     */
+    loadRequireableExtensions(requireableExtensions: RequireableComponent[], throwOnError?: boolean): Promise<void>;
+    getManifestsFromRequireableExtensions(requireableExtensions: RequireableComponent[], throwOnError?: boolean, runSubscribers?: boolean): Promise<Array<ExtensionManifest | Aspect>>;
+    handleExtensionLoadingError(error: Error, idStr: string, throwOnError: boolean): void;
+    private printWarningIfFirstTime;
+    runOnLoadRequireableExtensionSubscribers(requireableExtension: RequireableComponent, manifest: ExtensionManifest | Aspect): Promise<ExtensionManifest | Aspect>;
+    getPluginDefs(): PluginDefinition[];
+    getPlugins(component: Component, componentPath: string): Plugins;
+    isEsmModule(path: string): Promise<boolean>;
+    loadEsm(path: string): Promise<any>;
+    getPluginsFromDefs(component: Component, componentPath: string, defs: PluginDefinition[]): Plugins;
+    getPluginFiles(component: Component, componentPath: string): string[];
+    hasPluginFiles(component: Component): boolean;
+    pluginFileResolver(component: Component, rootDir: string): (relativePath: string) => string;
+    isAspect(manifest: any): boolean;
+    isValidAspect(manifest: any): boolean;
+    isAspectComponent(component: Component): boolean;
+    /**
+     * get or create a global scope, import the non-core aspects, load bit from that scope, create
+     * capsules for the aspects and load them from the capsules.
+     */
+    loadAspectsFromGlobalScope(aspectIds: string[]): Promise<{
+        components: Component[];
+        globalScopeHarmony: Harmony;
+    }>;
+    filterAspectDefs(allDefs: AspectDefinition[], componentIds: ComponentID[], runtimeName: string | undefined, filterOpts?: FilterAspectsOptions): AspectDefinition[];
+    getAspectIdFromAspectFile(aspectFilePath: string): string | undefined;
+    private prepareManifests;
+    /**
+     * register a plugin.
+     */
+    registerPlugins(pluginDefs: PluginDefinition[]): void;
+    loadExtensionsByManifests(extensionsManifests: Array<ExtensionManifest | Aspect>, context?: LoadExtByManifestContext, options?: LoadExtByManifestOptions): Promise<void>;
+    private generateManifestGraph;
+    loadAspectFromPath(localAspects: string[]): Promise<void>;
+    private parseLocalAspect;
+    private findRuntime;
+    resolveLocalAspects(ids: string[], runtime?: string): Promise<AspectDefinition[]>;
+    private findAspectFile;
+    static runtime: import("@teambit/harmony").RuntimeDefinition;
+    static dependencies: Aspect[];
+    static slots: (((registerFn: () => string) => SlotRegistry<OnAspectLoadError>) | ((registerFn: () => string) => SlotRegistry<OnLoadRequireableExtension>) | ((registerFn: () => string) => SlotRegistry<PluginDefinition[]>))[];
+    static provider([loggerExt, envs, graphql]: [LoggerMain, EnvsMain, GraphqlMain], config: any, [onAspectLoadErrorSlot, onLoadRequireableExtensionSlot, pluginSlot]: [
+        OnAspectLoadErrorSlot,
+        OnLoadRequireableExtensionSlot,
+        PluginDefinitionSlot
+    ], harmony: Harmony): Promise<AspectLoaderMain>;
+}
+export default AspectLoaderMain;

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const UNABLE_TO_LOAD_EXTENSION: (id: string, errMsg?: string) => string;
+export declare const UNABLE_TO_LOAD_EXTENSION_FROM_LIST: (ids: string[], errMsg?: string, neededFor?: string) => string;

package/dist/core-aspects.d.ts

@@ -0,0 +1,17 @@
+export declare function getBvmDir(): string;
+export declare function getAspectDir(id: string): string;
+type BvmDirOptions = {
+    version?: string;
+    linkName?: string;
+};
+export declare function getAspectDirFromBvm(id: string, bvmDirOptions?: BvmDirOptions): string;
+export declare function getAspectDistDir(id: string): string;
+export declare function getCoreAspectName(id: string): string;
+export declare function getCoreAspectPackageName(id: string): string;
+export declare function getAspectDef(aspectName: string, runtime?: string): Promise<{
+    id: string;
+    aspectPath: string;
+    aspectFilePath: string | null;
+    runtimePath: string | null;
+}>;
+export {};

package/dist/core-aspects.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/exceptions/cannot-load-extension.d.ts

@@ -0,0 +1,8 @@
+import { BitError } from '@teambit/bit-error';
+export declare class CannotLoadExtension extends BitError {
+    private extensionName;
+    private error;
+    constructor(extensionName: string, error: Error);
+    report(verbose?: boolean): string;
+    toJson(): void;
+}

package/dist/exceptions/index.d.ts

@@ -0,0 +1 @@
+export { CannotLoadExtension } from './cannot-load-extension';

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { AspectLoaderAspect } from './aspect-loader.aspect';
+export type { AspectLoaderMain, AspectDescriptor, MainAspect, OnLoadRequireableExtension, AspectResolver, ResolvedAspect, } from './aspect-loader.main.runtime';
+export { getAspectDef, getAspectDir, getAspectDistDir, getCoreAspectPackageName, getCoreAspectName, getAspectDirFromBvm, } from './core-aspects';
+export type { PluginDefinition } from './plugin-definition';
+export { AspectDefinition } from './aspect-definition';
+export { UNABLE_TO_LOAD_EXTENSION } from './constants';
+export { AspectLoaderAspect };
+export default AspectLoaderAspect;

package/dist/is-esm-module.d.ts

@@ -0,0 +1 @@
+export declare function isEsmModule(path: string): boolean;

package/dist/plugin-definition.d.ts

@@ -0,0 +1,20 @@
+import { Aspect } from '@teambit/harmony';
+export interface PluginDefinition {
+    /**
+     * regex pattern for detecting the definition file within a component.
+     */
+    pattern: string | RegExp;
+    /**
+     * runtimes for the plugin to apply.
+     */
+    runtimes: string[];
+    /**
+     * register the plugin to its slot registry.
+     */
+    /**
+     * Plugin implementation.
+     * @param object The object that was exported as default by the *.plugin-pattern file.
+     * @param sourceAspect Pointer to the aspect that is using the plugin (the aspect that contain the *.plugin-pattern file).
+     */
+    register<T>(object: T, sourceAspect: Aspect): void;
+}

package/dist/plugin.d.ts

@@ -0,0 +1,14 @@
+import { Aspect } from '@teambit/harmony';
+import { PluginDefinition } from './plugin-definition';
+export declare class Plugin {
+    readonly def: PluginDefinition;
+    readonly path: string;
+    constructor(def: PluginDefinition, path: string);
+    private _instance;
+    /**
+     * determines whether the plugin supports a certain runtime.
+     */
+    supportsRuntime(runtime: string): boolean;
+    register(sourceAspect: Aspect, module?: unknown): void;
+    require(): unknown;
+}

package/dist/plugins.d.ts

@@ -0,0 +1,26 @@
+import { Component } from '@teambit/component';
+import { Logger } from '@teambit/logger';
+import { Aspect } from '@teambit/harmony';
+import { PluginDefinition } from './plugin-definition';
+import { Plugin } from './plugin';
+import { OnAspectLoadErrorHandler } from './aspect-loader.main.runtime';
+export type PluginMap = {
+    [filePath: string]: PluginDefinition;
+};
+export declare class Plugins {
+    readonly component: Component;
+    readonly plugins: Plugin[];
+    private triggerOnAspectLoadError;
+    private logger;
+    constructor(component: Component, plugins: Plugin[], triggerOnAspectLoadError: OnAspectLoadErrorHandler, logger: Logger);
+    getByRuntime(runtime: string): Plugin[];
+    load(runtime: string): Promise<Aspect>;
+    loadModule(path: string): Promise<any>;
+    registerPluginWithTryCatch(plugin: Plugin, aspect: Aspect): Promise<void>;
+    has(): boolean;
+    static from(component: Component, defs: PluginDefinition[], triggerOnAspectLoadError: OnAspectLoadErrorHandler, logger: Logger, resolvePath?: (path: string) => string): Plugins;
+    /**
+     * Get the plugin files from the component.
+     */
+    static files(component: Component, defs: PluginDefinition[], resolvePath?: (path: string) => string): string[];
+}

package/dist/{preview-1712719054377.js → preview-1712822929999.js}

@@ -1,5 +1,5 @@
-import * as compositions_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.harmony_aspect-loader@1.0.227/dist/aspect-loader.composition.js';
-import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.harmony_aspect-loader@1.0.227/dist/aspect-loader.docs.mdx';
+import * as compositions_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.harmony_aspect-loader@1.0.229/dist/aspect-loader.composition.js';
+import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.harmony_aspect-loader@1.0.229/dist/aspect-loader.docs.mdx';
 
 export const compositions = [compositions_0];
 export const overview = [overview_0];

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/aspect-loader",
-  "version": "1.0.227",
+  "version": "1.0.229",
   "homepage": "https://bit.cloud/teambit/harmony/aspect-loader",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.harmony",
     "name": "aspect-loader",
-    "version": "1.0.227"
+    "version": "1.0.229"
   },
   "dependencies": {
     "graphql-tag": "2.12.1",
@@ -22,15 +22,15 @@
     "@teambit/node.utils.esm-loader": "0.0.6",
     "@teambit/bvm.config": "0.2.5",
     "@teambit/bvm.path": "0.1.2",
-    "@teambit/component": "1.0.227",
-    "@teambit/graphql": "1.0.227",
-    "@teambit/bit": "1.6.120",
-    "@teambit/cli": "0.0.860",
+    "@teambit/component": "1.0.229",
+    "@teambit/graphql": "1.0.229",
+    "@teambit/bit": "1.6.122",
+    "@teambit/cli": "0.0.862",
     "@teambit/compilation.modules.babel-compiler": "0.0.139",
-    "@teambit/envs": "1.0.227",
+    "@teambit/envs": "1.0.229",
     "@teambit/harmony.modules.requireable-component": "0.0.497",
-    "@teambit/logger": "0.0.953",
-    "@teambit/scope": "1.0.227",
+    "@teambit/logger": "0.0.955",
+    "@teambit/scope": "1.0.229",
     "@teambit/toolbox.performance.v8-cache": "0.0.33"
   },
   "devDependencies": {
@@ -40,7 +40,7 @@
     "chai": "4.3.0",
     "@types/find-root": "1.1.2",
     "@types/mocha": "9.1.0",
-    "@teambit/harmony.envs.core-aspect-env": "0.0.30"
+    "@teambit/harmony.envs.core-aspect-env": "0.0.33"
   },
   "peerDependencies": {
     "react": "^17.0.0 || ^18.0.0",

package/tsconfig.json

@@ -20,8 +20,7 @@
     "emitDeclarationOnly": true,
     "strict": true,
     "strictPropertyInitialization": false,
-    "noImplicitAny": false,
-    "composite": true
+    "noImplicitAny": false
   },
   "exclude": [
     "artifacts",
@@ -36,28 +35,5 @@
   "include": [
     "**/*",
     "**/*.json"
-  ],
-  "references": [
-    {
-      "path": "/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.component_component@1.0.227"
-    },
-    {
-      "path": "/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.harmony_graphql@1.0.227"
-    },
-    {
-      "path": "/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.harmony_bit@1.6.120"
-    },
-    {
-      "path": "/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.harmony_cli@0.0.860"
-    },
-    {
-      "path": "/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.envs_envs@1.0.227"
-    },
-    {
-      "path": "/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.harmony_logger@0.0.953"
-    },
-    {
-      "path": "/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.scope_scope@1.0.227"
-    }
   ]
 }