@teambit/preview 1.0.227 → 1.0.229

package/dist/preview.main.runtime.d.ts

@@ -0,0 +1,343 @@
+import type { BuilderMain } from '@teambit/builder';
+import { Asset, BundlerMain } from '@teambit/bundler';
+import { PubsubMain } from '@teambit/pubsub';
+import { Component, ComponentMain, ComponentMap, ComponentID, ResolveAspectsOptions } from '@teambit/component';
+import type { EnvsMain, PreviewEnv } from '@teambit/envs';
+import { SlotRegistry, Harmony } from '@teambit/harmony';
+import { UiMain, UIRoot } from '@teambit/ui';
+import { CacheMain } from '@teambit/cache';
+import { PkgMain } from '@teambit/pkg';
+import type { AspectDefinition, AspectLoaderMain } from '@teambit/aspect-loader';
+import { Workspace } from '@teambit/workspace';
+import { LoggerMain, Logger } from '@teambit/logger';
+import type { DependencyResolverMain } from '@teambit/dependency-resolver';
+import { WatcherMain } from '@teambit/watcher';
+import { GraphqlMain } from '@teambit/graphql';
+import { ScopeMain } from '@teambit/scope';
+import { MainModulesMap } from './generate-link';
+import { PreviewArtifact } from './preview-artifact';
+import { PreviewDefinition } from './preview-definition';
+import { BundlingStrategy } from './bundling-strategy';
+export type PreviewDefinitionRegistry = SlotRegistry<PreviewDefinition>;
+export type PreviewStrategyName = 'env' | 'component';
+export type PreviewFiles = {
+    files: string[];
+    isBundledWithEnv: boolean;
+};
+export type ComponentPreviewSizedFile = Asset;
+export type ComponentPreviewSize = {
+    files: ComponentPreviewSizedFile[];
+    assets: ComponentPreviewSizedFile[];
+    totalFiles: number;
+    compressedTotalFiles?: number;
+    totalAssets: number;
+    compressedTotalAssets?: number;
+    total: number;
+    compressedTotal?: number;
+};
+export type ComponentPreviewMetaData = {
+    size?: ComponentPreviewSize;
+};
+export type PreviewVariantConfig = {
+    isScaling?: boolean;
+};
+/**
+ * Preview data that stored on the component on load
+ */
+export type PreviewComponentData = PreviewAnyComponentData & PreviewEnvComponentData;
+/**
+ * Preview data that stored on the component on load for any component
+ */
+export type PreviewAnyComponentData = {
+    doesScaling?: boolean;
+    /**
+     * The strategy configured by the component's env
+     */
+    strategyName?: PreviewStrategyName;
+    /**
+     * Does the component has a bundle for the component itself (separated from the compositions/docs)
+     * Calculated by the component's env
+     */
+    splitComponentBundle?: boolean;
+    /**
+     * don't allow other aspects implementing a preview definition to be included in your preview.
+     */
+    onlyOverview?: boolean;
+    /**
+     * use name query params to select a specific composition to render.
+     */
+    useNameParam?: boolean;
+    /**
+     * don't allow other aspects implementing a preview definition to be included in your preview.
+     */
+    skipIncludes?: boolean;
+};
+/**
+ * Preview data that stored on the component on load if the component is an env
+ */
+export type PreviewEnvComponentData = {
+    isScaling?: boolean;
+    supportsOnlyOverview?: boolean;
+    supportsUseNameParam?: boolean;
+};
+export type PreviewConfig = {
+    bundlingStrategy?: string;
+    disabled: boolean;
+    /**
+     * limit concurrent components when running the bundling step for your bundler during generate components preview task.
+     * this helps mitigate large memory consumption for the build pipeline. This may increase the overall time for the generate-preview task, but reduce memory footprint.
+     * default - no limit.
+     */
+    maxChunkSize?: number;
+    onlyOverview?: boolean;
+};
+export type EnvPreviewConfig = {
+    strategyName?: PreviewStrategyName;
+    splitComponentBundle?: boolean;
+};
+export type BundlingStrategySlot = SlotRegistry<BundlingStrategy>;
+export type GenerateLinkFn = (prefix: string, componentMap: ComponentMap<string[]>, defaultModule?: string) => string;
+export declare class PreviewMain {
+    /**
+     * harmony context.
+     */
+    private harmony;
+    /**
+     * slot for preview definitions.
+     */
+    private previewSlot;
+    private ui;
+    private cache;
+    private envs;
+    private componentAspect;
+    private pkg;
+    private aspectLoader;
+    readonly config: PreviewConfig;
+    private bundlingStrategySlot;
+    private builder;
+    private workspace;
+    private logger;
+    private dependencyResolver;
+    constructor(
+    /**
+     * harmony context.
+     */
+    harmony: Harmony, 
+    /**
+     * slot for preview definitions.
+     */
+    previewSlot: PreviewDefinitionRegistry, ui: UiMain, cache: CacheMain, envs: EnvsMain, componentAspect: ComponentMain, pkg: PkgMain, aspectLoader: AspectLoaderMain, config: PreviewConfig, bundlingStrategySlot: BundlingStrategySlot, builder: BuilderMain, workspace: Workspace | undefined, logger: Logger, dependencyResolver: DependencyResolverMain);
+    get tempFolder(): string;
+    getComponentBundleSize(component: Component): ComponentPreviewSize | undefined;
+    getPreview(component: Component): Promise<PreviewArtifact | undefined>;
+    /**
+     * Get a list of all the artifact files generated during the GeneratePreview task
+     * @param component
+     * @returns
+     */
+    getPreviewFiles(component: Component): Promise<PreviewFiles | undefined>;
+    /**
+     * Get the preview config of the component.
+     * (config that was set by variants or on bitmap)
+     * @param component
+     * @returns
+     */
+    getPreviewAspectConfig(component: Component): PreviewVariantConfig | undefined;
+    /**
+     * Get the preview data of the component.
+     * (data that was calculated during the on load process)
+     * @param component
+     * @returns
+     */
+    getPreviewData(component: Component): PreviewComponentData | undefined;
+    /**
+     * check if the current version of env component supports skipping other included previews
+     * @param envComponent
+     * @returns
+     */
+    doesEnvIncludesOnlyOverview(envComponent: Component): boolean;
+    /**
+     * check if the current version of env component supports name query param
+     * @param envComponent
+     * @returns
+     */
+    doesEnvUseNameParam(envComponent: Component): boolean;
+    private calculateIncludeOnlyOverview;
+    private calculateUseNameParam;
+    /**
+     * Calculate preview data on component load
+     * @param component
+     * @returns
+     */
+    calcPreviewData(component: Component): Promise<PreviewComponentData>;
+    /**
+     * Calculate preview data on component that configured by its env
+     * @param component
+     * @returns
+     */
+    calcPreviewDataFromEnv(component: Component): Promise<Omit<PreviewAnyComponentData, 'doesScaling' | 'onlyOverview' | 'useNameParam'> | undefined>;
+    /**
+     * calculate extra preview data for env components (on load)
+     * @param envComponent
+     * @returns
+     */
+    private calculateDataForEnvComponent;
+    /**
+     * Check if the component preview bundle contain the env as part of the bundle or only the component code
+     * (we used in the past to bundle them together, there might also be specific envs which still uses the env strategy)
+     * This should be used only for calculating the value on load.
+     * otherwise, use the isBundledWithEnv function
+     * @param component
+     * @returns
+     */
+    calcIsBundledWithEnv(component: Component): Promise<boolean>;
+    /**
+     * Check if the component preview bundle contain the env as part of the bundle or only the component code
+     * (we used in the past to bundle them together, there might also be specific envs which still uses the env strategy)
+     * @param component
+     * @returns
+     */
+    isBundledWithEnv(component: Component): Promise<boolean>;
+    /**
+     * This is a legacy calculation for the isBundledWithEnv
+     * This calc is based on the component artifacts which is very expensive operation as it requires to fetch and load the artifacts
+     * See the new implementation in the isBundledWithEnv method
+     * @param component
+     * @returns
+     */
+    private isBundledWithEnvBackward;
+    private calcDoesScalingForComponent;
+    /**
+     * can the current component preview scale in size for different preview sizes.
+     * this calculation is based on the env of the component and if the env of the component support it.
+     */
+    doesScaling(component: Component): Promise<boolean>;
+    /**
+     * Check if the current version of the env support scaling
+     * @param envComponent
+     * @returns
+     */
+    isEnvSupportScaling(envComponent: Component): boolean;
+    isSupportSkipIncludes(component: Component): Promise<boolean>;
+    /**
+     * check if the component preview should only include the overview (skipping rendering of the compostions and properties table)
+     */
+    getOnlyOverview(component: Component): Promise<boolean>;
+    /**
+     * check if the component preview should include the name query param
+     */
+    getUseNameParam(component: Component): Promise<boolean>;
+    /**
+     * This function is calculate the isScaling support flag for the component preview.
+     * This is calculated only for the env component and not for the component itself.
+     * It should be only used during the (env) component on load.
+     * Once the component load, you should only use the `isEnvSupportScaling` to fetch it from the calculated data.
+     * If you want to check if an env for a given component support scaling, use the `isScaling` function.
+     * @param component
+     * @returns
+     */
+    private calculateIsEnvSupportScaling;
+    /**
+     * Check if the component preview bundle contain the header inside of it (legacy)
+     * today we are not including the header inside anymore
+     * @param component
+     * @returns
+     */
+    isLegacyHeader(component: Component): Promise<boolean>;
+    /**
+     * Getting the env template artifact
+     * This should be called with the env itself or it will return undefined
+     * If you want to get the env template from the env of the component,
+     * use: getEnvTemplateFromComponentEnv below
+     *
+     * @param component
+     * @returns
+     */
+    getEnvTemplate(component: Component): Promise<PreviewArtifact | undefined>;
+    /**
+     * This is a special method to get a core env template
+     * As the core envs doesn't exist in the scope we need to bring it from other place
+     * We will bring it from the core env package files
+     */
+    private getCoreEnvTemplate;
+    /**
+     * This will fetch the component env, then will take the env template from the component env
+     * @param component
+     */
+    getEnvTemplateFromComponentEnv(component: Component): Promise<PreviewArtifact | undefined>;
+    /**
+     * This will fetch the component env, then will take the env template from the component env
+     * @param component
+     */
+    getEnvTemplateByEnvId(envId: string): Promise<PreviewArtifact | undefined>;
+    getDefs(): PreviewDefinition[];
+    private writeHash;
+    private timestamp;
+    /**
+     * write a link to load custom modules dynamically.
+     * @param prefix write
+     * @param moduleMap map of components to module paths to require.
+     * @param defaultModule
+     * @param dirName
+     */
+    writeLink(prefix: string, moduleMap: ComponentMap<string[]>, mainModulesMap: MainModulesMap, dirName: string, isSplitComponentBundle: boolean): string;
+    writeLinkContents(contents: string, targetDir: string, prefix: string): string;
+    private executionRefs;
+    private getPreviewTarget;
+    private writePreviewEntry;
+    private updateLinkFiles;
+    writePreviewRuntime(context: {
+        components: Component[];
+    }, aspectsIdsToNotFilterOut?: string[]): Promise<string>;
+    resolveAspects(runtimeName?: string, componentIds?: ComponentID[], uiRoot?: UIRoot, opts?: ResolveAspectsOptions): Promise<AspectDefinition[]>;
+    private getUi;
+    /**
+     * Filter the aspects to have only aspects that are:
+     * 1. core aspects
+     * 2. configured on the host (workspace/scope)
+     * 3. used by at least one component from the context
+     * @param aspects
+     * @param context
+     */
+    private filterAspectsByExecutionContext;
+    private getDefaultStrategies;
+    private handleComponentChange;
+    private handleComponentRemoval;
+    getEnvPreviewConfig(env?: PreviewEnv): EnvPreviewConfig;
+    /**
+     * return the configured bundling strategy.
+     */
+    getBundlingStrategy(env?: PreviewEnv): BundlingStrategy;
+    /**
+     * register a new bundling strategy. default available strategies are `env` and ``
+     */
+    registerBundlingStrategy(bundlingStrategy: BundlingStrategy): this;
+    /**
+     * register a new preview definition.
+     */
+    registerDefinition(previewDef: PreviewDefinition): void;
+    static slots: (((registerFn: () => string) => SlotRegistry<PreviewDefinition>) | ((registerFn: () => string) => SlotRegistry<BundlingStrategy>))[];
+    static runtime: import("@teambit/harmony").RuntimeDefinition;
+    static dependencies: import("@teambit/harmony").Aspect[];
+    static defaultConfig: {
+        disabled: boolean;
+        onlyOverview: boolean;
+    };
+    static provider([bundler, builder, componentExtension, uiMain, cache, envs, workspace, pkg, pubsub, aspectLoader, loggerMain, dependencyResolver, graphql, watcher, scope,]: [
+        BundlerMain,
+        BuilderMain,
+        ComponentMain,
+        UiMain,
+        CacheMain,
+        EnvsMain,
+        Workspace | undefined,
+        PkgMain,
+        PubsubMain,
+        AspectLoaderMain,
+        LoggerMain,
+        DependencyResolverMain,
+        GraphqlMain,
+        WatcherMain,
+        ScopeMain
+    ], config: PreviewConfig, [previewSlot, bundlingStrategySlot]: [PreviewDefinitionRegistry, BundlingStrategySlot], harmony: Harmony): Promise<PreviewMain>;
+}

