@teambit/application 1.0.228 → 1.0.229

package/dist/app-build-context.d.ts

@@ -0,0 +1,26 @@
+import { Component } from '@teambit/component';
+import { Capsule, Network } from '@teambit/isolator';
+import { BuildContext, PipeName, TaskResults } from '@teambit/builder';
+import { LaneId } from '@teambit/lane-id';
+import { AppContext } from './app-context';
+export type AppBuildContextCreate = {
+    appContext: AppContext;
+    buildContext: BuildContext;
+    name: string;
+    appComponent: Component;
+    artifactsDir: string;
+    capsule: Capsule;
+};
+export declare class AppBuildContext extends AppContext implements BuildContext {
+    readonly appContext: AppContext;
+    readonly capsuleNetwork: Network;
+    readonly previousTasksResults: TaskResults[];
+    readonly pipeName: PipeName;
+    readonly capsule: Capsule;
+    readonly name: string;
+    readonly appComponent: Component;
+    readonly artifactsDir: string;
+    readonly laneId?: LaneId | undefined;
+    constructor(appContext: AppContext, capsuleNetwork: Network, previousTasksResults: TaskResults[], pipeName: PipeName, capsule: Capsule, name: string, appComponent: Component, artifactsDir: string, laneId?: LaneId | undefined);
+    static create({ name, capsule, appComponent, artifactsDir, appContext, buildContext }: AppBuildContextCreate): AppBuildContext;
+}

package/dist/app-build-result.d.ts

@@ -0,0 +1,22 @@
+import { ArtifactDefinition } from '@teambit/builder';
+export interface AppBuildResult {
+    artifacts?: ArtifactDefinition[];
+    /**
+     * errors thrown during the build process.
+     */
+    errors?: Error[];
+    /**
+     * warnings thrown during the build process.
+     */
+    warnings?: string[];
+    /**
+     * metadata to persist.
+     * this is the only property that actually gets saved into the objects (in builder aspect, aspectsData.buildDeployContexts[deployContext]).
+     * in some scenarios, the build and deploy pipelines run in different processes, and then the only data the deploy
+     * gets is what saved into the objects.
+     * examples of data that gets save here:
+     * React: { publicDir, ssrPublicDir }.
+     * Node: { mainFile, artifactsDir }.
+     */
+    metadata?: Record<string, any>;
+}

package/dist/app-context.d.ts

@@ -0,0 +1,103 @@
+import { ExecutionContext } from '@teambit/envs';
+import { Harmony } from '@teambit/harmony';
+import { Component } from '@teambit/component';
+import { Logger } from '@teambit/logger';
+export declare class AppContext extends ExecutionContext {
+    /**
+     * name of the app
+     */
+    readonly appName: string;
+    /**
+     * instance of harmony.
+     */
+    readonly harmony: Harmony;
+    /**
+     * determine whether to serve the application in dev mode.
+     */
+    readonly dev: boolean;
+    /**
+     * application component instance.
+     */
+    readonly appComponent: Component;
+    /**
+     * working directory of the component.
+     */
+    readonly workdir: string;
+    /**
+     * execution context of the app.
+     */
+    readonly execContext: ExecutionContext;
+    /**
+     * A path for the host root dir
+     * Host root dir is the dir where we run the app from
+     * This can be used in different bundle options which run require.resolve
+     * for example when configuring webpack aliases or webpack expose loader on the peers deps
+     */
+    readonly hostRootDir?: string | undefined;
+    /**
+     * A port to run the app on
+     */
+    readonly port?: number | undefined;
+    /**
+     * path to the application component in the workspace
+     */
+    readonly workspaceComponentPath?: string | undefined;
+    /**
+     * list of env variables to include.
+     */
+    readonly envVariables: Record<string, string>;
+    constructor(
+    /**
+     * name of the app
+     */
+    appName: string, 
+    /**
+     * instance of harmony.
+     */
+    harmony: Harmony, 
+    /**
+     * determine whether to serve the application in dev mode.
+     */
+    dev: boolean, 
+    /**
+     * application component instance.
+     */
+    appComponent: Component, 
+    /**
+     * working directory of the component.
+     */
+    workdir: string, 
+    /**
+     * execution context of the app.
+     */
+    execContext: ExecutionContext, 
+    /**
+     * A path for the host root dir
+     * Host root dir is the dir where we run the app from
+     * This can be used in different bundle options which run require.resolve
+     * for example when configuring webpack aliases or webpack expose loader on the peers deps
+     */
+    hostRootDir?: string | undefined, 
+    /**
+     * A port to run the app on
+     */
+    port?: number | undefined, 
+    /**
+     * path to the application component in the workspace
+     */
+    workspaceComponentPath?: string | undefined, 
+    /**
+     * list of env variables to include.
+     */
+    envVariables?: Record<string, string>);
+    /**
+     * return a logger instance for the env.
+     */
+    createLogger(name?: string): Logger;
+    /**
+     * get an instance of an aspect.
+     * make sure it is loaded prior to requesting it.
+     */
+    getAspect<T>(aspectId: string): T | undefined;
+    static compose(appContext: AppContext, overrides?: Partial<AppContext>): AppContext;
+}

