@teambit/objects 0.0.19

package/dist/models/version.d.ts

@@ -0,0 +1,279 @@
+import { ComponentID, ComponentIdList } from '@teambit/component-id';
+import { LaneId } from '@teambit/lane-id';
+import { BuildStatus } from '@teambit/legacy.constants';
+import { Dependencies, Dependency, ConsumerComponent } from '@teambit/legacy.consumer-component';
+import { SourceFile } from '@teambit/component.sources';
+import { ComponentOverridesData } from '@teambit/legacy.consumer-config';
+import { ExtensionDataList } from '@teambit/legacy.extension-data';
+import type { Doclet } from '@teambit/semantics.doc-parser';
+import { PathLinux } from '@teambit/legacy.utils';
+import { BitObject, Ref, Repository } from '../objects';
+import { ObjectItem } from '../objects/object-list';
+import Source from './source';
+import { DependenciesGraph } from './dependencies-graph';
+export type SourceFileModel = {
+    name: string;
+    relativePath: PathLinux;
+    test: boolean;
+    file: Ref;
+};
+export type DistFileModel = SourceFileModel;
+export type ArtifactFileModel = {
+    relativePath: PathLinux;
+    file: Ref;
+};
+export type Log = {
+    message: string;
+    date: string;
+    username: string | undefined;
+    email: string | undefined;
+};
+export type DepEdgeType = 'prod' | 'dev' | 'peer' | 'ext';
+export type DepEdge = {
+    source: ComponentID;
+    target: ComponentID;
+    type: DepEdgeType;
+};
+type ExternalHead = {
+    head: Ref;
+    laneId: LaneId;
+};
+type SquashData = {
+    previousParents: Ref[];
+    laneId: LaneId;
+};
+type VersionOrigin = {
+    id: {
+        scope: string;
+        name: string;
+    };
+    lane?: {
+        scope: string;
+        name: string;
+        hash: string;
+    };
+};
+export type VersionProps = {
+    mainFile: PathLinux;
+    files: Array<SourceFileModel>;
+    log: Log;
+    docs?: Doclet[];
+    dependencies?: Dependency[];
+    devDependencies?: Dependency[];
+    peerDependencies?: Dependency[];
+    flattenedDependencies?: ComponentIdList;
+    _flattenedEdges?: DepEdge[];
+    flattenedEdges?: DepEdge[];
+    flattenedEdgesRef?: Ref;
+    dependenciesGraphRef?: Ref;
+    packageDependencies?: {
+        [key: string]: string;
+    };
+    devPackageDependencies?: {
+        [key: string]: string;
+    };
+    peerPackageDependencies?: {
+        [key: string]: string;
+    };
+    bindingPrefix: string;
+    schema?: string;
+    overrides: ComponentOverridesData;
+    packageJsonChangedProps?: Record<string, any>;
+    hash?: string;
+    parents?: Ref[];
+    squashed?: SquashData;
+    unrelated?: ExternalHead;
+    extensions?: ExtensionDataList;
+    buildStatus?: BuildStatus;
+    componentId?: ComponentID;
+    bitVersion?: string;
+    modified?: Log[];
+    origin?: VersionOrigin;
+    hidden?: boolean;
+};
+/**
+ * Represent a version model in the scope
+ */
+export default class Version extends BitObject {
+    mainFile: PathLinux;
+    files: Array<SourceFileModel>;
+    log: Log;
+    docs: Doclet[] | undefined;
+    dependencies: Dependencies;
+    devDependencies: Dependencies;
+    peerDependencies: Dependencies;
+    flattenedDependencies: ComponentIdList;
+    dependenciesGraphRef?: Ref;
+    _dependenciesGraph?: DependenciesGraph;
+    flattenedEdgesRef?: Ref;
+    _flattenedEdges?: DepEdge[];
+    /**
+     * @deprecated
+     * to get the flattenedEdges, please use `this.getFlattenedEdges()`.
+     * this function handles the backward compatibility and provides the flattened edges regardless whether it was saved
+     * the `flattenedEdgesRef` introduced or after.
+     *
+     * the reason this is left here is not for backward compatibility, but for forward compatibility. meaning, if a
+     * Version object created by the new version is parsed by an old version that doesn't support the flattenedEdgesRef,
+     * then, it'll be able to still get the flattenedEdges by this prop.
+     * this is causing duplication currently. the data is kept in both, `this.flattenedEdges` and the file stored in `flattenedEdgesRef`.
+     * so it'll be best to delete this prop as soon as all scopes are deployed with the new version.
+     * (around August 2023 should be safe)
+     */
+    private flattenedEdges;
+    packageDependencies: {
+        [key: string]: string;
+    };
+    devPackageDependencies: {
+        [key: string]: string;
+    };
+    peerPackageDependencies: {
+        [key: string]: string;
+    };
+    bindingPrefix: string;
+    schema: string | undefined;
+    overrides: ComponentOverridesData;
+    packageJsonChangedProps: Record<string, any>;
+    _hash: string;
+    parents: Ref[];
+    squashed?: SquashData;
+    unrelated?: ExternalHead;
+    extensions: ExtensionDataList;
+    buildStatus?: BuildStatus;
+    componentId?: ComponentID;
+    bitVersion?: string;
+    modified: Log[];
+    origin?: VersionOrigin;
+    hidden?: boolean;
+    constructor(props: VersionProps);
+    /**
+     * use only this method to get the flattened edges (graph of flattened dependencies).
+     * it's backward compatible with the previous way this was stored on the Version object itself.
+     */
+    getFlattenedEdges(repo: Repository): Promise<DepEdge[]>;
+    loadDependenciesGraph(repo: Repository): Promise<DependenciesGraph | undefined>;
+    validateVersion(): void;
+    id(): string;
+    calculateHash(): Ref;
+    hash(): Ref;
+    get extensionDependencies(): Dependencies;
+    lastModified(): string;
+    getAllFlattenedDependencies(): ComponentIdList;
+    getAllDependencies(): Dependency[];
+    get depsIdsGroupedByType(): {
+        dependencies: ComponentIdList;
+        devDependencies: ComponentIdList;
+        peerDependencies: ComponentIdList;
+        extensionDependencies: ComponentIdList;
+    };
+    getAllDependenciesCloned(): Dependencies;
+    getAllDependenciesIds(): ComponentIdList;
+    getDependenciesIdsExcludeExtensions(): ComponentIdList;
+    updateFlattenedDependency(currentId: ComponentID, newId: ComponentID): void;
+    refs(): Ref[];
+    refsWithOptions(includeParents?: boolean, includeArtifacts?: boolean): Ref[];
+    refsWithoutParents(): Ref[];
+    collectManyObjects(repo: Repository, refs: Ref[]): Promise<ObjectItem[]>;
+    static depEdgeToObject(depEdge: DepEdge): Record<string, any>;
+    static depEdgeFromObject(depEdgeObj: Record<string, any>): DepEdge;
+    static depEdgeToArray(depEdge: DepEdge): Record<string, any>;
+    static depEdgeFromArray(depEdgeArr: string[]): DepEdge;
+    static flattenedEdgeToSource(flattenedEdges?: DepEdge[]): Source | undefined;
+    static dependenciesGraphToSource(dependenciesGraph?: DependenciesGraph): Source | undefined;
+    toObject(): import("lodash").Dictionary<string | boolean | string[] | Record<string, any> | Record<string, any>[] | ComponentOverridesData | {
+        extensionId: ComponentID | import("@teambit/component-id").ComponentIdObj | undefined;
+        config: {
+            [key: string]: any;
+        };
+        data: {
+            [key: string]: any;
+        };
+        legacyId: string | undefined;
+        name: string | undefined;
+        newExtensionId: ComponentID | undefined;
+    }[] | {
+        file: any;
+        relativePath: any;
+        name: any;
+        test: any;
+    }[] | Doclet[] | import("@teambit/component-id").ComponentIdObj[] | {
+        [key: string]: string;
+    } | {
+        [key: string]: string;
+    } | {
+        [key: string]: string;
+    } | Log[] | VersionOrigin | {
+        message: string;
+        date: string;
+        username: string | undefined;
+        email: string | undefined;
+        previousParents?: undefined;
+        laneId?: undefined;
+        head?: undefined;
+    } | {
+        previousParents: string[];
+        laneId: {
+            scope: string;
+            name: string;
+        };
+        message?: undefined;
+        date?: undefined;
+        username?: undefined;
+        email?: undefined;
+        head?: undefined;
+    } | {
+        head: string;
+        laneId: {
+            scope: string;
+            name: string;
+        };
+        message?: undefined;
+        date?: undefined;
+        username?: undefined;
+        email?: undefined;
+        previousParents?: undefined;
+    } | null | undefined>;
+    validateBeforePersisting(versionStr: string): void;
+    toBuffer(pretty: boolean): Buffer;
+    /**
+     * used by the super class BitObject
+     */
+    static parse(contents: string, hash: string): Version;
+    /**
+     * used by raw-object.toRealObject()
+     */
+    static from(versionProps: VersionProps, hash: string): Version;
+    /**
+     * Create version model object from consumer component
+     * @param {*} param0
+     */
+    static fromComponent({ component, files, flattenedEdges, dependenciesGraph, }: {
+        component: ConsumerComponent;
+        files: Array<SourceFileModel>;
+        flattenedEdges?: Source;
+        dependenciesGraph?: Source;
+    }): Version;
+    setNewHash(): void;
+    get ignoreSharedDir(): boolean;
+    get isLegacy(): boolean;
+    get originLaneId(): LaneId | undefined;
+    get originId(): ComponentID | undefined;
+    setDist(dist: Source | undefined): void;
+    hasParent(ref: Ref): Ref | undefined;
+    addParent(ref: Ref): void;
+    setSquashed(squashData: SquashData, log: Log, replaceMessage?: string): void;
+    setUnrelated(externalHead: ExternalHead): void;
+    addModifiedLog(log: Log): void;
+    addAsOnlyParent(ref: Ref): void;
+    removeParent(ref: Ref): void;
+    removeAllParents(): void;
+    modelFilesToSourceFiles(repository: Repository): Promise<SourceFile[]>;
+    isRemoved(): boolean;
+    shouldRemoveFromMain(): boolean;
+    /**
+     * Validate the version model properties, to make sure we are not inserting something
+     * in the wrong format
+     */
+    validate(): void;
+}
+export {};