package/dist/preview.preview.runtime.d.ts

@@ -0,0 +1,77 @@
+import { PubsubPreview } from '@teambit/pubsub';
+import { SlotRegistry } from '@teambit/harmony';
+import { ComponentID } from '@teambit/component-id';
+import { PreviewType } from './preview-type';
+import { ModuleFile, PreviewModule } from './types/preview-module';
+import { RenderingContext } from './rendering-context';
+export { linkModules } from './preview-modules';
+export type PreviewSlot = SlotRegistry<PreviewType>;
+export type RenderingContextOptions = {
+    aspectsFilter?: string[];
+};
+export type RenderingContextProvider = (options: RenderingContextOptions) => {
+    [key: string]: any;
+};
+export type RenderingContextSlot = SlotRegistry<RenderingContextProvider>;
+export declare class PreviewPreview {
+    /**
+     * register to pubsub
+     */
+    private pubsub;
+    /**
+     * preview slot.
+     */
+    private previewSlot;
+    private renderingContextSlot;
+    constructor(
+    /**
+     * register to pubsub
+     */
+    pubsub: PubsubPreview, 
+    /**
+     * preview slot.
+     */
+    previewSlot: PreviewSlot, renderingContextSlot: RenderingContextSlot);
+    private registerClickPubSub;
+    private isDev;
+    private isReady;
+    private _setupPromise?;
+    setup: () => Promise<void>;
+    /**
+     * render the preview.
+     */
+    render: (rootExt?: string) => Promise<void>;
+    setFullScreen(): void;
+    setViewport(): void;
+    reportSize(): void;
+    getPreviewModule(previewName: string, id: ComponentID): Promise<PreviewModule>;
+    fetchComponentPreview(id: ComponentID, name: string): Promise<Record<string, ModuleFile[]>>;
+    private addComponentFileElement;
+    private fetchComponentPreviewFiles;
+    private addComponentFileScriptElement;
+    private addComponentFileLinkElement;
+    private loadPreviewScript;
+    private getComponentAspects;
+    /**
+     * register a new preview.
+     */
+    registerPreview(preview: PreviewType): this;
+    /**
+     * get the preview rendering context.
+     */
+    getRenderingContext(aspectsFilter?: string[]): RenderingContext;
+    /**
+     * allows aspects to add rendering contexts.
+     * render context is available through all preview definitions.
+     */
+    registerRenderContext(renderContext: RenderingContextProvider): this;
+    getDefault(): string;
+    private getPreview;
+    getParam(query: string, param: string): string | null;
+    getQuery(): string;
+    private getLocation;
+    static runtime: import("@teambit/harmony").RuntimeDefinition;
+    static dependencies: import("@teambit/harmony").Aspect[];
+    static slots: (((registerFn: () => string) => SlotRegistry<PreviewType>) | ((registerFn: () => string) => SlotRegistry<RenderingContextProvider>))[];
+    static provider([pubsub]: [PubsubPreview], config: any, [previewSlot, renderingContextSlot]: [PreviewSlot, RenderingContextSlot]): Promise<PreviewPreview>;
+}

