/
RulesetManager.ts
132 lines (114 loc) · 3.56 KB
/
RulesetManager.ts
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
/*---------------------------------------------------------------------------------------------
* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
* See LICENSE.md in the project root for license terms and full copyright notice.
*--------------------------------------------------------------------------------------------*/
/** @packageDocumentation
* @module Core
*/
import { BeEvent, Guid } from "@itwin/core-bentley";
import { RegisteredRuleset, Ruleset } from "@itwin/presentation-common";
/**
* Presentation ruleset registry.
* @public
*/
export interface RulesetManager {
/**
* An event invoked one a ruleset is modified using [[modify]] function.
* @beta
*/
onRulesetModified: BeEvent<(curr: RegisteredRuleset, prev: Ruleset) => void>;
/**
* Get a ruleset with the specified id.
*/
get(id: string): Promise<RegisteredRuleset | undefined>;
/**
* Register the supplied ruleset
*/
add(ruleset: Ruleset): Promise<RegisteredRuleset>;
/**
* Modify the given pre-registered ruleset
* @beta
*/
modify(ruleset: RegisteredRuleset, newRules: Omit<Ruleset, "id">): Promise<RegisteredRuleset>;
/**
* Unregister the supplied ruleset
*/
remove(ruleset: RegisteredRuleset | [string, string]): Promise<boolean>;
/**
* Remove all rulesets registered in this session.
*/
clear(): Promise<void>;
}
/** @internal */
export class RulesetManagerImpl implements RulesetManager {
private _clientRulesets = new Map<string, RegisteredRuleset[]>();
public onRulesetModified = new BeEvent<(curr: RegisteredRuleset, prev: Ruleset) => void>();
public static create() {
return new RulesetManagerImpl();
}
/**
* Get a ruleset with the specified id.
*/
public async get(id: string): Promise<RegisteredRuleset | undefined> {
const m = this._clientRulesets.get(id);
if (!m) {
return undefined;
}
return m[0];
}
/**
* Register the supplied ruleset
*/
public async add(ruleset: Ruleset): Promise<RegisteredRuleset> {
const registered = new RegisteredRuleset(ruleset, Guid.createValue(), async (r: RegisteredRuleset) => this.remove(r));
if (!this._clientRulesets.has(ruleset.id)) {
this._clientRulesets.set(ruleset.id, []);
}
this._clientRulesets.get(ruleset.id)!.push(registered);
return registered;
}
/**
* Modifies the given pre-registered ruleset
*/
public async modify(ruleset: RegisteredRuleset, newRules: Omit<Ruleset, "id">): Promise<RegisteredRuleset> {
await this.remove(ruleset);
const modified = await this.add({ ...newRules, id: ruleset.id });
this.onRulesetModified.raiseEvent(modified, ruleset.toJSON());
return modified;
}
/**
* Unregister the supplied ruleset
*/
public async remove(ruleset: RegisteredRuleset | [string, string]): Promise<boolean> {
let rulesetId, uniqueIdentifier: string;
if (Array.isArray(ruleset)) {
rulesetId = ruleset[0];
uniqueIdentifier = ruleset[1];
} else {
rulesetId = ruleset.id;
uniqueIdentifier = ruleset.uniqueIdentifier;
}
const m = this._clientRulesets.get(rulesetId);
if (!m) {
return false;
}
let didRemove = false;
for (let i = 0; i < m.length; ++i) {
if (m[i].uniqueIdentifier === uniqueIdentifier) {
m.splice(i, 1);
didRemove = true;
break;
}
}
return didRemove;
}
/**
* Remove all rulesets registered in this session.
*/
public async clear(): Promise<void> {
if (0 === this._clientRulesets.size) {
return;
}
this._clientRulesets.clear();
}
}