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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
"use strict";
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.applyToSubtree = exports.composeFileOperators = exports.forEach = exports.partitionApplyMerge = exports.when = exports.branchAndMerge = exports.asSource = exports.filter = exports.noop = exports.mergeWith = exports.apply = exports.chain = exports.empty = exports.source = void 0;
const rxjs_1 = require("rxjs");
const operators_1 = require("rxjs/operators");
const exception_1 = require("../exception/exception");
const host_tree_1 = require("../tree/host-tree");
const interface_1 = require("../tree/interface");
const scoped_1 = require("../tree/scoped");
const static_1 = require("../tree/static");
const call_1 = require("./call");
/**
* A Source that returns an tree as its single value.
*/
function source(tree) {
return () => tree;
}
exports.source = source;
/**
* A source that returns an empty tree.
*/
function empty() {
return () => (0, static_1.empty)();
}
exports.empty = empty;
/**
* Chain multiple rules into a single rule.
*/
function chain(rules) {
return (tree, context) => {
return rules.reduce((acc, curr) => (0, call_1.callRule)(curr, acc, context), tree);
};
}
exports.chain = chain;
/**
* Apply multiple rules to a source, and returns the source transformed.
*/
function apply(source, rules) {
return (context) => (0, call_1.callRule)(chain(rules), (0, call_1.callSource)(source, context), context);
}
exports.apply = apply;
/**
* Merge an input tree with the source passed in.
*/
function mergeWith(source, strategy = interface_1.MergeStrategy.Default) {
return (tree, context) => {
return (0, call_1.callSource)(source, context).pipe((0, operators_1.map)((sourceTree) => tree.merge(sourceTree, strategy || context.strategy)), (0, operators_1.mapTo)(tree));
};
}
exports.mergeWith = mergeWith;
function noop() {
return () => { };
}
exports.noop = noop;
function filter(predicate) {
return (tree) => {
if (host_tree_1.HostTree.isHostTree(tree)) {
return new host_tree_1.FilterHostTree(tree, predicate);
}
else {
throw new exception_1.SchematicsException('Tree type is not supported.');
}
};
}
exports.filter = filter;
function asSource(rule) {
return (context) => (0, call_1.callRule)(rule, (0, static_1.empty)(), context);
}
exports.asSource = asSource;
function branchAndMerge(rule, strategy = interface_1.MergeStrategy.Default) {
return (tree, context) => {
return (0, call_1.callRule)(rule, tree.branch(), context).pipe((0, operators_1.map)((branch) => tree.merge(branch, strategy || context.strategy)), (0, operators_1.mapTo)(tree));
};
}
exports.branchAndMerge = branchAndMerge;
function when(predicate, operator) {
return (entry) => {
if (predicate(entry.path, entry)) {
return operator(entry);
}
else {
return entry;
}
};
}
exports.when = when;
function partitionApplyMerge(predicate, ruleYes, ruleNo) {
return (tree, context) => {
const [yes, no] = (0, static_1.partition)(tree, predicate);
return (0, rxjs_1.concat)((0, call_1.callRule)(ruleYes, yes, context), (0, call_1.callRule)(ruleNo || noop(), no, context)).pipe((0, operators_1.toArray)(), (0, operators_1.map)(([yesTree, noTree]) => {
yesTree.merge(noTree, context.strategy);
return yesTree;
}));
};
}
exports.partitionApplyMerge = partitionApplyMerge;
function forEach(operator) {
return (tree) => {
tree.visit((path, entry) => {
if (!entry) {
return;
}
const newEntry = operator(entry);
if (newEntry === entry) {
return;
}
if (newEntry === null) {
tree.delete(path);
return;
}
if (newEntry.path != path) {
tree.rename(path, newEntry.path);
}
if (!newEntry.content.equals(entry.content)) {
tree.overwrite(newEntry.path, newEntry.content);
}
});
};
}
exports.forEach = forEach;
function composeFileOperators(operators) {
return (entry) => {
let current = entry;
for (const op of operators) {
current = op(current);
if (current === null) {
// Deleted, just return.
return null;
}
}
return current;
};
}
exports.composeFileOperators = composeFileOperators;
function applyToSubtree(path, rules) {
return (tree, context) => {
const scoped = new scoped_1.ScopedTree(tree, path);
return (0, call_1.callRule)(chain(rules), scoped, context).pipe((0, operators_1.map)((result) => {
if (result === scoped) {
return tree;
}
else {
throw new exception_1.SchematicsException('Original tree must be returned from all rules when using "applyToSubtree".');
}
}));
};
}
exports.applyToSubtree = applyToSubtree;
|
