1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
|
import { inject, injectable } from 'inversify';
import { ServiceIdentifiers } from '../container/ServiceIdentifiers';
import { TDictionary } from '../types/TDictionary';
import { TTransformersRelationEdge } from '../types/utils/TTransformersRelationEdge';
import { ILevelledTopologicalSorter } from '../interfaces/utils/ILevelledTopologicalSorter';
import { ITransformer } from '../interfaces/ITransformer';
import { ITransformerNamesGroupsBuilder } from '../interfaces/utils/ITransformerNamesGroupsBuilder';
@injectable()
export abstract class AbstractTransformerNamesGroupsBuilder <
TTransformerName extends string,
TTransformer extends ITransformer<TTransformerName>
> implements ITransformerNamesGroupsBuilder <
TTransformerName,
TTransformer
> {
/**
* @type {ILevelledTopologicalSorter<TTransformerName>}
*/
private readonly levelledTopologicalSorter: ILevelledTopologicalSorter<TTransformerName>;
public constructor (
@inject(ServiceIdentifiers.ILevelledTopologicalSorter)
levelledTopologicalSorter: ILevelledTopologicalSorter<TTransformerName>
) {
this.levelledTopologicalSorter = levelledTopologicalSorter;
}
/**
* Builds sorted transformer names by topological sort with levels
*
* For example, if SplitString transformer has following dependencies inside `runAfter` property:
* - NodeTransformer.ObjectExpressionKeysTransformer,
* - NodeTransformer.TemplateLiteralTransformer
*
* Than result node transformer names groups will be like:
* [
* [
* SomeTransformerA,
* ObjectExpressionKeysTransformer,
* TemplateLiteralTransformer,
* SomeTransformerB
* ],
* [
* SplitStringTransformer
* ]
* ]
*
* @param {TDictionary<TTransformer>} normalizedTransformers
* @returns {TTransformerName[][]}
*/
public build (normalizedTransformers: TDictionary<TTransformer>): TTransformerName[][] {
const transformerNames: TTransformerName[] = <TTransformerName[]>Object.keys(normalizedTransformers);
const relationEdges: TTransformersRelationEdge<TTransformerName>[] = this.buildTransformersRelationEdges(
transformerNames,
normalizedTransformers
);
for (const [precedent, consequent] of relationEdges) {
this.levelledTopologicalSorter.add(precedent, consequent);
}
return this.levelledTopologicalSorter.sortByGroups();
}
/**
* @param {TTransformerName[]} transformerNames
* @param {TDictionary<TTransformer>} normalizedTransformers
* @returns {TTransformersRelationEdge<TTransformerName>[]}
*/
private buildTransformersRelationEdges (
transformerNames: TTransformerName[],
normalizedTransformers: TDictionary<TTransformer>
): TTransformersRelationEdge<TTransformerName>[] {
const relationEdges: TTransformersRelationEdge<TTransformerName>[] = [];
for (const transformerName of transformerNames) {
const transformer: TTransformer = normalizedTransformers[transformerName];
const runAfterRelations: TTransformerName[] | undefined = transformer.runAfter;
if (!runAfterRelations || !runAfterRelations.length) {
relationEdges.push([transformerName, null]);
continue;
}
for (const runAfterRelation of runAfterRelations) {
const isUnknownRelation: boolean = normalizedTransformers[runAfterRelation] === undefined;
if (isUnknownRelation) {
relationEdges.push([transformerName, null]);
continue;
}
relationEdges.push([runAfterRelation, transformerName]);
}
}
return relationEdges;
}
}
|