package/dist/preview.route.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="express" />
+import type { NextFunction, Request, Response, Route } from '@teambit/express';
+import type { Logger } from '@teambit/logger';
+import { PreviewMain } from './preview.main.runtime';
+import type { PreviewUrlParams } from './artifact-file-middleware';
+export declare class PreviewRoute implements Route {
+    /**
+     * preview extension.
+     */
+    private preview;
+    private logger;
+    constructor(
+    /**
+     * preview extension.
+     */
+    preview: PreviewMain, logger: Logger);
+    route: string;
+    method: string;
+    middlewares: (import("@teambit/express").Middleware | ((req: Request<PreviewUrlParams>, res: Response, next: NextFunction) => Promise<void | import("express").Response<any, Record<string, any>>>))[];
+}

package/dist/preview.service.d.ts

@@ -0,0 +1,29 @@
+import { EnvService, Env, EnvContext, ServiceTransformationMap } from '@teambit/envs';
+import { EnvPreviewConfig } from './preview.main.runtime';
+type PreviewTransformationMap = ServiceTransformationMap & {
+    /**
+     * Returns a paths to a function which mounts a given component to DOM
+     * Required for `bit start` & `bit build`
+     */
+    getMounter?: () => string;
+    /**
+     * Returns a path to a docs template.
+     * Required for `bit start` & `bit build`
+     */
+    getDocsTemplate?: () => string;
+    /**
+     * Returns a list of additional host dependencies
+     * this list will be provided as globals on the window after bit preview bundle
+     * by default bit will merge this list with the peers from the getDependencies function
+     */
+    getAdditionalHostDependencies?: () => string[] | Promise<string[]>;
+    /**
+     * Returns preview config like the strategy name to use when bundling the components for the preview
+     */
+    getPreviewConfig?: () => EnvPreviewConfig;
+};
+export declare class PreviewService implements EnvService<any> {
+    name: string;
+    transform(env: Env, envContext: EnvContext): PreviewTransformationMap | undefined;
+}
+export {};

