@teambit/pkg 1.0.228 → 1.0.229

package/dist/exceptions/index.d.ts

@@ -0,0 +1,3 @@
+export { PkgArtifactNotFound } from './pkg-artifact-not-found';
+export { ScopeNotFound } from './scope-not-found';
+export { PackageTarFiletNotFound } from './package-tar-filet-not-found';

package/dist/exceptions/package-tar-filet-not-found.d.ts

@@ -0,0 +1,6 @@
+import { ComponentID } from '@teambit/component';
+import { BitError } from '@teambit/bit-error';
+export declare class PackageTarFiletNotFound extends BitError {
+    readonly componentId: ComponentID;
+    constructor(componentId: ComponentID);
+}

package/dist/exceptions/pkg-artifact-not-found.d.ts

@@ -0,0 +1,6 @@
+import { ComponentID } from '@teambit/component';
+import { BitError } from '@teambit/bit-error';
+export declare class PkgArtifactNotFound extends BitError {
+    readonly componentId: ComponentID;
+    constructor(componentId: ComponentID);
+}

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

@@ -0,0 +1,5 @@
+import { BitError } from '@teambit/bit-error';
+export declare class ScopeNotFound extends BitError {
+    readonly scopePath?: string | undefined;
+    constructor(scopePath?: string | undefined);
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export type { PkgMain, PackageJsonProps, ComponentPackageManifest, ComponentPkgExtensionData, VersionPackageManifest, } from './pkg.main.runtime';
+export type { PackageDependency, PackageDependencyFactory } from './package-dependency';
+export type { PackageEnv } from './package-env-type';
+export { PackageGenerator } from './package-generator';
+export { PkgAspect as default, PkgAspect } from './pkg.aspect';
+export { PkgUI } from './pkg.ui.runtime';

package/dist/pack.cmd.d.ts

@@ -0,0 +1,25 @@
+import { Command, CommandOptions } from '@teambit/cli';
+import { Packer } from './packer';
+type PackArgs = [string, string];
+type PackCmdOptions = {
+    outDir?: string;
+    override?: boolean;
+    prefix?: boolean;
+    keep?: boolean;
+};
+export declare class PackCmd implements Command {
+    private packer;
+    name: string;
+    description: string;
+    options: CommandOptions;
+    alias: string;
+    group: string;
+    private: boolean;
+    constructor(packer: Packer);
+    report(args: PackArgs, options: PackCmdOptions): Promise<string>;
+    json([componentId, scopePath]: PackArgs, options: PackCmdOptions): Promise<{
+        data: import("./packer").PackResultWithId;
+        code: number;
+    }>;
+}
+export {};

package/dist/pack.task.d.ts

@@ -0,0 +1,17 @@
+import { BuildContext, BuiltTaskResult, BuildTask, TaskLocation } from '@teambit/builder';
+import { Logger } from '@teambit/logger';
+import { Packer } from './packer';
+/**
+ * pack components to a .tgz file
+ */
+export declare class PackTask implements BuildTask {
+    readonly aspectId: string;
+    private packer;
+    private logger;
+    readonly name = "PackComponents";
+    readonly description = "Packing components into a .tgz file";
+    readonly location: TaskLocation;
+    readonly dependencies: string[];
+    constructor(aspectId: string, packer: Packer, logger: Logger);
+    execute(context: BuildContext): Promise<BuiltTaskResult>;
+}

package/dist/package-dependency/index.d.ts

@@ -0,0 +1,2 @@
+export { PackageDependency, SerializedPackageDependency } from './package-dependency';
+export { PackageDependencyFactory } from './package-dependency-factory';

package/dist/package-dependency/package-dependency-factory.d.ts

@@ -0,0 +1,8 @@
+import { SerializedDependency, DependencyFactory, DependencyList } from '@teambit/dependency-resolver';
+import LegacyComponent from '@teambit/legacy/dist/consumer/component';
+export declare class PackageDependencyFactory implements DependencyFactory {
+    type: string;
+    constructor();
+    parse<PackageDependency, S extends SerializedDependency>(serialized: S): PackageDependency;
+    fromLegacyComponent(legacyComponent: LegacyComponent): Promise<DependencyList>;
+}

package/dist/package-dependency/package-dependency.d.ts

@@ -0,0 +1,7 @@
+import { BaseDependency, SerializedDependency, DependencyLifecycleType, DependencySource } from '@teambit/dependency-resolver';
+export interface SerializedPackageDependency extends SerializedDependency {
+}
+export declare class PackageDependency extends BaseDependency {
+    constructor(id: string, version: string, lifecycle: DependencyLifecycleType, source?: DependencySource, hidden?: boolean, optional?: boolean);
+    getPackageName(): string;
+}

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

@@ -0,0 +1,8 @@
+import { EnvHandler } from '@teambit/envs';
+import { PackageGenerator } from './package-generator';
+export interface PackageEnv {
+    /**
+     * return a PackageGenerator instance.
+     */
+    package(): EnvHandler<PackageGenerator>;
+}

package/dist/package-generator.d.ts

@@ -0,0 +1,19 @@
+import { EnvContext, EnvHandler } from '@teambit/envs';
+import { PackageJsonProps } from './pkg.main.runtime';
+export type PackageGeneratorOptions = {
+    packageJson: PackageJsonProps;
+    npmIgnore?: string[];
+};
+/**
+ * create and maintain build pipelines for component
+ * dev environments.
+ */
+export declare class PackageGenerator {
+    private _packageJson;
+    private _npmIgnore;
+    private context;
+    constructor(_packageJson: PackageJsonProps, _npmIgnore: string[], context: EnvContext);
+    get packageJsonProps(): PackageJsonProps;
+    get npmIgnore(): string[];
+    static from(options: PackageGeneratorOptions): EnvHandler<PackageGenerator>;
+}

package/dist/package.fragment.d.ts

@@ -0,0 +1,16 @@
+import { Component, ShowFragment } from '@teambit/component';
+import { PkgMain } from './pkg.main.runtime';
+export declare class PackageFragment implements ShowFragment {
+    private pkg;
+    constructor(pkg: PkgMain);
+    title: string;
+    renderRow(component: Component): Promise<{
+        title: string;
+        content: string;
+    }>;
+    json(component: Component): Promise<{
+        title: string;
+        json: string;
+    }>;
+    weight: number;
+}

package/dist/package.route.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="express" />
+import { Request, Response, Route } from '@teambit/express';
+import { PkgMain } from './pkg.main.runtime';
+export declare const routePath = "package";
+export declare class PackageRoute implements Route {
+    /**
+     * pkg extension.
+     */
+    private pkg;
+    constructor(
+    /**
+     * pkg extension.
+     */
+    pkg: PkgMain);
+    route: string;
+    method: string;
+    middlewares: ((req: Request, res: Response) => Promise<import("express").Response<any, Record<string, any>>>)[];
+}

package/dist/packer.d.ts

@@ -0,0 +1,42 @@
+import { ComponentFactory } from '@teambit/component';
+import { ComponentResult, ArtifactDefinition } from '@teambit/builder';
+import { Capsule, IsolatorMain } from '@teambit/isolator';
+import { ScopeMain } from '@teambit/scope';
+import { Logger } from '@teambit/logger';
+export type PackResult = Omit<ComponentResult, 'component'>;
+export type PackResultWithId = PackResult & {
+    id: string;
+};
+export declare const DEFAULT_TAR_DIR_IN_CAPSULE = "package-tar";
+export declare const TAR_FILE_ARTIFACT_NAME = "package tar file";
+export type PackResultMetadata = {
+    pkgJson: Record<any, string>;
+    tarPath: string;
+    tarName: string;
+    checksum?: string;
+    integrity?: string;
+};
+export type PackWriteOptions = {
+    outDir?: string;
+    override?: boolean;
+};
+export type PackOptions = {
+    writeOptions: PackWriteOptions;
+    prefix?: boolean;
+    keep?: boolean;
+    loadScopeFromCache?: boolean;
+    dryRun?: boolean;
+};
+export declare class Packer {
+    private isolator;
+    private logger;
+    private host;
+    private scope?;
+    constructor(isolator: IsolatorMain, logger: Logger, host: ComponentFactory, scope?: ScopeMain | undefined);
+    packComponent(componentId: string, scopePath: string | undefined, options: PackOptions): Promise<PackResultWithId>;
+    packMultipleCapsules(capsules: Capsule[], writeOptions?: PackWriteOptions, dryRun?: boolean, omitFullTarPath?: boolean): Promise<ComponentResult[]>;
+    packCapsule(capsule: Capsule, writeOptions?: PackWriteOptions, dryRun?: boolean, omitFullTarPath?: boolean): Promise<ComponentResult>;
+    pnpmPack(cwd: string, outputPath: string, override?: boolean, dryRun?: boolean): Promise<PackResult>;
+    getArtifactDefInCapsule(outDir?: string): ArtifactDefinition;
+    private getCapsule;
+}

package/dist/pkg-artifact.d.ts

@@ -0,0 +1,5 @@
+import { AbstractVinyl } from '@teambit/legacy/dist/consumer/component/sources';
+export declare class PkgArtifact {
+    private artifacts;
+    constructor(artifacts: AbstractVinyl[]);
+}

package/dist/pkg.aspect.d.ts

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

package/dist/pkg.composition.d.ts

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

package/dist/pkg.graphql.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from '@teambit/graphql';
+import { PkgMain } from './pkg.main.runtime';
+export declare function pkgSchema(pkg: PkgMain): Schema;

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

@@ -0,0 +1,194 @@
+import { CLIMain } from '@teambit/cli';
+import { Component, ComponentMain, IComponent, Snap } from '@teambit/component';
+import { EnvsMain } from '@teambit/envs';
+import { SlotRegistry } from '@teambit/harmony';
+import { IsolatorMain } from '@teambit/isolator';
+import { LoggerMain, Logger } from '@teambit/logger';
+import { ScopeMain } from '@teambit/scope';
+import { Workspace } from '@teambit/workspace';
+import { BuilderMain } from '@teambit/builder';
+import { AbstractVinyl } from '@teambit/legacy/dist/consumer/component/sources';
+import { GraphqlMain } from '@teambit/graphql';
+import { DependencyResolverMain } from '@teambit/dependency-resolver';
+import { Packer, PackOptions, PackResult } from './packer';
+import { PublishTask } from './publish.task';
+import { PkgArtifact } from './pkg-artifact';
+export interface PackageJsonProps {
+    [key: string]: any;
+}
+export type PackageJsonPropsRegistry = SlotRegistry<PackageJsonProps>;
+export type PkgExtensionConfig = {
+    packageManagerPublishArgs?: string[];
+    packageJson?: Record<string, any>;
+    avoidPublishToNPM?: boolean;
+};
+type GetModulePathOptions = {
+    absPath?: boolean;
+};
+/**
+ * Config for variants
+ */
+export type ComponentPkgExtensionConfig = {
+    /**
+     * properties to add to the package.json of the component.
+     */
+    packageJson: Record<string, any>;
+};
+/**
+ * Data stored in the component
+ */
+export type ComponentPkgExtensionData = {
+    /**
+     * properties to add to the package.json of the component.
+     */
+    packageJsonModification: Record<string, any>;
+    /**
+     * Final package.json after creating tar file
+     */
+    pkgJson?: Record<string, any>;
+    /**
+     * integrity of the tar file
+     */
+    integrity?: string;
+    /**
+     * Checksum of the tar file
+     */
+    checksum?: string;
+};
+export type ComponentPackageManifest = {
+    name: string;
+    distTags: Record<string, string>;
+    externalRegistry: boolean;
+    versions: VersionPackageManifest[];
+};
+export type VersionPackageManifest = {
+    [key: string]: any;
+    dist: {
+        tarball: string;
+        shasum: string;
+    };
+};
+export declare class PkgMain {
+    /**
+     * logger extension
+     */
+    readonly logger: Logger;
+    /**
+     * pkg extension configuration.
+     */
+    readonly config: PkgExtensionConfig;
+    /**
+     * Registry for changes by other extensions.
+     */
+    private packageJsonPropsRegistry;
+    private workspace;
+    private scope;
+    private builder;
+    /**
+     * A utils class to packing components into tarball
+     */
+    private packer;
+    /**
+     * envs extension.
+     */
+    private envs;
+    private componentAspect;
+    /**
+     * keep it as public. external env might want to register it to the snap pipeline
+     */
+    publishTask: PublishTask;
+    private dependencyResolver;
+    static runtime: import("@teambit/harmony").RuntimeDefinition;
+    static dependencies: import("@teambit/harmony").Aspect[];
+    static slots: ((registerFn: () => string) => SlotRegistry<PackageJsonProps>)[];
+    static defaultConfig: {};
+    static provider([cli, scope, envs, isolator, logger, workspace, builder, dependencyResolver, componentAspect, graphql]: [
+        CLIMain,
+        ScopeMain,
+        EnvsMain,
+        IsolatorMain,
+        LoggerMain,
+        Workspace,
+        BuilderMain,
+        DependencyResolverMain,
+        ComponentMain,
+        GraphqlMain
+    ], config: PkgExtensionConfig, [packageJsonPropsRegistry]: [PackageJsonPropsRegistry]): Promise<PkgMain>;
+    /**
+     * get the package name of a component.
+     */
+    getPackageName(component: Component): string;
+    getRuntimeModulePath(component: Component, options?: GetModulePathOptions): string;
+    /**
+     * returns the package path in the /node_modules/ folder
+     * In case you call this in order to run the code from the path, please refer to the `getRuntimeModulePath` API
+     */
+    getModulePath(component: Component, options?: GetModulePathOptions): string;
+    isModulePathExists(component: Component): boolean;
+    addMissingLinksFromNodeModulesIssue(component: Component): Promise<undefined>;
+    private manifestCache;
+    constructor(
+    /**
+     * logger extension
+     */
+    logger: Logger, 
+    /**
+     * pkg extension configuration.
+     */
+    config: PkgExtensionConfig, 
+    /**
+     * Registry for changes by other extensions.
+     */
+    packageJsonPropsRegistry: PackageJsonPropsRegistry, workspace: Workspace, scope: ScopeMain, builder: BuilderMain, 
+    /**
+     * A utils class to packing components into tarball
+     */
+    packer: Packer, 
+    /**
+     * envs extension.
+     */
+    envs: EnvsMain, componentAspect: ComponentMain, 
+    /**
+     * keep it as public. external env might want to register it to the snap pipeline
+     */
+    publishTask: PublishTask, dependencyResolver: DependencyResolverMain);
+    /**
+     * register changes in the package.json
+     */
+    registerPackageJsonNewProps(props: PackageJsonProps): void;
+    /**
+     * Pack a component and generate a tarball suitable for npm registry
+     *
+     * @param {string} componentId
+     * @param {(string | undefined)} scopePath
+     * @param {string} outDir
+     * @param {boolean} [prefix=false]
+     * @param {boolean} [override=false]
+     * @param {boolean} [keep=false]
+     * @returns {Promise<PackResult>}
+     * @memberof PkgExtension
+     */
+    packComponent(componentId: string, scopePath: string | undefined, options: PackOptions): Promise<PackResult>;
+    /**
+     * Merge the configs provided by:
+     * 1. envs configured in the component - via getPackageJsonProps method
+     * 2. extensions that registered to the registerPackageJsonNewProps slot (and configured for the component)
+     * 3. props defined by the user (they are the strongest one)
+     */
+    mergePackageJsonProps(component: Component): Promise<PackageJsonProps>;
+    getPackageJsonModifications(component: Component): Record<string, any>;
+    getPkgArtifact(component: Component): Promise<PkgArtifact>;
+    getManifest(component: Component): Promise<ComponentPackageManifest>;
+    private getAllSnapsManifests;
+    /**
+     * Check if the component should be fetched from bit registry or from another registry
+     * This will usually determined by the latest version of the component
+     * @param component
+     */
+    isPublishedToExternalRegistry(component: IComponent): boolean;
+    private getComponentBuildData;
+    getSnapManifest(component: Component, snap: Snap): Promise<VersionPackageManifest | undefined>;
+    getPackageTarFile(component: Component): Promise<AbstractVinyl>;
+    transformPackageJson(component: Component, packageJsonObject: Record<string, any>): Promise<Record<string, any>>;
+}
+export {};

package/dist/pkg.service.d.ts

@@ -0,0 +1,18 @@
+import { EnvService, EnvDefinition, Env, EnvContext, ServiceTransformationMap, GetNpmIgnoreContext } from '@teambit/envs';
+import { PackageJsonProps } from './pkg.main.runtime';
+export type PkgDescriptor = {
+    id: string;
+    displayName: string;
+    config?: string;
+};
+type PkgTransformationMap = ServiceTransformationMap & {
+    getPackageJsonProps: () => PackageJsonProps;
+    getNpmIgnore: (npmIgnoreContext?: GetNpmIgnoreContext) => string[];
+};
+export declare class PkgService implements EnvService<{}, PkgDescriptor> {
+    name: string;
+    render(env: EnvDefinition): Promise<string>;
+    transform(env: Env, context: EnvContext): PkgTransformationMap | undefined;
+    getDescriptor(env: EnvDefinition): PkgDescriptor | undefined;
+}
+export {};

package/dist/pkg.ui.runtime.d.ts

@@ -0,0 +1,10 @@
+import { ComponentUI } from '@teambit/component';
+export declare class PkgUI {
+    private compUI;
+    static runtime: import("@teambit/harmony").RuntimeDefinition;
+    static dependencies: import("@teambit/harmony").Aspect[];
+    static provider([componentUI]: [ComponentUI]): Promise<PkgUI>;
+    constructor(compUI: ComponentUI);
+    private npmConsumeMethod;
+}
+export default PkgUI;

package/dist/prepare-packages.task.d.ts

@@ -0,0 +1,31 @@
+import { BuildContext, BuiltTaskResult, BuildTask } from '@teambit/builder';
+import { EnvsMain } from '@teambit/envs';
+import { Logger } from '@teambit/logger';
+/**
+ * prepare packages for publishing.
+ */
+export declare class PreparePackagesTask implements BuildTask {
+    readonly aspectId: string;
+    private logger;
+    private envs;
+    readonly name = "PreparePackages";
+    readonly location = "end";
+    constructor(aspectId: string, logger: Logger, envs: EnvsMain);
+    execute(context: BuildContext): Promise<BuiltTaskResult>;
+    private writeNpmIgnoreFile;
+    /**
+     * remove the source files and copy the dists files
+     * into the root of the capsule.
+     * this is needed when components import from other components internal paths. without this task,
+     * the internal paths are the source, so node will throw an error when trying to use them. this
+     * task makes sure that the internal paths point to the consumable code (dists).
+     */
+    private executeDistAsRootTask;
+    private removeSourceFiles;
+    private moveDistToRoot;
+    /**
+     * by default, the "main" prop points to the dist file (e.g. "dist/index./js").
+     * here, we have to change it because there is no dist dir anymore.
+     */
+    private updatePackageJson;
+}

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.pkg_pkg@1.0.228/dist/pkg.composition.js';
-import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.pkg_pkg@1.0.228/dist/pkg.docs.mdx';
+import * as compositions_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.pkg_pkg@1.0.229/dist/pkg.composition.js';
+import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.pkg_pkg@1.0.229/dist/pkg.docs.mdx';
 
 export const compositions = [compositions_0];
 export const overview = [overview_0];

package/dist/publish-dry-run.task.d.ts

@@ -0,0 +1,18 @@
+import { BuildContext, BuiltTaskResult, BuildTask } from '@teambit/builder';
+import { Logger } from '@teambit/logger';
+import { Publisher } from './publisher';
+import { Packer } from './packer';
+/**
+ * publish build task is running "publish --dry-run" to avoid later npm errors during export
+ */
+export declare class PublishDryRunTask implements BuildTask {
+    readonly aspectId: string;
+    private publisher;
+    private packer;
+    private logger;
+    readonly name = "PublishDryRun";
+    readonly location = "end";
+    dependencies: string[];
+    constructor(aspectId: string, publisher: Publisher, packer: Packer, logger: Logger);
+    execute(context: BuildContext): Promise<BuiltTaskResult>;
+}

package/dist/publish.cmd.d.ts

@@ -0,0 +1,24 @@
+import { ComponentResult } from '@teambit/builder';
+import { Command, CommandOptions } from '@teambit/cli';
+import { Publisher, PublisherOptions } from './publisher';
+type PublishArgs = [string];
+export declare class PublishCmd implements Command {
+    private publisher;
+    name: string;
+    description: string;
+    arguments: {
+        name: string;
+        description: string;
+    }[];
+    options: CommandOptions;
+    alias: string;
+    private: boolean;
+    group: string;
+    constructor(publisher: Publisher);
+    report(args: PublishArgs, options: PublisherOptions): Promise<string>;
+    json([pattern]: PublishArgs, options: PublisherOptions): Promise<{
+        data: ComponentResult[];
+        code: number;
+    }>;
+}
+export {};

package/dist/publish.task.d.ts

@@ -0,0 +1,15 @@
+import { BuildContext, BuiltTaskResult, BuildTask, TaskLocation } from '@teambit/builder';
+import { Logger } from '@teambit/logger';
+import { Publisher } from './publisher';
+/**
+ * publish components by running "npm publish"
+ */
+export declare class PublishTask implements BuildTask {
+    readonly aspectId: string;
+    private publisher;
+    private logger;
+    readonly name = "PublishComponents";
+    readonly location: TaskLocation;
+    constructor(aspectId: string, publisher: Publisher, logger: Logger);
+    execute(context: BuildContext): Promise<BuiltTaskResult>;
+}

package/dist/publisher.d.ts

@@ -0,0 +1,32 @@
+import { ComponentResult } from '@teambit/builder';
+import { Capsule, IsolatorMain } from '@teambit/isolator';
+import { Logger } from '@teambit/logger';
+import { Workspace } from '@teambit/workspace';
+import { ExtensionDataList } from '@teambit/legacy/dist/consumer/config/extension-data';
+import { Scope } from '@teambit/legacy/dist/scope';
+export type PublisherOptions = {
+    dryRun?: boolean;
+    allowStaged?: boolean;
+};
+export declare class Publisher {
+    private isolator;
+    private logger;
+    private scope;
+    private workspace;
+    options: PublisherOptions;
+    packageManager: string;
+    constructor(isolator: IsolatorMain, logger: Logger, scope: Scope, workspace: Workspace, options?: PublisherOptions);
+    publish(componentPattern: string, options: PublisherOptions): Promise<ComponentResult[]>;
+    publishMultipleCapsules(capsules: Capsule[]): Promise<ComponentResult[]>;
+    private publishOneCapsule;
+    private getTagFlagForPreRelease;
+    private getComponentCapsules;
+    /**
+     * only components that use pkg extension and configure "publishConfig" with their own registry
+     * or custom "name", should be published. ignore the rest.
+     */
+    private getIdsToPublish;
+    shouldPublish(extensions: ExtensionDataList): boolean;
+    private getExtraArgsFromConfig;
+    private throwForNonStagedOrTaggedComponents;
+}

package/dist/write-npm-ignore.d.ts

@@ -0,0 +1,3 @@
+import { EnvsMain } from '@teambit/envs';
+import { Capsule } from '@teambit/isolator';
+export declare function writeNpmIgnore(capsule: Capsule, envs: EnvsMain): Promise<void>;