package/dist/app-deploy-context.d.ts

@@ -0,0 +1,33 @@
+import { Artifact, ArtifactList } from '@teambit/builder';
+import { AppBuildContext } from './app-build-context';
+export declare class AppDeployContext extends AppBuildContext {
+    /**
+     * artifacts generated upon component build.
+     */
+    readonly artifacts: ArtifactList<Artifact>;
+    /**
+     * public dir generated by the build.
+     */
+    readonly publicDir?: string | undefined;
+    /**
+     * ssr dir generated by the build.
+     */
+    readonly ssrPublicDir?: string | undefined;
+    constructor(
+    /**
+     * app build context.
+     */
+    appBuildContext: AppBuildContext, 
+    /**
+     * artifacts generated upon component build.
+     */
+    artifacts: ArtifactList<Artifact>, 
+    /**
+     * public dir generated by the build.
+     */
+    publicDir?: string | undefined, 
+    /**
+     * ssr dir generated by the build.
+     */
+    ssrPublicDir?: string | undefined);
+}

package/dist/app-instance.d.ts

@@ -0,0 +1,35 @@
+export type ApplicationInstance = {
+    /**
+     * port in which app is running.
+     */
+    port?: number;
+    /**
+     * name of the app
+     */
+    appName?: string;
+    /**
+     * url of the running app.
+     */
+    url?: string;
+    /**
+     * function for closing the server.
+     */
+    stop?: () => Promise<void>;
+};
+/**
+ * an instance of an application deployment.
+ */
+export type ApplicationDeployment = {
+    /**
+     * timestamp of the deployment.
+     */
+    timestamp?: string;
+    /**
+     * name of the deployed app.
+     */
+    appName?: string;
+    /**
+     * url the deployed app.
+     */
+    url?: string;
+};

package/dist/app-list.cmd.d.ts

@@ -0,0 +1,18 @@
+import { Command, CommandOptions } from '@teambit/cli';
+import { ApplicationMain } from './application.main.runtime';
+/**
+ * @deprecated use AppListCmd class
+ */
+export declare class AppListCmdDeprecated implements Command {
+    private applicationAspect;
+    name: string;
+    description: string;
+    alias: string;
+    private: boolean;
+    group: string;
+    options: CommandOptions;
+    constructor(applicationAspect: ApplicationMain);
+    report(args: [string], { json }: {
+        json: boolean;
+    }): Promise<string>;
+}

package/dist/app-server.d.ts

@@ -0,0 +1,6 @@
+import { Application } from './application';
+export declare class AppServer {
+    private app;
+    constructor(app: Application);
+    get name(): string;
+}

package/dist/app-type-list.d.ts

@@ -0,0 +1,13 @@
+import { EnvContext, EnvHandler } from '@teambit/envs';
+import { ApplicationType } from './application-type';
+export type AppTypeListOptions = {
+    name?: string;
+};
+export declare class AppTypeList {
+    readonly name: string;
+    private appTypes;
+    private context;
+    constructor(name: string, appTypes: EnvHandler<ApplicationType<any>>[], context: EnvContext);
+    compute(): ApplicationType<any>[];
+    static from(appTypes: EnvHandler<ApplicationType<any>>[], options?: AppTypeListOptions): EnvHandler<AppTypeList>;
+}

package/dist/app-type.plugin.d.ts

@@ -0,0 +1,12 @@
+import { PluginDefinition } from '@teambit/aspect-loader';
+import { ApplicationType } from './application-type';
+import { ApplicationSlot } from './application.main.runtime';
+export declare class AppTypePlugin implements PluginDefinition {
+    readonly pattern: string;
+    private appType;
+    private appSlot;
+    constructor(pattern: string, appType: ApplicationType<unknown>, appSlot: ApplicationSlot);
+    runtimes: string[];
+    register(object: any): void;
+    private validateApp;
+}

package/dist/app.cmd.d.ts

