template?: TemplateName | Template;

orientation?: Orientation;

reverseArrow?: boolean;

initCommitOffsetX?: number;

initCommitOffsetY?: number;

mode?: Mode;

author?: string;

branchLabelOnEveryCommit?: boolean;

commitMessage?: string;

generateCommitHash?: () => Commit["hash"];

compareBranchesOrder?: CompareBranchesOrder;

commits: Array<Commit<TNode>>;

branchesPaths: BranchesPaths<TNode>;

commitMessagesX: number;

public orientation?: Orientation;

public get isHorizontal(): boolean {

return (

this.orientation === Orientation.Horizontal ||

this.orientation === Orientation.HorizontalReverse

);

}

public get isVertical(): boolean {

return !this.isHorizontal;

}

public get isReverse(): boolean {

return (

this.orientation === Orientation.HorizontalReverse ||

this.orientation === Orientation.VerticalReverse

);

}

public get shouldDisplayCommitMessage(): boolean {

return !this.isHorizontal && this.mode !== Mode.Compact;

}

public reverseArrow: boolean;

public initCommitOffsetX: number;

public initCommitOffsetY: number;

public mode?: Mode;

public author: string;

public commitMessage: string;

public generateCommitHash: () => Commit["hash"] | undefined;

public branchesOrderFunction: CompareBranchesOrder | undefined;

public template: Template;

public branchLabelOnEveryCommit: boolean;

public refs = new Refs();

public tags = new Refs();

public tagStyles: { [name: string]: TemplateOptions["tag"] } = {};

public tagRenders: {

[name: string]: GitgraphTagOptions<TNode>["render"];

} = {};

public commits: Array<Commit<TNode>> = [];

public branches: Map<Branch["name"], Branch<TNode>> = new Map();

public currentBranch: Branch<TNode>;

private listeners: Array<(data: RenderedData<TNode>) => void> = [];

private nextTimeoutId: number | null = null;

constructor(options: GitgraphOptions = {}) {

this.template = getTemplate(options.template);

// Set a default `master` branch

this.currentBranch = this.createBranch("master");

// Set all options with default values

this.orientation = options.orientation;

this.reverseArrow = booleanOptionOr(options.reverseArrow, false);

this.initCommitOffsetX = numberOptionOr(options.initCommitOffsetX, 0);

this.initCommitOffsetY = numberOptionOr(options.initCommitOffsetY, 0);

this.mode = options.mode;

this.author = options.author || "Sergio Flores <saxo-guy@epic.com>";

this.commitMessage =

options.commitMessage || "He doesn't like George Michael! Boooo!";

this.generateCommitHash =

typeof options.generateCommitHash === "function"

? options.generateCommitHash

: () => undefined;

this.branchesOrderFunction =

typeof options.compareBranchesOrder === "function"

? options.compareBranchesOrder

: undefined;

this.branchLabelOnEveryCommit = booleanOptionOr(

options.branchLabelOnEveryCommit,

false,

);

}

