source: trip-planner-front/node_modules/@angular/material/bundles/material-tree.umd.js@ 188ee53

Last change on this file since 188ee53 was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit
  • Property mode set to 100644
File size: 36.7 KB
Line 
1(function (global, factory) {
2 typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/cdk/tree'), require('@angular/core'), require('@angular/material/core'), require('@angular/cdk/coercion'), require('@angular/cdk/collections'), require('rxjs'), require('rxjs/operators')) :
3 typeof define === 'function' && define.amd ? define('@angular/material/tree', ['exports', '@angular/cdk/tree', '@angular/core', '@angular/material/core', '@angular/cdk/coercion', '@angular/cdk/collections', 'rxjs', 'rxjs/operators'], factory) :
4 (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.ng = global.ng || {}, global.ng.material = global.ng.material || {}, global.ng.material.tree = {}), global.ng.cdk.tree, global.ng.core, global.ng.material.core, global.ng.cdk.coercion, global.ng.cdk.collections, global.rxjs, global.rxjs.operators));
5}(this, (function (exports, tree, core$1, core, coercion, collections, rxjs, operators) { 'use strict';
6
7 /*! *****************************************************************************
8 Copyright (c) Microsoft Corporation.
9
10 Permission to use, copy, modify, and/or distribute this software for any
11 purpose with or without fee is hereby granted.
12
13 THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
14 REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
15 AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
16 INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
17 LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
18 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
19 PERFORMANCE OF THIS SOFTWARE.
20 ***************************************************************************** */
21 /* global Reflect, Promise */
22 var extendStatics = function (d, b) {
23 extendStatics = Object.setPrototypeOf ||
24 ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
25 function (d, b) { for (var p in b)
26 if (Object.prototype.hasOwnProperty.call(b, p))
27 d[p] = b[p]; };
28 return extendStatics(d, b);
29 };
30 function __extends(d, b) {
31 if (typeof b !== "function" && b !== null)
32 throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
33 extendStatics(d, b);
34 function __() { this.constructor = d; }
35 d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
36 }
37 var __assign = function () {
38 __assign = Object.assign || function __assign(t) {
39 for (var s, i = 1, n = arguments.length; i < n; i++) {
40 s = arguments[i];
41 for (var p in s)
42 if (Object.prototype.hasOwnProperty.call(s, p))
43 t[p] = s[p];
44 }
45 return t;
46 };
47 return __assign.apply(this, arguments);
48 };
49 function __rest(s, e) {
50 var t = {};
51 for (var p in s)
52 if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
53 t[p] = s[p];
54 if (s != null && typeof Object.getOwnPropertySymbols === "function")
55 for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
56 if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
57 t[p[i]] = s[p[i]];
58 }
59 return t;
60 }
61 function __decorate(decorators, target, key, desc) {
62 var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
63 if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
64 r = Reflect.decorate(decorators, target, key, desc);
65 else
66 for (var i = decorators.length - 1; i >= 0; i--)
67 if (d = decorators[i])
68 r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
69 return c > 3 && r && Object.defineProperty(target, key, r), r;
70 }
71 function __param(paramIndex, decorator) {
72 return function (target, key) { decorator(target, key, paramIndex); };
73 }
74 function __metadata(metadataKey, metadataValue) {
75 if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
76 return Reflect.metadata(metadataKey, metadataValue);
77 }
78 function __awaiter(thisArg, _arguments, P, generator) {
79 function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
80 return new (P || (P = Promise))(function (resolve, reject) {
81 function fulfilled(value) { try {
82 step(generator.next(value));
83 }
84 catch (e) {
85 reject(e);
86 } }
87 function rejected(value) { try {
88 step(generator["throw"](value));
89 }
90 catch (e) {
91 reject(e);
92 } }
93 function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
94 step((generator = generator.apply(thisArg, _arguments || [])).next());
95 });
96 }
97 function __generator(thisArg, body) {
98 var _ = { label: 0, sent: function () { if (t[0] & 1)
99 throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
100 return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
101 function verb(n) { return function (v) { return step([n, v]); }; }
102 function step(op) {
103 if (f)
104 throw new TypeError("Generator is already executing.");
105 while (_)
106 try {
107 if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
108 return t;
109 if (y = 0, t)
110 op = [op[0] & 2, t.value];
111 switch (op[0]) {
112 case 0:
113 case 1:
114 t = op;
115 break;
116 case 4:
117 _.label++;
118 return { value: op[1], done: false };
119 case 5:
120 _.label++;
121 y = op[1];
122 op = [0];
123 continue;
124 case 7:
125 op = _.ops.pop();
126 _.trys.pop();
127 continue;
128 default:
129 if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
130 _ = 0;
131 continue;
132 }
133 if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
134 _.label = op[1];
135 break;
136 }
137 if (op[0] === 6 && _.label < t[1]) {
138 _.label = t[1];
139 t = op;
140 break;
141 }
142 if (t && _.label < t[2]) {
143 _.label = t[2];
144 _.ops.push(op);
145 break;
146 }
147 if (t[2])
148 _.ops.pop();
149 _.trys.pop();
150 continue;
151 }
152 op = body.call(thisArg, _);
153 }
154 catch (e) {
155 op = [6, e];
156 y = 0;
157 }
158 finally {
159 f = t = 0;
160 }
161 if (op[0] & 5)
162 throw op[1];
163 return { value: op[0] ? op[1] : void 0, done: true };
164 }
165 }
166 var __createBinding = Object.create ? (function (o, m, k, k2) {
167 if (k2 === undefined)
168 k2 = k;
169 Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
170 }) : (function (o, m, k, k2) {
171 if (k2 === undefined)
172 k2 = k;
173 o[k2] = m[k];
174 });
175 function __exportStar(m, o) {
176 for (var p in m)
177 if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
178 __createBinding(o, m, p);
179 }
180 function __values(o) {
181 var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
182 if (m)
183 return m.call(o);
184 if (o && typeof o.length === "number")
185 return {
186 next: function () {
187 if (o && i >= o.length)
188 o = void 0;
189 return { value: o && o[i++], done: !o };
190 }
191 };
192 throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
193 }
194 function __read(o, n) {
195 var m = typeof Symbol === "function" && o[Symbol.iterator];
196 if (!m)
197 return o;
198 var i = m.call(o), r, ar = [], e;
199 try {
200 while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
201 ar.push(r.value);
202 }
203 catch (error) {
204 e = { error: error };
205 }
206 finally {
207 try {
208 if (r && !r.done && (m = i["return"]))
209 m.call(i);
210 }
211 finally {
212 if (e)
213 throw e.error;
214 }
215 }
216 return ar;
217 }
218 /** @deprecated */
219 function __spread() {
220 for (var ar = [], i = 0; i < arguments.length; i++)
221 ar = ar.concat(__read(arguments[i]));
222 return ar;
223 }
224 /** @deprecated */
225 function __spreadArrays() {
226 for (var s = 0, i = 0, il = arguments.length; i < il; i++)
227 s += arguments[i].length;
228 for (var r = Array(s), k = 0, i = 0; i < il; i++)
229 for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
230 r[k] = a[j];
231 return r;
232 }
233 function __spreadArray(to, from, pack) {
234 if (pack || arguments.length === 2)
235 for (var i = 0, l = from.length, ar; i < l; i++) {
236 if (ar || !(i in from)) {
237 if (!ar)
238 ar = Array.prototype.slice.call(from, 0, i);
239 ar[i] = from[i];
240 }
241 }
242 return to.concat(ar || from);
243 }
244 function __await(v) {
245 return this instanceof __await ? (this.v = v, this) : new __await(v);
246 }
247 function __asyncGenerator(thisArg, _arguments, generator) {
248 if (!Symbol.asyncIterator)
249 throw new TypeError("Symbol.asyncIterator is not defined.");
250 var g = generator.apply(thisArg, _arguments || []), i, q = [];
251 return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
252 function verb(n) { if (g[n])
253 i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
254 function resume(n, v) { try {
255 step(g[n](v));
256 }
257 catch (e) {
258 settle(q[0][3], e);
259 } }
260 function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
261 function fulfill(value) { resume("next", value); }
262 function reject(value) { resume("throw", value); }
263 function settle(f, v) { if (f(v), q.shift(), q.length)
264 resume(q[0][0], q[0][1]); }
265 }
266 function __asyncDelegator(o) {
267 var i, p;
268 return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
269 function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
270 }
271 function __asyncValues(o) {
272 if (!Symbol.asyncIterator)
273 throw new TypeError("Symbol.asyncIterator is not defined.");
274 var m = o[Symbol.asyncIterator], i;
275 return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
276 function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
277 function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
278 }
279 function __makeTemplateObject(cooked, raw) {
280 if (Object.defineProperty) {
281 Object.defineProperty(cooked, "raw", { value: raw });
282 }
283 else {
284 cooked.raw = raw;
285 }
286 return cooked;
287 }
288 ;
289 var __setModuleDefault = Object.create ? (function (o, v) {
290 Object.defineProperty(o, "default", { enumerable: true, value: v });
291 }) : function (o, v) {
292 o["default"] = v;
293 };
294 function __importStar(mod) {
295 if (mod && mod.__esModule)
296 return mod;
297 var result = {};
298 if (mod != null)
299 for (var k in mod)
300 if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
301 __createBinding(result, mod, k);
302 __setModuleDefault(result, mod);
303 return result;
304 }
305 function __importDefault(mod) {
306 return (mod && mod.__esModule) ? mod : { default: mod };
307 }
308 function __classPrivateFieldGet(receiver, state, kind, f) {
309 if (kind === "a" && !f)
310 throw new TypeError("Private accessor was defined without a getter");
311 if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
312 throw new TypeError("Cannot read private member from an object whose class did not declare it");
313 return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
314 }
315 function __classPrivateFieldSet(receiver, state, value, kind, f) {
316 if (kind === "m")
317 throw new TypeError("Private method is not writable");
318 if (kind === "a" && !f)
319 throw new TypeError("Private accessor was defined without a setter");
320 if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
321 throw new TypeError("Cannot write private member to an object whose class did not declare it");
322 return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
323 }
324
325 var _MatTreeNodeBase = core.mixinTabIndex(core.mixinDisabled(tree.CdkTreeNode));
326 /**
327 * Wrapper for the CdkTree node with Material design styles.
328 */
329 var MatTreeNode = /** @class */ (function (_super) {
330 __extends(MatTreeNode, _super);
331 function MatTreeNode(elementRef, tree, tabIndex) {
332 var _this = _super.call(this, elementRef, tree) || this;
333 _this.tabIndex = Number(tabIndex) || 0;
334 // The classes are directly added here instead of in the host property because classes on
335 // the host property are not inherited with View Engine. It is not set as a @HostBinding because
336 // it is not set by the time it's children nodes try to read the class from it.
337 // TODO: move to host after View Engine deprecation
338 elementRef.nativeElement.classList.add('mat-tree-node');
339 return _this;
340 }
341 // This is a workaround for https://github.com/angular/angular/issues/23091
342 // In aot mode, the lifecycle hooks from parent class are not called.
343 MatTreeNode.prototype.ngOnInit = function () {
344 _super.prototype.ngOnInit.call(this);
345 };
346 MatTreeNode.prototype.ngDoCheck = function () {
347 _super.prototype.ngDoCheck.call(this);
348 };
349 MatTreeNode.prototype.ngOnDestroy = function () {
350 _super.prototype.ngOnDestroy.call(this);
351 };
352 return MatTreeNode;
353 }(_MatTreeNodeBase));
354 MatTreeNode.decorators = [
355 { type: core$1.Directive, args: [{
356 selector: 'mat-tree-node',
357 exportAs: 'matTreeNode',
358 inputs: ['role', 'disabled', 'tabIndex'],
359 providers: [{ provide: tree.CdkTreeNode, useExisting: MatTreeNode }]
360 },] }
361 ];
362 MatTreeNode.ctorParameters = function () { return [
363 { type: core$1.ElementRef },
364 { type: tree.CdkTree },
365 { type: String, decorators: [{ type: core$1.Attribute, args: ['tabindex',] }] }
366 ]; };
367 /**
368 * Wrapper for the CdkTree node definition with Material design styles.
369 * Captures the node's template and a when predicate that describes when this node should be used.
370 */
371 var MatTreeNodeDef = /** @class */ (function (_super) {
372 __extends(MatTreeNodeDef, _super);
373 function MatTreeNodeDef() {
374 return _super !== null && _super.apply(this, arguments) || this;
375 }
376 return MatTreeNodeDef;
377 }(tree.CdkTreeNodeDef));
378 MatTreeNodeDef.decorators = [
379 { type: core$1.Directive, args: [{
380 selector: '[matTreeNodeDef]',
381 inputs: [
382 'when: matTreeNodeDefWhen'
383 ],
384 providers: [{ provide: tree.CdkTreeNodeDef, useExisting: MatTreeNodeDef }]
385 },] }
386 ];
387 MatTreeNodeDef.propDecorators = {
388 data: [{ type: core$1.Input, args: ['matTreeNode',] }]
389 };
390 /**
391 * Wrapper for the CdkTree nested node with Material design styles.
392 */
393 var MatNestedTreeNode = /** @class */ (function (_super) {
394 __extends(MatNestedTreeNode, _super);
395 function MatNestedTreeNode(elementRef, tree, differs, tabIndex) {
396 var _this = _super.call(this, elementRef, tree, differs) || this;
397 _this._disabled = false;
398 _this.tabIndex = Number(tabIndex) || 0;
399 // The classes are directly added here instead of in the host property because classes on
400 // the host property are not inherited with View Engine. It is not set as a @HostBinding because
401 // it is not set by the time it's children nodes try to read the class from it.
402 // TODO: move to host after View Engine deprecation
403 elementRef.nativeElement.classList.add('mat-nested-tree-node');
404 return _this;
405 }
406 Object.defineProperty(MatNestedTreeNode.prototype, "disabled", {
407 /** Whether the node is disabled. */
408 get: function () { return this._disabled; },
409 set: function (value) { this._disabled = coercion.coerceBooleanProperty(value); },
410 enumerable: false,
411 configurable: true
412 });
413 Object.defineProperty(MatNestedTreeNode.prototype, "tabIndex", {
414 /** Tabindex for the node. */
415 get: function () { return this.disabled ? -1 : this._tabIndex; },
416 set: function (value) {
417 // If the specified tabIndex value is null or undefined, fall back to the default value.
418 this._tabIndex = value != null ? value : 0;
419 },
420 enumerable: false,
421 configurable: true
422 });
423 // This is a workaround for https://github.com/angular/angular/issues/19145
424 // In aot mode, the lifecycle hooks from parent class are not called.
425 // TODO(tinayuangao): Remove when the angular issue #19145 is fixed
426 MatNestedTreeNode.prototype.ngOnInit = function () {
427 _super.prototype.ngOnInit.call(this);
428 };
429 MatNestedTreeNode.prototype.ngDoCheck = function () {
430 _super.prototype.ngDoCheck.call(this);
431 };
432 MatNestedTreeNode.prototype.ngAfterContentInit = function () {
433 _super.prototype.ngAfterContentInit.call(this);
434 };
435 MatNestedTreeNode.prototype.ngOnDestroy = function () {
436 _super.prototype.ngOnDestroy.call(this);
437 };
438 return MatNestedTreeNode;
439 }(tree.CdkNestedTreeNode));
440 MatNestedTreeNode.decorators = [
441 { type: core$1.Directive, args: [{
442 selector: 'mat-nested-tree-node',
443 exportAs: 'matNestedTreeNode',
444 inputs: ['role', 'disabled', 'tabIndex'],
445 providers: [
446 { provide: tree.CdkNestedTreeNode, useExisting: MatNestedTreeNode },
447 { provide: tree.CdkTreeNode, useExisting: MatNestedTreeNode },
448 { provide: tree.CDK_TREE_NODE_OUTLET_NODE, useExisting: MatNestedTreeNode }
449 ]
450 },] }
451 ];
452 MatNestedTreeNode.ctorParameters = function () { return [
453 { type: core$1.ElementRef },
454 { type: tree.CdkTree },
455 { type: core$1.IterableDiffers },
456 { type: String, decorators: [{ type: core$1.Attribute, args: ['tabindex',] }] }
457 ]; };
458 MatNestedTreeNode.propDecorators = {
459 node: [{ type: core$1.Input, args: ['matNestedTreeNode',] }],
460 disabled: [{ type: core$1.Input }],
461 tabIndex: [{ type: core$1.Input }]
462 };
463
464 /**
465 * Wrapper for the CdkTree padding with Material design styles.
466 */
467 var MatTreeNodePadding = /** @class */ (function (_super) {
468 __extends(MatTreeNodePadding, _super);
469 function MatTreeNodePadding() {
470 return _super !== null && _super.apply(this, arguments) || this;
471 }
472 Object.defineProperty(MatTreeNodePadding.prototype, "level", {
473 /** The level of depth of the tree node. The padding will be `level * indent` pixels. */
474 get: function () { return this._level; },
475 set: function (value) { this._setLevelInput(value); },
476 enumerable: false,
477 configurable: true
478 });
479 Object.defineProperty(MatTreeNodePadding.prototype, "indent", {
480 /** The indent for each level. Default number 40px from material design menu sub-menu spec. */
481 get: function () { return this._indent; },
482 set: function (indent) { this._setIndentInput(indent); },
483 enumerable: false,
484 configurable: true
485 });
486 return MatTreeNodePadding;
487 }(tree.CdkTreeNodePadding));
488 MatTreeNodePadding.decorators = [
489 { type: core$1.Directive, args: [{
490 selector: '[matTreeNodePadding]',
491 providers: [{ provide: tree.CdkTreeNodePadding, useExisting: MatTreeNodePadding }]
492 },] }
493 ];
494 MatTreeNodePadding.propDecorators = {
495 level: [{ type: core$1.Input, args: ['matTreeNodePadding',] }],
496 indent: [{ type: core$1.Input, args: ['matTreeNodePaddingIndent',] }]
497 };
498
499 /**
500 * @license
501 * Copyright Google LLC All Rights Reserved.
502 *
503 * Use of this source code is governed by an MIT-style license that can be
504 * found in the LICENSE file at https://angular.io/license
505 */
506 /**
507 * Outlet for nested CdkNode. Put `[matTreeNodeOutlet]` on a tag to place children dataNodes
508 * inside the outlet.
509 */
510 var MatTreeNodeOutlet = /** @class */ (function () {
511 function MatTreeNodeOutlet(viewContainer, _node) {
512 this.viewContainer = viewContainer;
513 this._node = _node;
514 }
515 return MatTreeNodeOutlet;
516 }());
517 MatTreeNodeOutlet.decorators = [
518 { type: core$1.Directive, args: [{
519 selector: '[matTreeNodeOutlet]',
520 providers: [{
521 provide: tree.CdkTreeNodeOutlet,
522 useExisting: MatTreeNodeOutlet
523 }]
524 },] }
525 ];
526 MatTreeNodeOutlet.ctorParameters = function () { return [
527 { type: core$1.ViewContainerRef },
528 { type: undefined, decorators: [{ type: core$1.Inject, args: [tree.CDK_TREE_NODE_OUTLET_NODE,] }, { type: core$1.Optional }] }
529 ]; };
530
531 /**
532 * Wrapper for the CdkTable with Material design styles.
533 */
534 var MatTree = /** @class */ (function (_super) {
535 __extends(MatTree, _super);
536 function MatTree() {
537 return _super !== null && _super.apply(this, arguments) || this;
538 }
539 return MatTree;
540 }(tree.CdkTree));
541 MatTree.decorators = [
542 { type: core$1.Component, args: [{
543 selector: 'mat-tree',
544 exportAs: 'matTree',
545 template: "<ng-container matTreeNodeOutlet></ng-container>",
546 host: {
547 // The 'cdk-tree' class needs to be included here because classes set in the host in the
548 // parent class are not inherited with View Engine. The 'cdk-tree' class in CdkTreeNode has
549 // to be set in the host because:
550 // if it is set as a @HostBinding it is not set by the time the tree nodes try to read the
551 // class from it.
552 // the ElementRef is not available in the constructor so the class can't be applied directly
553 // without a breaking constructor change.
554 'class': 'mat-tree cdk-tree',
555 'role': 'tree',
556 },
557 encapsulation: core$1.ViewEncapsulation.None,
558 // See note on CdkTree for explanation on why this uses the default change detection strategy.
559 // tslint:disable-next-line:validate-decorators
560 changeDetection: core$1.ChangeDetectionStrategy.Default,
561 providers: [{ provide: tree.CdkTree, useExisting: MatTree }],
562 styles: [".mat-tree{display:block}.mat-tree-node{display:flex;align-items:center;flex:1;word-wrap:break-word}.mat-nested-tree-node{border-bottom-width:0}\n"]
563 },] }
564 ];
565 MatTree.propDecorators = {
566 _nodeOutlet: [{ type: core$1.ViewChild, args: [MatTreeNodeOutlet, { static: true },] }]
567 };
568
569 /**
570 * Wrapper for the CdkTree's toggle with Material design styles.
571 */
572 // tslint:disable-next-line: coercion-types
573 var MatTreeNodeToggle = /** @class */ (function (_super) {
574 __extends(MatTreeNodeToggle, _super);
575 function MatTreeNodeToggle() {
576 return _super !== null && _super.apply(this, arguments) || this;
577 }
578 Object.defineProperty(MatTreeNodeToggle.prototype, "recursive", {
579 get: function () { return this._recursive; },
580 set: function (value) {
581 // TODO: when we remove support for ViewEngine, change this setter to an input
582 // alias in the decorator metadata.
583 this._recursive = coercion.coerceBooleanProperty(value);
584 },
585 enumerable: false,
586 configurable: true
587 });
588 return MatTreeNodeToggle;
589 }(tree.CdkTreeNodeToggle));
590 MatTreeNodeToggle.decorators = [
591 { type: core$1.Directive, args: [{
592 selector: '[matTreeNodeToggle]',
593 providers: [{ provide: tree.CdkTreeNodeToggle, useExisting: MatTreeNodeToggle }]
594 },] }
595 ];
596 MatTreeNodeToggle.propDecorators = {
597 recursive: [{ type: core$1.Input, args: ['matTreeNodeToggleRecursive',] }]
598 };
599
600 /**
601 * @license
602 * Copyright Google LLC All Rights Reserved.
603 *
604 * Use of this source code is governed by an MIT-style license that can be
605 * found in the LICENSE file at https://angular.io/license
606 */
607 var MAT_TREE_DIRECTIVES = [
608 MatNestedTreeNode,
609 MatTreeNodeDef,
610 MatTreeNodePadding,
611 MatTreeNodeToggle,
612 MatTree,
613 MatTreeNode,
614 MatTreeNodeOutlet
615 ];
616 var MatTreeModule = /** @class */ (function () {
617 function MatTreeModule() {
618 }
619 return MatTreeModule;
620 }());
621 MatTreeModule.decorators = [
622 { type: core$1.NgModule, args: [{
623 imports: [tree.CdkTreeModule, core.MatCommonModule],
624 exports: [core.MatCommonModule, MAT_TREE_DIRECTIVES],
625 declarations: MAT_TREE_DIRECTIVES,
626 },] }
627 ];
628
629 /**
630 * Tree flattener to convert a normal type of node to node with children & level information.
631 * Transform nested nodes of type `T` to flattened nodes of type `F`.
632 *
633 * For example, the input data of type `T` is nested, and contains its children data:
634 * SomeNode: {
635 * key: 'Fruits',
636 * children: [
637 * NodeOne: {
638 * key: 'Apple',
639 * },
640 * NodeTwo: {
641 * key: 'Pear',
642 * }
643 * ]
644 * }
645 * After flattener flatten the tree, the structure will become
646 * SomeNode: {
647 * key: 'Fruits',
648 * expandable: true,
649 * level: 1
650 * },
651 * NodeOne: {
652 * key: 'Apple',
653 * expandable: false,
654 * level: 2
655 * },
656 * NodeTwo: {
657 * key: 'Pear',
658 * expandable: false,
659 * level: 2
660 * }
661 * and the output flattened type is `F` with additional information.
662 */
663 var MatTreeFlattener = /** @class */ (function () {
664 function MatTreeFlattener(transformFunction, getLevel, isExpandable, getChildren) {
665 this.transformFunction = transformFunction;
666 this.getLevel = getLevel;
667 this.isExpandable = isExpandable;
668 this.getChildren = getChildren;
669 }
670 MatTreeFlattener.prototype._flattenNode = function (node, level, resultNodes, parentMap) {
671 var _this = this;
672 var flatNode = this.transformFunction(node, level);
673 resultNodes.push(flatNode);
674 if (this.isExpandable(flatNode)) {
675 var childrenNodes = this.getChildren(node);
676 if (childrenNodes) {
677 if (Array.isArray(childrenNodes)) {
678 this._flattenChildren(childrenNodes, level, resultNodes, parentMap);
679 }
680 else {
681 childrenNodes.pipe(operators.take(1)).subscribe(function (children) {
682 _this._flattenChildren(children, level, resultNodes, parentMap);
683 });
684 }
685 }
686 }
687 return resultNodes;
688 };
689 MatTreeFlattener.prototype._flattenChildren = function (children, level, resultNodes, parentMap) {
690 var _this = this;
691 children.forEach(function (child, index) {
692 var childParentMap = parentMap.slice();
693 childParentMap.push(index != children.length - 1);
694 _this._flattenNode(child, level + 1, resultNodes, childParentMap);
695 });
696 };
697 /**
698 * Flatten a list of node type T to flattened version of node F.
699 * Please note that type T may be nested, and the length of `structuredData` may be different
700 * from that of returned list `F[]`.
701 */
702 MatTreeFlattener.prototype.flattenNodes = function (structuredData) {
703 var _this = this;
704 var resultNodes = [];
705 structuredData.forEach(function (node) { return _this._flattenNode(node, 0, resultNodes, []); });
706 return resultNodes;
707 };
708 /**
709 * Expand flattened node with current expansion status.
710 * The returned list may have different length.
711 */
712 MatTreeFlattener.prototype.expandFlattenedNodes = function (nodes, treeControl) {
713 var _this = this;
714 var results = [];
715 var currentExpand = [];
716 currentExpand[0] = true;
717 nodes.forEach(function (node) {
718 var expand = true;
719 for (var i = 0; i <= _this.getLevel(node); i++) {
720 expand = expand && currentExpand[i];
721 }
722 if (expand) {
723 results.push(node);
724 }
725 if (_this.isExpandable(node)) {
726 currentExpand[_this.getLevel(node) + 1] = treeControl.isExpanded(node);
727 }
728 });
729 return results;
730 };
731 return MatTreeFlattener;
732 }());
733 /**
734 * Data source for flat tree.
735 * The data source need to handle expansion/collapsion of the tree node and change the data feed
736 * to `MatTree`.
737 * The nested tree nodes of type `T` are flattened through `MatTreeFlattener`, and converted
738 * to type `F` for `MatTree` to consume.
739 */
740 var MatTreeFlatDataSource = /** @class */ (function (_super) {
741 __extends(MatTreeFlatDataSource, _super);
742 function MatTreeFlatDataSource(_treeControl, _treeFlattener, initialData) {
743 var _this = _super.call(this) || this;
744 _this._treeControl = _treeControl;
745 _this._treeFlattener = _treeFlattener;
746 _this._flattenedData = new rxjs.BehaviorSubject([]);
747 _this._expandedData = new rxjs.BehaviorSubject([]);
748 _this._data = new rxjs.BehaviorSubject([]);
749 if (initialData) {
750 // Assign the data through the constructor to ensure that all of the logic is executed.
751 _this.data = initialData;
752 }
753 return _this;
754 }
755 Object.defineProperty(MatTreeFlatDataSource.prototype, "data", {
756 get: function () { return this._data.value; },
757 set: function (value) {
758 this._data.next(value);
759 this._flattenedData.next(this._treeFlattener.flattenNodes(this.data));
760 this._treeControl.dataNodes = this._flattenedData.value;
761 },
762 enumerable: false,
763 configurable: true
764 });
765 MatTreeFlatDataSource.prototype.connect = function (collectionViewer) {
766 var _this = this;
767 return rxjs.merge(collectionViewer.viewChange, this._treeControl.expansionModel.changed, this._flattenedData).pipe(operators.map(function () {
768 _this._expandedData.next(_this._treeFlattener.expandFlattenedNodes(_this._flattenedData.value, _this._treeControl));
769 return _this._expandedData.value;
770 }));
771 };
772 MatTreeFlatDataSource.prototype.disconnect = function () {
773 // no op
774 };
775 return MatTreeFlatDataSource;
776 }(collections.DataSource));
777
778 /**
779 * Data source for nested tree.
780 *
781 * The data source for nested tree doesn't have to consider node flattener, or the way to expand
782 * or collapse. The expansion/collapsion will be handled by TreeControl and each non-leaf node.
783 */
784 var MatTreeNestedDataSource = /** @class */ (function (_super) {
785 __extends(MatTreeNestedDataSource, _super);
786 function MatTreeNestedDataSource() {
787 var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this;
788 _this._data = new rxjs.BehaviorSubject([]);
789 return _this;
790 }
791 Object.defineProperty(MatTreeNestedDataSource.prototype, "data", {
792 /**
793 * Data for the nested tree
794 */
795 get: function () { return this._data.value; },
796 set: function (value) { this._data.next(value); },
797 enumerable: false,
798 configurable: true
799 });
800 MatTreeNestedDataSource.prototype.connect = function (collectionViewer) {
801 var _this = this;
802 return rxjs.merge.apply(void 0, [collectionViewer.viewChange, this._data]).pipe(operators.map(function () { return _this.data; }));
803 };
804 MatTreeNestedDataSource.prototype.disconnect = function () {
805 // no op
806 };
807 return MatTreeNestedDataSource;
808 }(collections.DataSource));
809
810 /**
811 * @license
812 * Copyright Google LLC All Rights Reserved.
813 *
814 * Use of this source code is governed by an MIT-style license that can be
815 * found in the LICENSE file at https://angular.io/license
816 */
817
818 /**
819 * Generated bundle index. Do not edit.
820 */
821
822 exports.MatNestedTreeNode = MatNestedTreeNode;
823 exports.MatTree = MatTree;
824 exports.MatTreeFlatDataSource = MatTreeFlatDataSource;
825 exports.MatTreeFlattener = MatTreeFlattener;
826 exports.MatTreeModule = MatTreeModule;
827 exports.MatTreeNestedDataSource = MatTreeNestedDataSource;
828 exports.MatTreeNode = MatTreeNode;
829 exports.MatTreeNodeDef = MatTreeNodeDef;
830 exports.MatTreeNodeOutlet = MatTreeNodeOutlet;
831 exports.MatTreeNodePadding = MatTreeNodePadding;
832 exports.MatTreeNodeToggle = MatTreeNodeToggle;
833
834 Object.defineProperty(exports, '__esModule', { value: true });
835
836})));
837//# sourceMappingURL=material-tree.umd.js.map
Note: See TracBrowser for help on using the repository browser.