@@ -0,0 +1,25 @@
+import { Command, CommandOptions } from '@teambit/cli';
+import { ApplicationMain } from './application.main.runtime';
+export declare class AppListCmd implements Command {
+    private applicationAspect;
+    name: string;
+    description: string;
+    alias: string;
+    group: string;
+    helpUrl: string;
+    options: CommandOptions;
+    constructor(applicationAspect: ApplicationMain);
+    report(args: [string], { json }: {
+        json: boolean;
+    }): Promise<string>;
+}
+export declare class AppCmd implements Command {
+    name: string;
+    description: string;
+    helpUrl: string;
+    alias: string;
+    group: string;
+    commands: Command[];
+    options: CommandOptions;
+    report(args: [string]): Promise<string>;
+}

package/dist/app.plugin.d.ts

@@ -0,0 +1,10 @@
+import { PluginDefinition } from '@teambit/aspect-loader';
+import { ApplicationSlot } from './application.main.runtime';
+export declare const BIT_APP_PATTERN = "*.bit-app.*";
+export declare class AppPlugin implements PluginDefinition {
+    private appSlot;
+    constructor(appSlot: ApplicationSlot);
+    pattern: string;
+    runtimes: string[];
+    register(object: any): void;
+}

package/dist/application-type.d.ts

@@ -0,0 +1,15 @@
+import { Application } from './application';
+export interface ApplicationType<T> {
+    /**
+     * name of the type of the app. e.g. `react-app`
+     */
+    name: string;
+    /**
+     * pattern of the app.
+     */
+    globPattern?: string;
+    /**
+     * a function that creates the app instance.
+     */
+    createApp(options: T): Application;
+}

package/dist/application.aspect.d.ts

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

package/dist/application.composition.d.ts

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

package/dist/application.d.ts

@@ -0,0 +1,33 @@
+import { AppContext } from './app-context';
+import { AppDeployContext } from './app-deploy-context';
+import { AppBuildContext } from './app-build-context';
+import { AppBuildResult } from './app-build-result';
+import { ApplicationDeployment, ApplicationInstance } from './app-instance';
+export type DeployFn = (context: AppDeployContext) => Promise<ApplicationDeployment | void | undefined>;
+export type BuildFn = (context: AppBuildContext) => Promise<AppBuildResult>;
+export type AppResult = {
+    port?: number;
+    errors?: Error[];
+};
+export interface Application {
+    /**
+     * name of the application. e.g. ripple-ci.
+     */
+    name: string;
+    /**
+     * run the application.
+     */
+    run(context: AppContext): Promise<ApplicationInstance | number>;
+    /**
+     * build the application.
+     */
+    build?: BuildFn;
+    /**
+     * application deployment. this is a build task.
+     */
+    deploy?: DeployFn;
+    /**
+     * Type of the application
+     */
+    applicationType?: string;
+}

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

