1 | /**
|
2 | * @license
|
3 | * Copyright 2021 Google Inc.
|
4 | *
|
5 | * Permission is hereby granted, free of charge, to any person obtaining a copy
|
6 | * of this software and associated documentation files (the "Software"), to deal
|
7 | * in the Software without restriction, including without limitation the rights
|
8 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
9 | * copies of the Software, and to permit persons to whom the Software is
|
10 | * furnished to do so, subject to the following conditions:
|
11 | *
|
12 | * The above copyright notice and this permission notice shall be included in
|
13 | * all copies or substantial portions of the Software.
|
14 | *
|
15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
18 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
21 | * THE SOFTWARE.
|
22 | */
|
23 | import { __assign, __extends, __read, __spreadArray, __values } from "tslib";
|
24 | /**
|
25 | * Mixin to add `MDCObserver` functionality to an optional base class.
|
26 | *
|
27 | * @deprecated Prefer MDCObserverFoundation for stricter closure compliance.
|
28 | * @template C Optional base class constructor type.
|
29 | * @param baseClass - Optional base class.
|
30 | * @return A class that extends the optional base class with `MDCObserver`
|
31 | * functionality.
|
32 | */
|
33 | export function mdcObserver(baseClass) {
|
34 | if (baseClass === void 0) { baseClass = /** @class */ (function () {
|
35 | function class_1() {
|
36 | }
|
37 | return class_1;
|
38 | }()); }
|
39 | // Mixin classes cannot use private members and Symbol() cannot be used in 3P
|
40 | // for IE11.
|
41 | var unobserveMap = new WeakMap();
|
42 | return /** @class */ (function (_super) {
|
43 | __extends(MDCObserver, _super);
|
44 | function MDCObserver() {
|
45 | return _super !== null && _super.apply(this, arguments) || this;
|
46 | }
|
47 | MDCObserver.prototype.observe = function (target, observers) {
|
48 | var e_1, _a;
|
49 | var _this = this;
|
50 | var cleanup = [];
|
51 | try {
|
52 | for (var _b = __values(Object.keys(observers)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
53 | var property = _c.value;
|
54 | var observer = observers[property].bind(this);
|
55 | cleanup.push(observeProperty(target, property, observer));
|
56 | }
|
57 | }
|
58 | catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
59 | finally {
|
60 | try {
|
61 | if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
62 | }
|
63 | finally { if (e_1) throw e_1.error; }
|
64 | }
|
65 | var unobserve = function () {
|
66 | var e_2, _a;
|
67 | try {
|
68 | for (var cleanup_1 = __values(cleanup), cleanup_1_1 = cleanup_1.next(); !cleanup_1_1.done; cleanup_1_1 = cleanup_1.next()) {
|
69 | var cleanupFn = cleanup_1_1.value;
|
70 | cleanupFn();
|
71 | }
|
72 | }
|
73 | catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
74 | finally {
|
75 | try {
|
76 | if (cleanup_1_1 && !cleanup_1_1.done && (_a = cleanup_1.return)) _a.call(cleanup_1);
|
77 | }
|
78 | finally { if (e_2) throw e_2.error; }
|
79 | }
|
80 | var unobserves = unobserveMap.get(_this) || [];
|
81 | var index = unobserves.indexOf(unobserve);
|
82 | if (index > -1) {
|
83 | unobserves.splice(index, 1);
|
84 | }
|
85 | };
|
86 | var unobserves = unobserveMap.get(this);
|
87 | if (!unobserves) {
|
88 | unobserves = [];
|
89 | unobserveMap.set(this, unobserves);
|
90 | }
|
91 | unobserves.push(unobserve);
|
92 | return unobserve;
|
93 | };
|
94 | MDCObserver.prototype.setObserversEnabled = function (target, enabled) {
|
95 | setObserversEnabled(target, enabled);
|
96 | };
|
97 | MDCObserver.prototype.unobserve = function () {
|
98 | var e_3, _a;
|
99 | // Iterate over a copy since unobserve() will remove themselves from the
|
100 | // array
|
101 | var unobserves = unobserveMap.get(this) || [];
|
102 | try {
|
103 | for (var _b = __values(__spreadArray([], __read(unobserves))), _c = _b.next(); !_c.done; _c = _b.next()) {
|
104 | var unobserve = _c.value;
|
105 | unobserve();
|
106 | }
|
107 | }
|
108 | catch (e_3_1) { e_3 = { error: e_3_1 }; }
|
109 | finally {
|
110 | try {
|
111 | if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
112 | }
|
113 | finally { if (e_3) throw e_3.error; }
|
114 | }
|
115 | };
|
116 | return MDCObserver;
|
117 | }(baseClass));
|
118 | }
|
119 | /**
|
120 | * Observe a target's property for changes. When a property changes, the
|
121 | * provided `Observer` function will be invoked with the properties current and
|
122 | * previous values.
|
123 | *
|
124 | * The returned cleanup function will stop listening to changes for the
|
125 | * provided `Observer`.
|
126 | *
|
127 | * @template T The observed target type.
|
128 | * @template K The observed property.
|
129 | * @param target - The target to observe.
|
130 | * @param property - The property of the target to observe.
|
131 | * @param observer - An observer function to invoke each time the property
|
132 | * changes.
|
133 | * @return A cleanup function that will stop observing changes for the provided
|
134 | * `Observer`.
|
135 | */
|
136 | export function observeProperty(target, property, observer) {
|
137 | var targetObservers = installObserver(target, property);
|
138 | var observers = targetObservers.getObservers(property);
|
139 | observers.push(observer);
|
140 | return function () {
|
141 | observers.splice(observers.indexOf(observer), 1);
|
142 | };
|
143 | }
|
144 | /**
|
145 | * A Map of all `TargetObservers` that have been installed.
|
146 | */
|
147 | var allTargetObservers = new WeakMap();
|
148 | /**
|
149 | * Installs a `TargetObservers` for the provided target (if not already
|
150 | * installed), and replaces the given property with a getter and setter that
|
151 | * will respond to changes and call `TargetObservers`.
|
152 | *
|
153 | * Subsequent calls to `installObserver()` with the same target and property
|
154 | * will not override the property's previously installed getter/setter.
|
155 | *
|
156 | * @template T The observed target type.
|
157 | * @template K The observed property to create a getter/setter for.
|
158 | * @param target - The target to observe.
|
159 | * @param property - The property to create a getter/setter for, if needed.
|
160 | * @return The installed `TargetObservers` for the provided target.
|
161 | */
|
162 | function installObserver(target, property) {
|
163 | var observersMap = new Map();
|
164 | if (!allTargetObservers.has(target)) {
|
165 | allTargetObservers.set(target, {
|
166 | isEnabled: true,
|
167 | getObservers: function (key) {
|
168 | var observers = observersMap.get(key) || [];
|
169 | if (!observersMap.has(key)) {
|
170 | observersMap.set(key, observers);
|
171 | }
|
172 | return observers;
|
173 | },
|
174 | installedProperties: new Set()
|
175 | });
|
176 | }
|
177 | var targetObservers = allTargetObservers.get(target);
|
178 | if (targetObservers.installedProperties.has(property)) {
|
179 | // The getter/setter has already been replaced for this property
|
180 | return targetObservers;
|
181 | }
|
182 | // Retrieve (or create if it's a plain property) the original descriptor from
|
183 | // the target...
|
184 | var descriptor = getDescriptor(target, property) || {
|
185 | configurable: true,
|
186 | enumerable: true,
|
187 | value: target[property],
|
188 | writable: true
|
189 | };
|
190 | // ...and create a copy that will be used for the observer.
|
191 | var observedDescriptor = __assign({}, descriptor);
|
192 | var descGet = descriptor.get, descSet = descriptor.set;
|
193 | if ('value' in descriptor) {
|
194 | // The descriptor is a simple value (not a getter/setter).
|
195 | // For our observer descriptor that we copied, delete the value/writable
|
196 | // properties, since they are incompatible with the get/set properties
|
197 | // for descriptors.
|
198 | delete observedDescriptor.value;
|
199 | delete observedDescriptor.writable;
|
200 | // Set up a simple getter...
|
201 | var value_1 = descriptor.value;
|
202 | descGet = function () { return value_1; };
|
203 | // ...and setter (if the original property was writable).
|
204 | if (descriptor.writable) {
|
205 | descSet = function (newValue) {
|
206 | value_1 = newValue;
|
207 | };
|
208 | }
|
209 | }
|
210 | if (descGet) {
|
211 | observedDescriptor.get = function () {
|
212 | // `this as T` needed for closure conformance
|
213 | return descGet.call(this);
|
214 | };
|
215 | }
|
216 | if (descSet) {
|
217 | observedDescriptor.set = function (newValue) {
|
218 | var e_4, _a;
|
219 | // `thus as T` needed for closure conformance
|
220 | var previous = descGet ? descGet.call(this) : newValue;
|
221 | descSet.call(this, newValue);
|
222 | if (targetObservers.isEnabled && (!descGet || newValue !== previous)) {
|
223 | try {
|
224 | for (var _b = __values(targetObservers.getObservers(property)), _c = _b.next(); !_c.done; _c = _b.next()) {
|
225 | var observer = _c.value;
|
226 | observer(newValue, previous);
|
227 | }
|
228 | }
|
229 | catch (e_4_1) { e_4 = { error: e_4_1 }; }
|
230 | finally {
|
231 | try {
|
232 | if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
233 | }
|
234 | finally { if (e_4) throw e_4.error; }
|
235 | }
|
236 | }
|
237 | };
|
238 | }
|
239 | targetObservers.installedProperties.add(property);
|
240 | Object.defineProperty(target, property, observedDescriptor);
|
241 | return targetObservers;
|
242 | }
|
243 | /**
|
244 | * Retrieves the descriptor for a property from the provided target. This
|
245 | * function will walk up the target's prototype chain to search for the
|
246 | * descriptor.
|
247 | *
|
248 | * @template T The target type.
|
249 | * @template K The property type.
|
250 | * @param target - The target to retrieve a descriptor from.
|
251 | * @param property - The name of the property to retrieve a descriptor for.
|
252 | * @return the descriptor, or undefined if it does not exist. Keep in mind that
|
253 | * plain properties may not have a descriptor defined.
|
254 | */
|
255 | export function getDescriptor(target, property) {
|
256 | var descriptorTarget = target;
|
257 | var descriptor;
|
258 | while (descriptorTarget) {
|
259 | descriptor = Object.getOwnPropertyDescriptor(descriptorTarget, property);
|
260 | if (descriptor) {
|
261 | break;
|
262 | }
|
263 | // Walk up the instance's prototype chain in case the property is declared
|
264 | // on a superclass.
|
265 | descriptorTarget = Object.getPrototypeOf(descriptorTarget);
|
266 | }
|
267 | return descriptor;
|
268 | }
|
269 | /**
|
270 | * Enables or disables all observers for a provided target. Changes to observed
|
271 | * properties will not call any observers when disabled.
|
272 | *
|
273 | * @template T The observed target type.
|
274 | * @param target - The target to enable or disable observers for.
|
275 | * @param enabled - True to enable or false to disable observers.
|
276 | */
|
277 | export function setObserversEnabled(target, enabled) {
|
278 | var targetObservers = allTargetObservers.get(target);
|
279 | if (targetObservers) {
|
280 | targetObservers.isEnabled = enabled;
|
281 | }
|
282 | }
|
283 | //# sourceMappingURL=observer.js.map |
\ | No newline at end of file |