@alauda-fe/common
Version:
Alauda frontend team common codes.
61 lines • 9.23 kB
JavaScript
import { uniq } from 'lodash-es';
import { distinctUntilChanged, map, merge, startWith, takeUntil, } from 'rxjs';
/**
* @description
* 创建集群中存在大量的 control 依赖的情形，同时，由于业务特殊性，在 ipv4,ipv6 时要对表单控件进行不同外观的展示，因此控件的 disabled 变得很复杂
* 如果是在 ts 里通过 valueChanges 写：每个影响源都要写自己的 subscription，且某个 control 可能会收到多个其他 control 影响，届时逻辑组织会复杂很多,
* 如果是在模板里通过 aluControlDisabled 去写，可能会存在多个 control 要重复同一套逻辑，这点在创建集群中很常见，因此提供了如下方案，可以以声明式写法去描述依赖关系
*
* @usageNotes
* For example, for the following `FormGroup`:
* ```
* [
{
source: 'joinCIDR',
deps: ['networkType'],
isEnable: networkType => networkType === 'kube-ovn',
},
{
source: 'gatewayIPv6',
deps: ['networkType', 'transmitType', 'ipv6DualStack'],
isEnable: (networkType, transmitType, ipv6DualStack: boolean) =>
networkType === 'kube-ovn' &&
transmitType === 'underlay' &&
ipv6DualStack,
},
{
source: ['clusterCIDRIPv6', 'serviceCIDRIPv6'],
deps: ['ipv6DualStack'],
isEnable: (ipv6DualStack: boolean) => ipv6DualStack,
},
]
* ```
*/
export function genControlDepsMap(context, rules, destroy$) {
const normRules = rules.flatMap(r => Array.isArray(r.source) ? r.source.map(s => ({ ...r, source: s })) : r);
const depPaths = uniq(normRules.flatMap(r => r.deps));
const depRuleMap = normRules.reduce((acc, rule) => {
for (const dep of rule.deps) {
if (!acc[dep]) {
acc[dep] = new Set();
}
acc[dep].add(rule.source);
}
return acc;
}, {});
// 每一次 deps 中的 valueChange 都有可能是一次 trigger
merge(...depPaths.map(p => context.get(p).valueChanges.pipe(startWith(context.get(p).value), distinctUntilChanged(), map(value => ({
key: p,
value,
})))))
.pipe(takeUntil(destroy$))
.subscribe(result => {
depRuleMap[result.key].forEach(source => {
const rules = normRules.filter(r => r.source === source);
const enable = rules.every(rule => rule.isEnable(...rule.deps.map(dep => context.get(dep).value)));
context
.get(source)[enable ? 'enable' : 'disable']({ emitEvent: false }); // emitEvent: false 会防止主动将本控件设为dirty
});
});
}
//# sourceMappingURL=data:application/json;base64,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