@@ -0,0 +1,153 @@
+import { CLIMain } from '@teambit/cli';
+import { AspectLoaderMain } from '@teambit/aspect-loader';
+import { SlotRegistry, Harmony } from '@teambit/harmony';
+import { Workspace } from '@teambit/workspace';
+import { WatcherMain } from '@teambit/watcher';
+import { BuilderMain } from '@teambit/builder';
+import { ScopeMain } from '@teambit/scope';
+import { Logger, LoggerMain } from '@teambit/logger';
+import { EnvsMain } from '@teambit/envs';
+import { ComponentMain, ComponentID, Component } from '@teambit/component';
+import { ApplicationType } from './application-type';
+import { Application } from './application';
+import { DeploymentProvider } from './deployment-provider';
+import { AppService } from './application.service';
+import { AppContext } from './app-context';
+export type ApplicationTypeSlot = SlotRegistry<ApplicationType<unknown>[]>;
+export type ApplicationSlot = SlotRegistry<Application[]>;
+export type DeploymentProviderSlot = SlotRegistry<DeploymentProvider[]>;
+export type ApplicationAspectConfig = {
+    /**
+     * envs ids to load app types.
+     */
+    envs?: string[];
+};
+/**
+ * Application meta data that is stored on the component on load if it's an application.
+ */
+export type ApplicationMetadata = {
+    appName: string;
+    type?: string;
+};
+export type ServeAppOptions = {
+    /**
+     * default port range used to serve applications.
+     */
+    defaultPortRange?: [start: number, end: number];
+    /**
+     * determine whether to start the application in dev mode.
+     */
+    dev: boolean;
+    /**
+     * actively watch and compile the workspace (like the bit watch command)
+     * @default true
+     */
+    watch?: boolean;
+    /**
+     * determine whether to start the application in server side mode.
+     * @default false
+     */
+    ssr?: boolean;
+    /**
+     * exact port to run the app
+     */
+    port?: number;
+};
+export declare class ApplicationMain {
+    private appSlot;
+    private appTypeSlot;
+    private deploymentProviderSlot;
+    private config;
+    private envs;
+    private componentAspect;
+    private appService;
+    private aspectLoader;
+    private workspace;
+    private logger;
+    private watcher;
+    private harmony;
+    constructor(appSlot: ApplicationSlot, appTypeSlot: ApplicationTypeSlot, deploymentProviderSlot: DeploymentProviderSlot, config: ApplicationAspectConfig, envs: EnvsMain, componentAspect: ComponentMain, appService: AppService, aspectLoader: AspectLoaderMain, workspace: Workspace, logger: Logger, watcher: WatcherMain, harmony: Harmony);
+    /**
+     * register a new app.
+     */
+    registerApp(app: Application): this;
+    /**
+     * list all registered apps.
+     */
+    listApps(): Application[];
+    /**
+     * map all apps by component ID.
+     */
+    mapApps(): [string, Application[]][];
+    /**
+     * list apps by a component id.
+     */
+    listAppsById(id?: ComponentID): Application[] | undefined;
+    /**
+     * get an application by a component id.
+     */
+    getAppById(id: ComponentID): Promise<Application | undefined>;
+    /**
+     * calculate an application by a component.
+     * This should be only used during the on component load slot
+     */
+    calculateAppByComponent(component: Component): Application | undefined;
+    listAppTypes(): ApplicationType<unknown>[];
+    /**
+     * @deprecated use `listAppsComponents` instead.
+     * @returns
+     */
+    listAppsFromComponents(): Promise<Component[]>;
+    listAppsComponents(): Promise<Component[]>;
+    private hasAppTypePattern;
+    getAppPatterns(): string[];
+    loadApps(): Promise<Application[]>;
+    loadAppsFromComponent(component: Component, rootDir: string): Promise<Application[] | undefined>;
+    /**
+     * get an app.
+     */
+    getApp(appName: string, id?: ComponentID): Application | undefined;
+    getAppByNameOrId(appNameOrId: string): Application | undefined;
+    getAppPattern(appType: ApplicationType<unknown>): string;
+    /**
+     * registers a new app and sets a plugin for it.
+     */
+    registerAppType<T>(...appTypes: Array<ApplicationType<T>>): this;
+    /**
+     * get an app AspectId.
+     */
+    getAppAspect(appName: string): string | undefined;
+    /**
+     * get app to throw.
+     */
+    getAppOrThrow(appName: string): Application;
+    defaultOpts: ServeAppOptions;
+    private computeOptions;
+    loadAppsToSlot(): Promise<this>;
+    runApp(appName: string, options?: ServeAppOptions): Promise<{
+        app: Application;
+        port: number | undefined;
+        errors?: Error[];
+        isOldApi: boolean;
+    }>;
+    /**
+     * get the component ID of a certain app.
+     */
+    getAppIdOrThrow(appName: string): Promise<ComponentID>;
+    private createAppContext;
+    createAppBuildContext(id: ComponentID, appName: string, capsuleRootDir: string, rootDir?: string): Promise<AppContext>;
+    static runtime: import("@teambit/harmony").RuntimeDefinition;
+    static dependencies: import("@teambit/harmony").Aspect[];
+    static slots: (((registerFn: () => string) => SlotRegistry<ApplicationType<unknown>[]>) | ((registerFn: () => string) => SlotRegistry<Application[]>) | ((registerFn: () => string) => SlotRegistry<DeploymentProvider[]>))[];
+    static provider([cli, loggerAspect, builder, envs, component, aspectLoader, workspace, watcher, scope]: [
+        CLIMain,
+        LoggerMain,
+        BuilderMain,
+        EnvsMain,
+        ComponentMain,
+        AspectLoaderMain,
+        Workspace,
+        WatcherMain,
+        ScopeMain
+    ], config: ApplicationAspectConfig, [appTypeSlot, appSlot, deploymentProviderSlot]: [ApplicationTypeSlot, ApplicationSlot, DeploymentProviderSlot], harmony: Harmony): Promise<ApplicationMain>;
+}

package/dist/application.service.d.ts