package/dist/preview.start-plugin.d.ts

@@ -0,0 +1,35 @@
+import { BundlerMain, ComponentServer } from '@teambit/bundler';
+import { PubsubMain } from '@teambit/pubsub';
+import { ProxyEntry, StartPlugin, StartPluginOptions, UiMain } from '@teambit/ui';
+import { Workspace } from '@teambit/workspace';
+import { Logger } from '@teambit/logger';
+import { WatcherMain } from '@teambit/watcher';
+type ServerState = {
+    isCompiling?: boolean;
+    isReady?: boolean;
+    errors?: Error[];
+    warnings?: Error[];
+    results?: any[];
+};
+type ServerStateMap = Record<string, ServerState>;
+export declare class PreviewStartPlugin implements StartPlugin {
+    private workspace;
+    private bundler;
+    private ui;
+    private pubsub;
+    private logger;
+    private watcher;
+    constructor(workspace: Workspace, bundler: BundlerMain, ui: UiMain, pubsub: PubsubMain, logger: Logger, watcher: WatcherMain);
+    previewServers: ComponentServer[];
+    serversState: ServerStateMap;
+    serversMap: Record<string, ComponentServer>;
+    initiate(options: StartPluginOptions): Promise<void>;
+    getProxy(): ProxyEntry[];
+    private listenToDevServers;
+    private handleOnStartCompiling;
+    private handleOnDoneCompiling;
+    private setReady;
+    private readyPromise;
+    get whenReady(): Promise<void>;
+}
+export {};

