@angular/material-experimental 21.0.0-next.9 → 21.0.0-rc.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/fesm2022/column-resize.mjs +521 -257
- package/fesm2022/column-resize.mjs.map +1 -1
- package/fesm2022/material-experimental.mjs +1 -2
- package/fesm2022/material-experimental.mjs.map +1 -1
- package/fesm2022/menubar.mjs +182 -60
- package/fesm2022/menubar.mjs.map +1 -1
- package/fesm2022/popover-edit.mjs +351 -178
- package/fesm2022/popover-edit.mjs.map +1 -1
- package/fesm2022/selection.mjs +418 -201
- package/fesm2022/selection.mjs.map +1 -1
- package/package.json +4 -4
|
@@ -6,310 +6,574 @@ import { OverlayModule } from '@angular/cdk/overlay';
|
|
|
6
6
|
import { Directionality } from '@angular/cdk/bidi';
|
|
7
7
|
import { CdkColumnDef } from '@angular/cdk/table';
|
|
8
8
|
|
|
9
|
-
/**
|
|
10
|
-
* Overrides CdkFlexTableResizeStrategy to match mat-column elements.
|
|
11
|
-
*/
|
|
12
9
|
class MatFlexTableResizeStrategy extends CdkFlexTableResizeStrategy {
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
10
|
+
getColumnCssClass(cssFriendlyColumnName) {
|
|
11
|
+
return `mat-column-${cssFriendlyColumnName}`;
|
|
12
|
+
}
|
|
13
|
+
static ɵfac = i0.ɵɵngDeclareFactory({
|
|
14
|
+
minVersion: "12.0.0",
|
|
15
|
+
version: "20.2.0-next.2",
|
|
16
|
+
ngImport: i0,
|
|
17
|
+
type: MatFlexTableResizeStrategy,
|
|
18
|
+
deps: null,
|
|
19
|
+
target: i0.ɵɵFactoryTarget.Injectable
|
|
20
|
+
});
|
|
21
|
+
static ɵprov = i0.ɵɵngDeclareInjectable({
|
|
22
|
+
minVersion: "12.0.0",
|
|
23
|
+
version: "20.2.0-next.2",
|
|
24
|
+
ngImport: i0,
|
|
25
|
+
type: MatFlexTableResizeStrategy
|
|
26
|
+
});
|
|
18
27
|
}
|
|
19
|
-
i0.ɵɵngDeclareClassMetadata({
|
|
20
|
-
|
|
21
|
-
|
|
28
|
+
i0.ɵɵngDeclareClassMetadata({
|
|
29
|
+
minVersion: "12.0.0",
|
|
30
|
+
version: "20.2.0-next.2",
|
|
31
|
+
ngImport: i0,
|
|
32
|
+
type: MatFlexTableResizeStrategy,
|
|
33
|
+
decorators: [{
|
|
34
|
+
type: Injectable
|
|
35
|
+
}]
|
|
36
|
+
});
|
|
22
37
|
const FLEX_RESIZE_STRATEGY_PROVIDER = {
|
|
23
|
-
|
|
24
|
-
|
|
38
|
+
provide: ResizeStrategy,
|
|
39
|
+
useClass: MatFlexTableResizeStrategy
|
|
25
40
|
};
|
|
26
41
|
|
|
27
|
-
const PROVIDERS = [
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
];
|
|
33
|
-
const TABLE_PROVIDERS = [
|
|
34
|
-
...PROVIDERS,
|
|
35
|
-
TABLE_LAYOUT_FIXED_RESIZE_STRATEGY_PROVIDER,
|
|
36
|
-
];
|
|
42
|
+
const PROVIDERS = [ColumnResizeNotifier, HeaderRowEventDispatcher, ColumnResizeNotifierSource, {
|
|
43
|
+
provide: _COALESCED_STYLE_SCHEDULER,
|
|
44
|
+
useClass: _CoalescedStyleScheduler
|
|
45
|
+
}];
|
|
46
|
+
const TABLE_PROVIDERS = [...PROVIDERS, TABLE_LAYOUT_FIXED_RESIZE_STRATEGY_PROVIDER];
|
|
37
47
|
const FLEX_PROVIDERS = [...PROVIDERS, FLEX_RESIZE_STRATEGY_PROVIDER];
|
|
38
48
|
const TABLE_HOST_BINDINGS = {
|
|
39
|
-
|
|
49
|
+
'class': 'mat-column-resize-table'
|
|
40
50
|
};
|
|
41
51
|
const FLEX_HOST_BINDINGS = {
|
|
42
|
-
|
|
52
|
+
'class': 'mat-column-resize-flex'
|
|
43
53
|
};
|
|
44
54
|
class AbstractMatColumnResize extends ColumnResize {
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
55
|
+
getTableHeight() {
|
|
56
|
+
return this.elementRef.nativeElement.offsetHeight;
|
|
57
|
+
}
|
|
48
58
|
}
|
|
49
59
|
|
|
50
|
-
/**
|
|
51
|
-
* Explicitly enables column resizing for a table-based mat-table.
|
|
52
|
-
* Individual columns must be annotated specifically.
|
|
53
|
-
*/
|
|
54
60
|
class MatColumnResize extends AbstractMatColumnResize {
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
61
|
+
columnResizeNotifier = inject(ColumnResizeNotifier);
|
|
62
|
+
elementRef = inject(ElementRef);
|
|
63
|
+
eventDispatcher = inject(HeaderRowEventDispatcher);
|
|
64
|
+
ngZone = inject(NgZone);
|
|
65
|
+
notifier = inject(ColumnResizeNotifierSource);
|
|
66
|
+
static ɵfac = i0.ɵɵngDeclareFactory({
|
|
67
|
+
minVersion: "12.0.0",
|
|
68
|
+
version: "20.2.0-next.2",
|
|
69
|
+
ngImport: i0,
|
|
70
|
+
type: MatColumnResize,
|
|
71
|
+
deps: null,
|
|
72
|
+
target: i0.ɵɵFactoryTarget.Directive
|
|
73
|
+
});
|
|
74
|
+
static ɵdir = i0.ɵɵngDeclareDirective({
|
|
75
|
+
minVersion: "14.0.0",
|
|
76
|
+
version: "20.2.0-next.2",
|
|
77
|
+
type: MatColumnResize,
|
|
78
|
+
isStandalone: true,
|
|
79
|
+
selector: "table[mat-table][columnResize]",
|
|
80
|
+
host: {
|
|
81
|
+
classAttribute: "mat-column-resize-table"
|
|
82
|
+
},
|
|
83
|
+
providers: [...TABLE_PROVIDERS, {
|
|
84
|
+
provide: ColumnResize,
|
|
85
|
+
useExisting: MatColumnResize
|
|
86
|
+
}],
|
|
87
|
+
usesInheritance: true,
|
|
88
|
+
ngImport: i0
|
|
89
|
+
});
|
|
62
90
|
}
|
|
63
|
-
i0.ɵɵngDeclareClassMetadata({
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
91
|
+
i0.ɵɵngDeclareClassMetadata({
|
|
92
|
+
minVersion: "12.0.0",
|
|
93
|
+
version: "20.2.0-next.2",
|
|
94
|
+
ngImport: i0,
|
|
95
|
+
type: MatColumnResize,
|
|
96
|
+
decorators: [{
|
|
97
|
+
type: Directive,
|
|
98
|
+
args: [{
|
|
99
|
+
selector: 'table[mat-table][columnResize]',
|
|
100
|
+
host: TABLE_HOST_BINDINGS,
|
|
101
|
+
providers: [...TABLE_PROVIDERS, {
|
|
102
|
+
provide: ColumnResize,
|
|
103
|
+
useExisting: MatColumnResize
|
|
104
|
+
}]
|
|
105
|
+
}]
|
|
106
|
+
}]
|
|
107
|
+
});
|
|
71
108
|
|
|
72
|
-
/**
|
|
73
|
-
* Explicitly enables column resizing for a flexbox-based mat-table.
|
|
74
|
-
* Individual columns must be annotated specifically.
|
|
75
|
-
*/
|
|
76
109
|
class MatColumnResizeFlex extends AbstractMatColumnResize {
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
110
|
+
columnResizeNotifier = inject(ColumnResizeNotifier);
|
|
111
|
+
elementRef = inject(ElementRef);
|
|
112
|
+
eventDispatcher = inject(HeaderRowEventDispatcher);
|
|
113
|
+
ngZone = inject(NgZone);
|
|
114
|
+
notifier = inject(ColumnResizeNotifierSource);
|
|
115
|
+
static ɵfac = i0.ɵɵngDeclareFactory({
|
|
116
|
+
minVersion: "12.0.0",
|
|
117
|
+
version: "20.2.0-next.2",
|
|
118
|
+
ngImport: i0,
|
|
119
|
+
type: MatColumnResizeFlex,
|
|
120
|
+
deps: null,
|
|
121
|
+
target: i0.ɵɵFactoryTarget.Directive
|
|
122
|
+
});
|
|
123
|
+
static ɵdir = i0.ɵɵngDeclareDirective({
|
|
124
|
+
minVersion: "14.0.0",
|
|
125
|
+
version: "20.2.0-next.2",
|
|
126
|
+
type: MatColumnResizeFlex,
|
|
127
|
+
isStandalone: true,
|
|
128
|
+
selector: "mat-table[columnResize]",
|
|
129
|
+
host: {
|
|
130
|
+
classAttribute: "mat-column-resize-flex"
|
|
131
|
+
},
|
|
132
|
+
providers: [...FLEX_PROVIDERS, {
|
|
133
|
+
provide: ColumnResize,
|
|
134
|
+
useExisting: MatColumnResizeFlex
|
|
135
|
+
}],
|
|
136
|
+
usesInheritance: true,
|
|
137
|
+
ngImport: i0
|
|
138
|
+
});
|
|
84
139
|
}
|
|
85
|
-
i0.ɵɵngDeclareClassMetadata({
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
140
|
+
i0.ɵɵngDeclareClassMetadata({
|
|
141
|
+
minVersion: "12.0.0",
|
|
142
|
+
version: "20.2.0-next.2",
|
|
143
|
+
ngImport: i0,
|
|
144
|
+
type: MatColumnResizeFlex,
|
|
145
|
+
decorators: [{
|
|
146
|
+
type: Directive,
|
|
147
|
+
args: [{
|
|
148
|
+
selector: 'mat-table[columnResize]',
|
|
149
|
+
host: FLEX_HOST_BINDINGS,
|
|
150
|
+
providers: [...FLEX_PROVIDERS, {
|
|
151
|
+
provide: ColumnResize,
|
|
152
|
+
useExisting: MatColumnResizeFlex
|
|
153
|
+
}]
|
|
154
|
+
}]
|
|
155
|
+
}]
|
|
156
|
+
});
|
|
93
157
|
|
|
94
|
-
/**
|
|
95
|
-
* Implicitly enables column resizing for a table-based mat-table.
|
|
96
|
-
* Individual columns will be resizable unless opted out.
|
|
97
|
-
*/
|
|
98
158
|
class MatDefaultEnabledColumnResize extends AbstractMatColumnResize {
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
159
|
+
columnResizeNotifier = inject(ColumnResizeNotifier);
|
|
160
|
+
elementRef = inject(ElementRef);
|
|
161
|
+
eventDispatcher = inject(HeaderRowEventDispatcher);
|
|
162
|
+
ngZone = inject(NgZone);
|
|
163
|
+
notifier = inject(ColumnResizeNotifierSource);
|
|
164
|
+
static ɵfac = i0.ɵɵngDeclareFactory({
|
|
165
|
+
minVersion: "12.0.0",
|
|
166
|
+
version: "20.2.0-next.2",
|
|
167
|
+
ngImport: i0,
|
|
168
|
+
type: MatDefaultEnabledColumnResize,
|
|
169
|
+
deps: null,
|
|
170
|
+
target: i0.ɵɵFactoryTarget.Directive
|
|
171
|
+
});
|
|
172
|
+
static ɵdir = i0.ɵɵngDeclareDirective({
|
|
173
|
+
minVersion: "14.0.0",
|
|
174
|
+
version: "20.2.0-next.2",
|
|
175
|
+
type: MatDefaultEnabledColumnResize,
|
|
176
|
+
isStandalone: true,
|
|
177
|
+
selector: "table[mat-table]",
|
|
178
|
+
host: {
|
|
179
|
+
classAttribute: "mat-column-resize-table"
|
|
180
|
+
},
|
|
181
|
+
providers: [...TABLE_PROVIDERS, {
|
|
182
|
+
provide: ColumnResize,
|
|
183
|
+
useExisting: MatDefaultEnabledColumnResize
|
|
184
|
+
}],
|
|
185
|
+
usesInheritance: true,
|
|
186
|
+
ngImport: i0
|
|
187
|
+
});
|
|
109
188
|
}
|
|
110
|
-
i0.ɵɵngDeclareClassMetadata({
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
189
|
+
i0.ɵɵngDeclareClassMetadata({
|
|
190
|
+
minVersion: "12.0.0",
|
|
191
|
+
version: "20.2.0-next.2",
|
|
192
|
+
ngImport: i0,
|
|
193
|
+
type: MatDefaultEnabledColumnResize,
|
|
194
|
+
decorators: [{
|
|
195
|
+
type: Directive,
|
|
196
|
+
args: [{
|
|
197
|
+
selector: 'table[mat-table]',
|
|
198
|
+
host: TABLE_HOST_BINDINGS,
|
|
199
|
+
providers: [...TABLE_PROVIDERS, {
|
|
200
|
+
provide: ColumnResize,
|
|
201
|
+
useExisting: MatDefaultEnabledColumnResize
|
|
202
|
+
}]
|
|
203
|
+
}]
|
|
204
|
+
}]
|
|
205
|
+
});
|
|
121
206
|
|
|
122
|
-
/**
|
|
123
|
-
* Implicitly enables column resizing for a flexbox-based mat-table.
|
|
124
|
-
* Individual columns will be resizable unless opted out.
|
|
125
|
-
*/
|
|
126
207
|
class MatDefaultEnabledColumnResizeFlex extends AbstractMatColumnResize {
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
208
|
+
columnResizeNotifier = inject(ColumnResizeNotifier);
|
|
209
|
+
elementRef = inject(ElementRef);
|
|
210
|
+
eventDispatcher = inject(HeaderRowEventDispatcher);
|
|
211
|
+
ngZone = inject(NgZone);
|
|
212
|
+
notifier = inject(ColumnResizeNotifierSource);
|
|
213
|
+
static ɵfac = i0.ɵɵngDeclareFactory({
|
|
214
|
+
minVersion: "12.0.0",
|
|
215
|
+
version: "20.2.0-next.2",
|
|
216
|
+
ngImport: i0,
|
|
217
|
+
type: MatDefaultEnabledColumnResizeFlex,
|
|
218
|
+
deps: null,
|
|
219
|
+
target: i0.ɵɵFactoryTarget.Directive
|
|
220
|
+
});
|
|
221
|
+
static ɵdir = i0.ɵɵngDeclareDirective({
|
|
222
|
+
minVersion: "14.0.0",
|
|
223
|
+
version: "20.2.0-next.2",
|
|
224
|
+
type: MatDefaultEnabledColumnResizeFlex,
|
|
225
|
+
isStandalone: true,
|
|
226
|
+
selector: "mat-table",
|
|
227
|
+
host: {
|
|
228
|
+
classAttribute: "mat-column-resize-flex"
|
|
229
|
+
},
|
|
230
|
+
providers: [...FLEX_PROVIDERS, {
|
|
231
|
+
provide: ColumnResize,
|
|
232
|
+
useExisting: MatDefaultEnabledColumnResizeFlex
|
|
233
|
+
}],
|
|
234
|
+
usesInheritance: true,
|
|
235
|
+
ngImport: i0
|
|
236
|
+
});
|
|
137
237
|
}
|
|
138
|
-
i0.ɵɵngDeclareClassMetadata({
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
238
|
+
i0.ɵɵngDeclareClassMetadata({
|
|
239
|
+
minVersion: "12.0.0",
|
|
240
|
+
version: "20.2.0-next.2",
|
|
241
|
+
ngImport: i0,
|
|
242
|
+
type: MatDefaultEnabledColumnResizeFlex,
|
|
243
|
+
decorators: [{
|
|
244
|
+
type: Directive,
|
|
245
|
+
args: [{
|
|
246
|
+
selector: 'mat-table',
|
|
247
|
+
host: FLEX_HOST_BINDINGS,
|
|
248
|
+
providers: [...FLEX_PROVIDERS, {
|
|
249
|
+
provide: ColumnResize,
|
|
250
|
+
useExisting: MatDefaultEnabledColumnResizeFlex
|
|
251
|
+
}]
|
|
252
|
+
}]
|
|
253
|
+
}]
|
|
254
|
+
});
|
|
149
255
|
|
|
150
|
-
/**
|
|
151
|
-
* Component shown over the edge of a resizable column that is responsible
|
|
152
|
-
* for handling column resize mouse events and displaying a vertical line along the column edge.
|
|
153
|
-
*/
|
|
154
256
|
class MatColumnResizeOverlayHandle extends ResizeOverlayHandle {
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
|
|
177
|
-
|
|
257
|
+
columnDef = inject(CdkColumnDef);
|
|
258
|
+
columnResize = inject(ColumnResize);
|
|
259
|
+
directionality = inject(Directionality);
|
|
260
|
+
elementRef = inject(ElementRef);
|
|
261
|
+
eventDispatcher = inject(HeaderRowEventDispatcher);
|
|
262
|
+
ngZone = inject(NgZone);
|
|
263
|
+
resizeNotifier = inject(ColumnResizeNotifierSource);
|
|
264
|
+
resizeRef = inject(ResizeRef);
|
|
265
|
+
styleScheduler = inject(_COALESCED_STYLE_SCHEDULER);
|
|
266
|
+
document = inject(DOCUMENT);
|
|
267
|
+
topElement;
|
|
268
|
+
updateResizeActive(active) {
|
|
269
|
+
super.updateResizeActive(active);
|
|
270
|
+
const originHeight = this.resizeRef.origin.nativeElement.offsetHeight;
|
|
271
|
+
this.topElement.nativeElement.style.height = `${originHeight}px`;
|
|
272
|
+
this.resizeRef.overlayRef.updateSize({
|
|
273
|
+
height: active ? this.columnResize.getTableHeight() : originHeight
|
|
274
|
+
});
|
|
275
|
+
}
|
|
276
|
+
static ɵfac = i0.ɵɵngDeclareFactory({
|
|
277
|
+
minVersion: "12.0.0",
|
|
278
|
+
version: "20.2.0-next.2",
|
|
279
|
+
ngImport: i0,
|
|
280
|
+
type: MatColumnResizeOverlayHandle,
|
|
281
|
+
deps: null,
|
|
282
|
+
target: i0.ɵɵFactoryTarget.Component
|
|
283
|
+
});
|
|
284
|
+
static ɵcmp = i0.ɵɵngDeclareComponent({
|
|
285
|
+
minVersion: "14.0.0",
|
|
286
|
+
version: "20.2.0-next.2",
|
|
287
|
+
type: MatColumnResizeOverlayHandle,
|
|
288
|
+
isStandalone: true,
|
|
289
|
+
selector: "ng-component",
|
|
290
|
+
host: {
|
|
291
|
+
classAttribute: "mat-column-resize-overlay-thumb"
|
|
292
|
+
},
|
|
293
|
+
viewQueries: [{
|
|
294
|
+
propertyName: "topElement",
|
|
295
|
+
first: true,
|
|
296
|
+
predicate: ["top"],
|
|
297
|
+
descendants: true,
|
|
298
|
+
static: true
|
|
299
|
+
}],
|
|
300
|
+
usesInheritance: true,
|
|
301
|
+
ngImport: i0,
|
|
302
|
+
template: '<div #top class="mat-column-resize-overlay-thumb-top"></div>',
|
|
303
|
+
isInline: true,
|
|
304
|
+
changeDetection: i0.ChangeDetectionStrategy.OnPush,
|
|
305
|
+
encapsulation: i0.ViewEncapsulation.None
|
|
306
|
+
});
|
|
178
307
|
}
|
|
179
|
-
i0.ɵɵngDeclareClassMetadata({
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
308
|
+
i0.ɵɵngDeclareClassMetadata({
|
|
309
|
+
minVersion: "12.0.0",
|
|
310
|
+
version: "20.2.0-next.2",
|
|
311
|
+
ngImport: i0,
|
|
312
|
+
type: MatColumnResizeOverlayHandle,
|
|
313
|
+
decorators: [{
|
|
314
|
+
type: Component,
|
|
315
|
+
args: [{
|
|
316
|
+
changeDetection: ChangeDetectionStrategy.OnPush,
|
|
317
|
+
encapsulation: ViewEncapsulation.None,
|
|
318
|
+
host: {
|
|
319
|
+
'class': 'mat-column-resize-overlay-thumb'
|
|
320
|
+
},
|
|
321
|
+
template: '<div #top class="mat-column-resize-overlay-thumb-top"></div>'
|
|
322
|
+
}]
|
|
323
|
+
}],
|
|
324
|
+
propDecorators: {
|
|
325
|
+
topElement: [{
|
|
326
|
+
type: ViewChild,
|
|
327
|
+
args: ['top', {
|
|
328
|
+
static: true
|
|
329
|
+
}]
|
|
330
|
+
}]
|
|
331
|
+
}
|
|
332
|
+
});
|
|
191
333
|
|
|
192
334
|
class AbstractMatResizable extends Resizable {
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
335
|
+
minWidthPxInternal = 32;
|
|
336
|
+
getInlineHandleCssClassName() {
|
|
337
|
+
return 'mat-resizable-handle';
|
|
338
|
+
}
|
|
339
|
+
getOverlayHandleComponentType() {
|
|
340
|
+
return MatColumnResizeOverlayHandle;
|
|
341
|
+
}
|
|
200
342
|
}
|
|
201
343
|
const RESIZABLE_HOST_BINDINGS = {
|
|
202
|
-
|
|
344
|
+
'class': 'mat-resizable'
|
|
203
345
|
};
|
|
204
|
-
const RESIZABLE_INPUTS = [
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
346
|
+
const RESIZABLE_INPUTS = [{
|
|
347
|
+
name: 'minWidthPx',
|
|
348
|
+
alias: 'matResizableMinWidthPx'
|
|
349
|
+
}, {
|
|
350
|
+
name: 'maxWidthPx',
|
|
351
|
+
alias: 'matResizableMaxWidthPx'
|
|
352
|
+
}];
|
|
208
353
|
|
|
209
|
-
/**
|
|
210
|
-
* Implicitly enables column resizing for a mat-header-cell unless the disableResize attribute
|
|
211
|
-
* is present.
|
|
212
|
-
*/
|
|
213
354
|
class MatDefaultResizable extends AbstractMatResizable {
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
355
|
+
columnDef = inject(CdkColumnDef);
|
|
356
|
+
columnResize = inject(ColumnResize);
|
|
357
|
+
directionality = inject(Directionality);
|
|
358
|
+
elementRef = inject(ElementRef);
|
|
359
|
+
eventDispatcher = inject(HeaderRowEventDispatcher);
|
|
360
|
+
injector = inject(Injector);
|
|
361
|
+
ngZone = inject(NgZone);
|
|
362
|
+
resizeNotifier = inject(ColumnResizeNotifierSource);
|
|
363
|
+
resizeStrategy = inject(ResizeStrategy);
|
|
364
|
+
styleScheduler = inject(_COALESCED_STYLE_SCHEDULER);
|
|
365
|
+
viewContainerRef = inject(ViewContainerRef);
|
|
366
|
+
changeDetectorRef = inject(ChangeDetectorRef);
|
|
367
|
+
document = inject(DOCUMENT);
|
|
368
|
+
static ɵfac = i0.ɵɵngDeclareFactory({
|
|
369
|
+
minVersion: "12.0.0",
|
|
370
|
+
version: "20.2.0-next.2",
|
|
371
|
+
ngImport: i0,
|
|
372
|
+
type: MatDefaultResizable,
|
|
373
|
+
deps: null,
|
|
374
|
+
target: i0.ɵɵFactoryTarget.Directive
|
|
375
|
+
});
|
|
376
|
+
static ɵdir = i0.ɵɵngDeclareDirective({
|
|
377
|
+
minVersion: "14.0.0",
|
|
378
|
+
version: "20.2.0-next.2",
|
|
379
|
+
type: MatDefaultResizable,
|
|
380
|
+
isStandalone: true,
|
|
381
|
+
selector: "mat-header-cell:not([disableResize]), th[mat-header-cell]:not([disableResize])",
|
|
382
|
+
inputs: {
|
|
383
|
+
minWidthPx: ["matResizableMinWidthPx", "minWidthPx"],
|
|
384
|
+
maxWidthPx: ["matResizableMaxWidthPx", "maxWidthPx"]
|
|
385
|
+
},
|
|
386
|
+
host: {
|
|
387
|
+
classAttribute: "mat-resizable"
|
|
388
|
+
},
|
|
389
|
+
usesInheritance: true,
|
|
390
|
+
ngImport: i0
|
|
391
|
+
});
|
|
229
392
|
}
|
|
230
|
-
i0.ɵɵngDeclareClassMetadata({
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
393
|
+
i0.ɵɵngDeclareClassMetadata({
|
|
394
|
+
minVersion: "12.0.0",
|
|
395
|
+
version: "20.2.0-next.2",
|
|
396
|
+
ngImport: i0,
|
|
397
|
+
type: MatDefaultResizable,
|
|
398
|
+
decorators: [{
|
|
399
|
+
type: Directive,
|
|
400
|
+
args: [{
|
|
401
|
+
selector: 'mat-header-cell:not([disableResize]), th[mat-header-cell]:not([disableResize])',
|
|
402
|
+
host: RESIZABLE_HOST_BINDINGS,
|
|
403
|
+
inputs: RESIZABLE_INPUTS
|
|
404
|
+
}]
|
|
405
|
+
}]
|
|
406
|
+
});
|
|
238
407
|
|
|
239
|
-
/**
|
|
240
|
-
* Explicitly enables column resizing for a mat-header-cell.
|
|
241
|
-
*/
|
|
242
408
|
class MatResizable extends AbstractMatResizable {
|
|
243
|
-
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
409
|
+
columnDef = inject(CdkColumnDef);
|
|
410
|
+
columnResize = inject(ColumnResize);
|
|
411
|
+
directionality = inject(Directionality);
|
|
412
|
+
elementRef = inject(ElementRef);
|
|
413
|
+
eventDispatcher = inject(HeaderRowEventDispatcher);
|
|
414
|
+
injector = inject(Injector);
|
|
415
|
+
ngZone = inject(NgZone);
|
|
416
|
+
resizeNotifier = inject(ColumnResizeNotifierSource);
|
|
417
|
+
resizeStrategy = inject(ResizeStrategy);
|
|
418
|
+
styleScheduler = inject(_COALESCED_STYLE_SCHEDULER);
|
|
419
|
+
viewContainerRef = inject(ViewContainerRef);
|
|
420
|
+
changeDetectorRef = inject(ChangeDetectorRef);
|
|
421
|
+
document = inject(DOCUMENT);
|
|
422
|
+
static ɵfac = i0.ɵɵngDeclareFactory({
|
|
423
|
+
minVersion: "12.0.0",
|
|
424
|
+
version: "20.2.0-next.2",
|
|
425
|
+
ngImport: i0,
|
|
426
|
+
type: MatResizable,
|
|
427
|
+
deps: null,
|
|
428
|
+
target: i0.ɵɵFactoryTarget.Directive
|
|
429
|
+
});
|
|
430
|
+
static ɵdir = i0.ɵɵngDeclareDirective({
|
|
431
|
+
minVersion: "14.0.0",
|
|
432
|
+
version: "20.2.0-next.2",
|
|
433
|
+
type: MatResizable,
|
|
434
|
+
isStandalone: true,
|
|
435
|
+
selector: "mat-header-cell[resizable], th[mat-header-cell][resizable]",
|
|
436
|
+
inputs: {
|
|
437
|
+
minWidthPx: ["matResizableMinWidthPx", "minWidthPx"],
|
|
438
|
+
maxWidthPx: ["matResizableMaxWidthPx", "maxWidthPx"]
|
|
439
|
+
},
|
|
440
|
+
host: {
|
|
441
|
+
classAttribute: "mat-resizable"
|
|
442
|
+
},
|
|
443
|
+
usesInheritance: true,
|
|
444
|
+
ngImport: i0
|
|
445
|
+
});
|
|
258
446
|
}
|
|
259
|
-
i0.ɵɵngDeclareClassMetadata({
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
447
|
+
i0.ɵɵngDeclareClassMetadata({
|
|
448
|
+
minVersion: "12.0.0",
|
|
449
|
+
version: "20.2.0-next.2",
|
|
450
|
+
ngImport: i0,
|
|
451
|
+
type: MatResizable,
|
|
452
|
+
decorators: [{
|
|
453
|
+
type: Directive,
|
|
454
|
+
args: [{
|
|
455
|
+
selector: 'mat-header-cell[resizable], th[mat-header-cell][resizable]',
|
|
456
|
+
host: RESIZABLE_HOST_BINDINGS,
|
|
457
|
+
inputs: RESIZABLE_INPUTS
|
|
458
|
+
}]
|
|
459
|
+
}]
|
|
460
|
+
});
|
|
267
461
|
|
|
268
462
|
const ENTRY_COMMON_COMPONENTS = [MatColumnResizeOverlayHandle];
|
|
269
463
|
class MatColumnResizeCommonModule {
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
464
|
+
static ɵfac = i0.ɵɵngDeclareFactory({
|
|
465
|
+
minVersion: "12.0.0",
|
|
466
|
+
version: "20.2.0-next.2",
|
|
467
|
+
ngImport: i0,
|
|
468
|
+
type: MatColumnResizeCommonModule,
|
|
469
|
+
deps: [],
|
|
470
|
+
target: i0.ɵɵFactoryTarget.NgModule
|
|
471
|
+
});
|
|
472
|
+
static ɵmod = i0.ɵɵngDeclareNgModule({
|
|
473
|
+
minVersion: "14.0.0",
|
|
474
|
+
version: "20.2.0-next.2",
|
|
475
|
+
ngImport: i0,
|
|
476
|
+
type: MatColumnResizeCommonModule,
|
|
477
|
+
imports: [MatColumnResizeOverlayHandle],
|
|
478
|
+
exports: [MatColumnResizeOverlayHandle]
|
|
479
|
+
});
|
|
480
|
+
static ɵinj = i0.ɵɵngDeclareInjector({
|
|
481
|
+
minVersion: "12.0.0",
|
|
482
|
+
version: "20.2.0-next.2",
|
|
483
|
+
ngImport: i0,
|
|
484
|
+
type: MatColumnResizeCommonModule
|
|
485
|
+
});
|
|
273
486
|
}
|
|
274
|
-
i0.ɵɵngDeclareClassMetadata({
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
487
|
+
i0.ɵɵngDeclareClassMetadata({
|
|
488
|
+
minVersion: "12.0.0",
|
|
489
|
+
version: "20.2.0-next.2",
|
|
490
|
+
ngImport: i0,
|
|
491
|
+
type: MatColumnResizeCommonModule,
|
|
492
|
+
decorators: [{
|
|
493
|
+
type: NgModule,
|
|
494
|
+
args: [{
|
|
495
|
+
imports: [...ENTRY_COMMON_COMPONENTS],
|
|
496
|
+
exports: ENTRY_COMMON_COMPONENTS
|
|
497
|
+
}]
|
|
498
|
+
}]
|
|
499
|
+
});
|
|
281
500
|
const IMPORTS = [OverlayModule, MatColumnResizeCommonModule];
|
|
282
501
|
class MatDefaultEnabledColumnResizeModule {
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
502
|
+
static ɵfac = i0.ɵɵngDeclareFactory({
|
|
503
|
+
minVersion: "12.0.0",
|
|
504
|
+
version: "20.2.0-next.2",
|
|
505
|
+
ngImport: i0,
|
|
506
|
+
type: MatDefaultEnabledColumnResizeModule,
|
|
507
|
+
deps: [],
|
|
508
|
+
target: i0.ɵɵFactoryTarget.NgModule
|
|
509
|
+
});
|
|
510
|
+
static ɵmod = i0.ɵɵngDeclareNgModule({
|
|
511
|
+
minVersion: "14.0.0",
|
|
512
|
+
version: "20.2.0-next.2",
|
|
513
|
+
ngImport: i0,
|
|
514
|
+
type: MatDefaultEnabledColumnResizeModule,
|
|
515
|
+
imports: [OverlayModule, MatColumnResizeCommonModule, MatDefaultEnabledColumnResize, MatDefaultEnabledColumnResizeFlex, MatDefaultResizable],
|
|
516
|
+
exports: [MatDefaultEnabledColumnResize, MatDefaultEnabledColumnResizeFlex, MatDefaultResizable]
|
|
517
|
+
});
|
|
518
|
+
static ɵinj = i0.ɵɵngDeclareInjector({
|
|
519
|
+
minVersion: "12.0.0",
|
|
520
|
+
version: "20.2.0-next.2",
|
|
521
|
+
ngImport: i0,
|
|
522
|
+
type: MatDefaultEnabledColumnResizeModule,
|
|
523
|
+
imports: [IMPORTS]
|
|
524
|
+
});
|
|
288
525
|
}
|
|
289
|
-
i0.ɵɵngDeclareClassMetadata({
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
526
|
+
i0.ɵɵngDeclareClassMetadata({
|
|
527
|
+
minVersion: "12.0.0",
|
|
528
|
+
version: "20.2.0-next.2",
|
|
529
|
+
ngImport: i0,
|
|
530
|
+
type: MatDefaultEnabledColumnResizeModule,
|
|
531
|
+
decorators: [{
|
|
532
|
+
type: NgModule,
|
|
533
|
+
args: [{
|
|
534
|
+
imports: [...IMPORTS, MatDefaultEnabledColumnResize, MatDefaultEnabledColumnResizeFlex, MatDefaultResizable],
|
|
535
|
+
exports: [MatDefaultEnabledColumnResize, MatDefaultEnabledColumnResizeFlex, MatDefaultResizable]
|
|
536
|
+
}]
|
|
537
|
+
}]
|
|
538
|
+
});
|
|
301
539
|
class MatColumnResizeModule {
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
540
|
+
static ɵfac = i0.ɵɵngDeclareFactory({
|
|
541
|
+
minVersion: "12.0.0",
|
|
542
|
+
version: "20.2.0-next.2",
|
|
543
|
+
ngImport: i0,
|
|
544
|
+
type: MatColumnResizeModule,
|
|
545
|
+
deps: [],
|
|
546
|
+
target: i0.ɵɵFactoryTarget.NgModule
|
|
547
|
+
});
|
|
548
|
+
static ɵmod = i0.ɵɵngDeclareNgModule({
|
|
549
|
+
minVersion: "14.0.0",
|
|
550
|
+
version: "20.2.0-next.2",
|
|
551
|
+
ngImport: i0,
|
|
552
|
+
type: MatColumnResizeModule,
|
|
553
|
+
imports: [OverlayModule, MatColumnResizeCommonModule, MatColumnResize, MatColumnResizeFlex, MatResizable],
|
|
554
|
+
exports: [MatColumnResize, MatColumnResizeFlex, MatResizable]
|
|
555
|
+
});
|
|
556
|
+
static ɵinj = i0.ɵɵngDeclareInjector({
|
|
557
|
+
minVersion: "12.0.0",
|
|
558
|
+
version: "20.2.0-next.2",
|
|
559
|
+
ngImport: i0,
|
|
560
|
+
type: MatColumnResizeModule,
|
|
561
|
+
imports: [IMPORTS]
|
|
562
|
+
});
|
|
305
563
|
}
|
|
306
|
-
i0.ɵɵngDeclareClassMetadata({
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
564
|
+
i0.ɵɵngDeclareClassMetadata({
|
|
565
|
+
minVersion: "12.0.0",
|
|
566
|
+
version: "20.2.0-next.2",
|
|
567
|
+
ngImport: i0,
|
|
568
|
+
type: MatColumnResizeModule,
|
|
569
|
+
decorators: [{
|
|
570
|
+
type: NgModule,
|
|
571
|
+
args: [{
|
|
572
|
+
imports: [...IMPORTS, MatColumnResize, MatColumnResizeFlex, MatResizable],
|
|
573
|
+
exports: [MatColumnResize, MatColumnResizeFlex, MatResizable]
|
|
574
|
+
}]
|
|
575
|
+
}]
|
|
576
|
+
});
|
|
313
577
|
|
|
314
578
|
export { FLEX_RESIZE_STRATEGY_PROVIDER, MatColumnResize, MatColumnResizeCommonModule, MatColumnResizeFlex, MatColumnResizeModule, MatColumnResizeOverlayHandle, MatDefaultEnabledColumnResize, MatDefaultEnabledColumnResizeFlex, MatDefaultEnabledColumnResizeModule, MatDefaultResizable, MatFlexTableResizeStrategy, MatResizable };
|
|
315
579
|
//# sourceMappingURL=column-resize.mjs.map
|