@@ -0,0 +1,15 @@
+import { EnvService, Env, EnvContext, ServiceTransformationMap, ExecutionContext } from '@teambit/envs';
+import { ApplicationType } from './application-type';
+type ApplicationTransformationMap = ServiceTransformationMap & {
+    getAppTypes: () => ApplicationType<any>[];
+};
+export declare class AppService implements EnvService<any> {
+    name: string;
+    registerAppType: (...appType: Array<ApplicationType<any>>) => void;
+    run(context: ExecutionContext): Promise<ExecutionContext & {
+        dev: boolean;
+        errors: never[];
+    }>;
+    transform(env: Env, context: EnvContext): ApplicationTransformationMap | undefined;
+}
+export {};

package/dist/apps-env-type.d.ts

@@ -0,0 +1,8 @@
+import { EnvHandler } from '@teambit/envs';
+import { AppTypeList } from './app-type-list';
+export interface AppsEnv {
+    /**
+     * return a template list instance.
+     */
+    apps?(): EnvHandler<AppTypeList>;
+}

package/dist/build-application.task.d.ts

@@ -0,0 +1,40 @@
+import { BuildTask, BuiltTaskResult, BuildContext, ComponentResult, ArtifactDefinition } from '@teambit/builder';
+import { ApplicationMain } from './application.main.runtime';
+export declare const BUILD_TASK = "build_application";
+export declare const ARTIFACTS_DIR_NAME = "apps";
+export type OneAppResult = {
+    componentResult: ComponentResult;
+    artifacts?: ArtifactDefinition[];
+};
+export type OneComponentResult = {
+    componentResult: ComponentResult;
+    artifacts?: ArtifactDefinition[];
+};
+export type BuildAppResult = {
+    componentResult: ComponentResult;
+    artifacts?: ArtifactDefinition[];
+};
+export type BuildDeployContexts = {
+    deployContext: {
+        publicDir?: string;
+        ssrPublicDir?: string;
+    };
+    name: string;
+    appType: string;
+};
+export type Options = {
+    deploy: boolean;
+};
+export declare class AppsBuildTask implements BuildTask {
+    private application;
+    private opt;
+    name: string;
+    aspectId: string;
+    readonly location = "end";
+    constructor(application: ApplicationMain, opt?: Options);
+    execute(context: BuildContext): Promise<BuiltTaskResult>;
+    private runForOneApp;
+    private mergeAppsResults;
+    private getArtifactDirectory;
+    private getDefaultArtifactDef;
+}

package/dist/deploy.task.d.ts

@@ -0,0 +1,16 @@
+import { BuilderMain, BuildTask, BuildContext, BuiltTaskResult } from '@teambit/builder';
+import { ApplicationMain } from './application.main.runtime';
+export declare const DEPLOY_TASK = "deploy_application";
+export declare class DeployTask implements BuildTask {
+    private application;
+    private builder;
+    name: string;
+    aspectId: string;
+    readonly location = "end";
+    constructor(application: ApplicationMain, builder: BuilderMain);
+    execute(context: BuildContext): Promise<BuiltTaskResult>;
+    private runForOneApp;
+    private getArtifactDirectory;
+    private getBuildMetadata;
+    private getBuildTask;
+}

package/dist/deployment-provider.d.ts

@@ -0,0 +1,4 @@
+import { DeployFn } from './application';
+export interface DeploymentProvider {
+    deploy: DeployFn;
+}

package/dist/exceptions/app-no-ssr.d.ts

@@ -0,0 +1,3 @@
+export declare class AppNoSsr extends Error {
+    constructor(appName: string);
+}

package/dist/exceptions/app-not-found.d.ts

@@ -0,0 +1,3 @@
+export declare class AppNotFound extends Error {
+    constructor(appName: string);
+}

package/dist/exceptions/index.d.ts

@@ -0,0 +1 @@
+export { AppNotFound } from './app-not-found';

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { ApplicationAspect } from './application.aspect';
+export type { ApplicationInstance, ApplicationDeployment } from './app-instance';
+export type { ApplicationMain, ApplicationMetadata } from './application.main.runtime';
+export type { Application, DeployFn, BuildFn, AppResult } from './application';
+export { AppContext } from './app-context';
+export type { DeploymentProvider } from './deployment-provider';
+export type { ApplicationType } from './application-type';
+export type { AppDeployContext } from './app-deploy-context';
+export type { AppBuildContext } from './app-build-context';
+export type { AppBuildResult } from './app-build-result';
+export { ARTIFACTS_DIR_NAME as APPS_ARTIFACTS_DIR_NAME } from './build-application.task';
+export type { AppsEnv } from './apps-env-type';
+export { AppTypeList } from './app-type-list';

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

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