package/dist/preview.task.d.ts

@@ -0,0 +1,39 @@
+import { ExecutionContext } from '@teambit/envs';
+import { BuildContext, BuiltTaskResult, BuildTask, TaskLocation } from '@teambit/builder';
+import { BundlerMain } from '@teambit/bundler';
+import { ComponentMap } from '@teambit/component';
+import { Capsule } from '@teambit/isolator';
+import { AbstractVinyl } from '@teambit/legacy/dist/consumer/component/sources';
+import { DependencyResolverMain } from '@teambit/dependency-resolver';
+import { Logger } from '@teambit/logger';
+import { PreviewMain } from './preview.main.runtime';
+export declare const PREVIEW_TASK_NAME = "GeneratePreview";
+export declare class PreviewTask implements BuildTask {
+    /**
+     * bundler extension.
+     */
+    private bundler;
+    /**
+     * preview extension.
+     */
+    private preview;
+    private dependencyResolver;
+    private logger;
+    constructor(
+    /**
+     * bundler extension.
+     */
+    bundler: BundlerMain, 
+    /**
+     * preview extension.
+     */
+    preview: PreviewMain, dependencyResolver: DependencyResolverMain, logger: Logger);
+    aspectId: string;
+    name: string;
+    description: string;
+    location: TaskLocation;
+    execute(context: BuildContext): Promise<BuiltTaskResult>;
+    getLinkFileDirectory(): string;
+    getPreviewDirectory(context: ExecutionContext): string;
+    getPathsFromMap(capsule: Capsule, moduleMap: ComponentMap<AbstractVinyl[]>, context: BuildContext): ComponentMap<string[]>;
+}