/**

public getUserApi(): GitgraphUserApi<TNode> {

return new GitgraphUserApi(this, () => this.next());

}

/**

public subscribe(listener: (data: RenderedData<TNode>) => void): () => void {

this.listeners.push(listener);

let isSubscribed = true;

return () => {

if (!isSubscribed) return;

isSubscribed = false;

const index = this.listeners.indexOf(listener);

this.listeners.splice(index, 1);

};

}

/**

public getRenderedData(): RenderedData<TNode> {

const commits = this.computeRenderedCommits();

const branchesPaths = this.computeRenderedBranchesPaths(commits);

const commitMessagesX = this.computeCommitMessagesX(branchesPaths);

this.computeBranchesColor(commits, branchesPaths);

return { commits, branchesPaths, commitMessagesX };

}

/**

public createBranch(options: GitgraphBranchOptions<TNode>): Branch<TNode>;

/**

public createBranch(name: string): Branch<TNode>;

public createBranch(args: any): Branch<TNode> {

const defaultParentBranchName = "HEAD";

let options = {

gitgraph: this,

name: "",

parentCommitHash: this.refs.getCommit(defaultParentBranchName),

style: this.template.branch,

onGraphUpdate: () => this.next(),

};

if (typeof args === "string") {

options.name = args;

options.parentCommitHash = this.refs.getCommit(defaultParentBranchName);

} else {

const parentBranchName = args.from

? args.from.name

: defaultParentBranchName;

const parentCommitHash =

this.refs.getCommit(parentBranchName) ||

(this.refs.hasCommit(args.from) ? args.from : undefined);

args.style = args.style || {};

options = {

...options,

...args,

parentCommitHash,

style: {

...options.style,

...args.style,

label: {

...options.style.label,

...args.style.label,

},

},

};

}

const branch = new Branch<TNode>(options);

this.branches.set(branch.name, branch);

return branch;

}

/**

private computeRenderedCommits(): Array<Commit<TNode>> {

const branches = this.getBranches();

// Commits that are not associated to a branch in `branches`

// were in a deleted branch. If the latter was merged beforehand

// they are reachable and are rendered. Others are not

const reachableUnassociatedCommits = (() => {

const unassociatedCommits = new Set(

this.commits.reduce(

(commits: Commit["hash"][], { hash }: { hash: Commit["hash"] }) =>

!branches.has(hash) ? [...commits, hash] : commits,

[],

),

);

const tipsOfMergedBranches = this.commits.reduce(

(tipsOfMergedBranches: Commit<TNode>[], commit: Commit<TNode>) =>

commit.parents.length > 1

? [

...tipsOfMergedBranches,

...commit.parents

.slice(1)

.map(

(parentHash) =>

this.commits.find(({ hash }) => parentHash === hash)!,

),

]

: tipsOfMergedBranches,

[],

);

const reachableCommits = new Set();

tipsOfMergedBranches.forEach((tip) => {

let currentCommit: Commit<TNode> | undefined = tip;

while (currentCommit && unassociatedCommits.has(currentCommit.hash)) {

reachableCommits.add(currentCommit.hash);

currentCommit =

currentCommit.parents.length > 0

? this.commits.find(

({ hash }) => currentCommit!.parents[0] === hash,

)

: undefined;

}

});

return reachableCommits;

})();

const commitsToRender = this.commits.filter(

({ hash }) =>

branches.has(hash) || reachableUnassociatedCommits.has(hash),

);

const commitsWithBranches = commitsToRender.map((commit) =>

this.withBranches(branches, commit),

);

const rows = createGraphRows(this.mode, commitsToRender);

const branchesOrder = new BranchesOrder<TNode>(

commitsWithBranches,

this.template.colors,

this.branchesOrderFunction,

);

return (

commitsWithBranches

.map((commit) => commit.setRefs(this.refs))

.map((commit) => this.withPosition(rows, branchesOrder, commit))

// Fallback commit computed color on branch color.

.map((commit) =>

commit.withDefaultColor(

this.getBranchDefaultColor(branchesOrder, commit.branchToDisplay),

),

)

// Tags need commit style to be computed (with default color).

.map((commit) =>

commit.setTags(

this.tags,

(name) =>

Object.assign({}, this.tagStyles[name], this.template.tag),

(name) => this.tagRenders[name],

),

)

);

}

/**

private computeRenderedBranchesPaths(

commits: Array<Commit<TNode>>,

): BranchesPaths<TNode> {

return new BranchesPathsCalculator<TNode>(

commits,

this.branches,

this.template.commit.spacing,

this.isVertical,

this.isReverse,

() => createDeletedBranch(this, this.template.branch, () => this.next()),

).execute();

}

/**

private computeBranchesColor(

commits: Array<Commit<TNode>>,

branchesPaths: BranchesPaths<TNode>,

): void {

const branchesOrder = new BranchesOrder<TNode>(

commits,

this.template.colors,

this.branchesOrderFunction,

);

Array.from(branchesPaths).forEach(([branch]) => {

branch.computedColor =

branch.style.color ||

this.getBranchDefaultColor(branchesOrder, branch.name);

});

}

/**

private computeCommitMessagesX(branchesPaths: BranchesPaths<TNode>): number {

const numberOfColumns = Array.from(branchesPaths).length;

return numberOfColumns * this.template.branch.spacing;

}

/**

private withBranches(

branches: Map<Commit["hash"], Set<Branch["name"]>>,

commit: Commit<TNode>,

): Commit<TNode> {

let commitBranches = Array.from(

(branches.get(commit.hash) || new Set()).values(),

);

if (commitBranches.length === 0) {

// No branch => branch has been deleted.

commitBranches = [DELETED_BRANCH_NAME];

}

return commit.setBranches(commitBranches);

}

/**

private getBranches(): Map<Commit["hash"], Set<Branch["name"]>> {

const result = new Map<Commit["hash"], Set<Branch["name"]>>();

const queue: Array<Commit["hash"]> = [];

const branches = this.refs.getAllNames().filter((name) => name !== "HEAD");

branches.forEach((branch) => {

const commitHash = this.refs.getCommit(branch);

if (commitHash) {

queue.push(commitHash);

}

while (queue.length > 0) {

const currentHash = queue.pop() as Commit["hash"];

const current = this.commits.find(

({ hash }) => hash === currentHash,

) as Commit<TNode> | null;

const prevBranches =

result.get(currentHash) || new Set<Branch["name"]>();

prevBranches.add(branch);

result.set(currentHash, prevBranches);

if (current && current.parents && current.parents.length > 0) {

queue.push(current.parents[0]);

}

}

});

return result;

}

/**

private withPosition(

rows: GraphRows<TNode>,

branchesOrder: BranchesOrder<TNode>,

commit: Commit<TNode>,

): Commit<TNode> {

const row = rows.getRowOf(commit.hash);

const maxRow = rows.getMaxRow();

const order = branchesOrder.get(commit.branchToDisplay);

switch (this.orientation) {

default:

return commit.setPosition({

x: this.initCommitOffsetX + this.template.branch.spacing * order,

y:

this.initCommitOffsetY +

this.template.commit.spacing * (maxRow - row),

});

case Orientation.VerticalReverse:

return commit.setPosition({

x: this.initCommitOffsetX + this.template.branch.spacing * order,

y: this.initCommitOffsetY + this.template.commit.spacing * row,

});

case Orientation.Horizontal:

return commit.setPosition({

x: this.initCommitOffsetX + this.template.commit.spacing * row,

y: this.initCommitOffsetY + this.template.branch.spacing * order,

});

case Orientation.HorizontalReverse:

return commit.setPosition({

x:

this.initCommitOffsetX +

this.template.commit.spacing * (maxRow - row),

y: this.initCommitOffsetY + this.template.branch.spacing * order,

});

}

}

/**

private getBranchDefaultColor(

branchesOrder: BranchesOrder<TNode>,

branchName: Branch["name"],

): string {

return branchesOrder.getColorOf(branchName);

}

/**

private next() {

if (this.nextTimeoutId) {

window.clearTimeout(this.nextTimeoutId);

}

// Use setTimeout() with `0` to debounce call to next tick.

this.nextTimeoutId = window.setTimeout(() => {

this.listeners.forEach((listener) => listener(this.getRenderedData()));

}, 0);

}