package/dist/rendering-context.d.ts

@@ -0,0 +1,18 @@
+import { RenderingContextSlot } from './preview.preview.runtime';
+export type RenderingContextOptions = {
+    aspectsFilter?: string[];
+};
+export type RenderingContextProvider = (options: RenderingContextOptions) => {
+    [key: string]: any;
+};
+export declare class RenderingContext {
+    private contexts;
+    private options;
+    constructor(contexts: RenderingContextSlot, options?: RenderingContextOptions);
+    /**
+     * obtain rendering context of a specific aspect.
+     */
+    get(aspectId: string): {
+        [key: string]: any;
+    } | undefined;
+}

package/dist/size-event.d.ts

@@ -0,0 +1,9 @@
+import { BitBaseEvent } from '@teambit/pubsub';
+export type SizeEventType = {
+    height: number;
+    width: number;
+};
+export declare class SizeEvent extends BitBaseEvent<SizeEventType> {
+    static readonly TYPE = "preview-size";
+    constructor(sizeEvent: SizeEventType);
+}

package/dist/strategies/component-strategy.d.ts

@@ -0,0 +1,54 @@
+import { Component } from '@teambit/component';
+import { ComponentResult } from '@teambit/builder';
+import type { PkgMain } from '@teambit/pkg';
+import type { DependencyResolverMain } from '@teambit/dependency-resolver';
+import type { BundlerResult, BundlerContext, Target } from '@teambit/bundler';
+import { BundlingStrategy, ComputeTargetsContext } from '../bundling-strategy';
+import type { PreviewDefinition } from '../preview-definition';
+import type { PreviewMain } from '../preview.main.runtime';
+export declare const PREVIEW_CHUNK_SUFFIX = "preview";
+export declare const COMPONENT_CHUNK_SUFFIX = "component";
+export declare const PREVIEW_CHUNK_FILENAME_SUFFIX = "preview.js";
+export declare const COMPONENT_CHUNK_FILENAME_SUFFIX = "component.js";
+export declare const COMPONENT_STRATEGY_SIZE_KEY_NAME = "size";
+export declare const COMPONENT_STRATEGY_ARTIFACT_NAME = "preview-component";
+type ComponentEntry = {
+    component: Component;
+    entries: Object;
+};
+/**
+ * bundles all components in a given env into the same bundle.
+ */
+export declare class ComponentBundlingStrategy implements BundlingStrategy {
+    private preview;
+    private pkg;
+    private dependencyResolver;
+    name: string;
+    constructor(preview: PreviewMain, pkg: PkgMain, dependencyResolver: DependencyResolverMain);
+    computeTargets(context: ComputeTargetsContext, previewDefs: PreviewDefinition[]): Promise<Target[]>;
+    computeComponentEntry(previewDefs: PreviewDefinition[], component: Component, context: ComputeTargetsContext): Promise<ComponentEntry>;
+    private getComponentChunkId;
+    private getComponentChunkFileName;
+    private getAssetAbsolutePath;
+    private getAssetFilename;
+    copyAssetsToCapsules(context: BundlerContext, result: BundlerResult): void;
+    private findAssetsForComponent;
+    private getArtifactDirectory;
+    private computeComponentMetadata;
+    computeResults(context: BundlerContext, results: BundlerResult[]): Promise<{
+        componentsResults: ComponentResult[];
+        artifacts: {
+            name: string;
+            globPatterns: string[];
+            rootDir: string;
+        }[];
+    }>;
+    computeTargetResult(context: BundlerContext, result: BundlerResult): Promise<ComponentResult[]>;
+    private getArtifactDef;
+    getDirName(context: ComputeTargetsContext): string;
+    private getOutputPath;
+    private getPaths;
+    private getComponentOutputPath;
+    private computePaths;
+}
+export {};

package/dist/strategies/env-strategy.d.ts

@@ -0,0 +1,41 @@
+import { ComponentResult } from '@teambit/builder';
+import { BundlerContext, BundlerHtmlConfig, BundlerResult } from '@teambit/bundler';
+import { DependencyResolverMain } from '@teambit/dependency-resolver';
+import { PkgMain } from '@teambit/pkg';
+import type { BundlingStrategy, ComputeTargetsContext } from '../bundling-strategy';
+import { PreviewDefinition } from '../preview-definition';
+import { PreviewMain } from '../preview.main.runtime';
+export declare const ENV_STRATEGY_ARTIFACT_NAME = "preview";
+/**
+ * bundles all components in a given env into the same bundle.
+ */
+export declare class EnvBundlingStrategy implements BundlingStrategy {
+    private preview;
+    private pkg;
+    private dependencyResolver;
+    name: string;
+    constructor(preview: PreviewMain, pkg: PkgMain, dependencyResolver: DependencyResolverMain);
+    computeTargets(context: ComputeTargetsContext, previewDefs: PreviewDefinition[]): Promise<{
+        entries: string[];
+        html: BundlerHtmlConfig[];
+        components: import("@teambit/component").Component[];
+        outputPath: string;
+        hostDependencies: string[];
+        aliasHostDependencies: boolean;
+    }[]>;
+    private generateHtmlConfig;
+    computeResults(context: BundlerContext, results: BundlerResult[]): Promise<{
+        componentsResults: ComponentResult[];
+        artifacts: {
+            name: string;
+            globPatterns: string[];
+            rootDir: string;
+            context: "env";
+        }[];
+    }>;
+    private getArtifactDef;
+    getDirName(context: ComputeTargetsContext): string;
+    private getOutputPath;
+    private getPaths;
+    private computePaths;
+}

package/dist/strategies/generate-component-link.d.ts

@@ -0,0 +1,6 @@
+export type ModuleVar = {
+    prefix: string;
+    paths: string[];
+    metadata?: unknown;
+};
+export declare function generateComponentLink(modules: ModuleVar[]): string;