@quadrel-enterprise-ui/framework 21.7.0 → 21.7.1
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/package.json
CHANGED
|
@@ -13855,7 +13855,12 @@ declare class QdPageStepComponent extends CdkStep implements OnInit, OnChanges,
|
|
|
13855
13855
|
* * @note The use of CDK attributes is not permitted. Please configure this component here.
|
|
13856
13856
|
*/
|
|
13857
13857
|
config: QdPageStepConfig;
|
|
13858
|
-
|
|
13858
|
+
/**
|
|
13859
|
+
* The form of the step, for example a QdFormGroup.
|
|
13860
|
+
*
|
|
13861
|
+
* The stepper only moves on to the next step when this form is valid. Optional steps skip this check.
|
|
13862
|
+
*/
|
|
13863
|
+
stepControl: AbstractControl;
|
|
13859
13864
|
infoBanners: QueryList<QdPageInfoBannerComponent>;
|
|
13860
13865
|
private _destroyed$;
|
|
13861
13866
|
constructor();
|
|
@@ -13865,7 +13870,7 @@ declare class QdPageStepComponent extends CdkStep implements OnInit, OnChanges,
|
|
|
13865
13870
|
private blockCdkInput;
|
|
13866
13871
|
private validateLabel;
|
|
13867
13872
|
static ɵfac: i0.ɵɵFactoryDeclaration<QdPageStepComponent, never>;
|
|
13868
|
-
static ɵcmp: i0.ɵɵComponentDeclaration<QdPageStepComponent, "qd-page-step", never, { "config": { "alias": "config"; "required": false; }; "
|
|
13873
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<QdPageStepComponent, "qd-page-step", never, { "config": { "alias": "config"; "required": false; }; "stepControl": { "alias": "stepControl"; "required": false; }; }, {}, ["infoBanners"], ["qd-page-info-banner", "*"], true, never>;
|
|
13869
13874
|
}
|
|
13870
13875
|
|
|
13871
13876
|
/**
|
|
@@ -19185,25 +19190,28 @@ declare class QdPageTabsModule {
|
|
|
19185
19190
|
}
|
|
19186
19191
|
|
|
19187
19192
|
/**
|
|
19188
|
-
*
|
|
19193
|
+
* All rows of a QdQuickEdit in template data mode. The generic type names the columns.
|
|
19194
|
+
*
|
|
19195
|
+
* Not used in FormArray mode, where the rows live in the consumer's form.
|
|
19189
19196
|
*/
|
|
19190
19197
|
type QdQuickEditData<T extends string> = QdQuickEditRow<T>[];
|
|
19191
19198
|
/**
|
|
19192
|
-
*
|
|
19199
|
+
* One row: a flat object whose keys are the column names.
|
|
19200
|
+
*
|
|
19201
|
+
* Flat on purpose — a column name resolves a direct key only, never a path like `address.city`.
|
|
19193
19202
|
*/
|
|
19194
19203
|
type QdQuickEditRow<T extends string> = Record<T, QdQuickEditDataValue>;
|
|
19195
19204
|
/**
|
|
19196
|
-
*
|
|
19197
|
-
* Currently only support for number & strings
|
|
19205
|
+
* What a single cell may hold. Dates and booleans are not supported.
|
|
19198
19206
|
*/
|
|
19199
19207
|
type QdQuickEditDataValue = number | string | string[];
|
|
19200
19208
|
|
|
19201
19209
|
/**
|
|
19202
|
-
*
|
|
19210
|
+
* Text shown while the table holds no row at all.
|
|
19203
19211
|
*/
|
|
19204
19212
|
interface QdQuickEditEmptyStateView {
|
|
19205
19213
|
/**
|
|
19206
|
-
*
|
|
19214
|
+
* Toggles the empty view off, if set to "true".
|
|
19207
19215
|
*
|
|
19208
19216
|
* * @default: false
|
|
19209
19217
|
*/
|
|
@@ -19218,11 +19226,14 @@ interface QdQuickEditEmptyStateView {
|
|
|
19218
19226
|
*/
|
|
19219
19227
|
interface QdQuickEditConfig<T extends string> {
|
|
19220
19228
|
/**
|
|
19221
|
-
*
|
|
19229
|
+
* Defines the columns of the table, in the order they are rendered.
|
|
19230
|
+
*
|
|
19231
|
+
* Every column names a control of the row. In FormArray mode a column without a matching control
|
|
19232
|
+
* renders an empty cell.
|
|
19222
19233
|
*/
|
|
19223
19234
|
columns: QdQuickEditColumn<T>[];
|
|
19224
19235
|
/**
|
|
19225
|
-
*
|
|
19236
|
+
* Defines a list of secondary actions that can be executed per Click/Tab of an item in the menu.
|
|
19226
19237
|
*
|
|
19227
19238
|
* * @example
|
|
19228
19239
|
* This is how the two actions "save" and "delete" are created.
|
|
@@ -19242,12 +19253,17 @@ interface QdQuickEditConfig<T extends string> {
|
|
|
19242
19253
|
*/
|
|
19243
19254
|
secondaryActions?: QdQuickEditSecondaryAction<T>[];
|
|
19244
19255
|
/**
|
|
19245
|
-
* Determines whether
|
|
19246
|
-
*
|
|
19256
|
+
* Determines whether rows can be added and removed.
|
|
19257
|
+
*
|
|
19258
|
+
* When `true`, QuickEdit renders its own create button while used standalone. Inside a section, configure the
|
|
19259
|
+
* section with an `addNew` action instead and leave this unset.
|
|
19260
|
+
*
|
|
19261
|
+
* **This flag also switches the remove action in the row menu on.** Without it nobody can delete a row, in
|
|
19262
|
+
* either mode. Adding and removing cannot be allowed separately today.
|
|
19247
19263
|
*/
|
|
19248
19264
|
canAdd?: boolean;
|
|
19249
19265
|
/**
|
|
19250
|
-
*
|
|
19266
|
+
* Enables a confirmation dialog before a row is removed via the built-in remove button.
|
|
19251
19267
|
*
|
|
19252
19268
|
* When set to `true`, a confirmation dialog with a framework default message is shown. The row is only removed if the user confirms.
|
|
19253
19269
|
* Only applies when `canAdd` is true and the remove button is visible.
|
|
@@ -19265,7 +19281,7 @@ interface QdQuickEditConfig<T extends string> {
|
|
|
19265
19281
|
*/
|
|
19266
19282
|
hasRemoveConfirmation?: boolean;
|
|
19267
19283
|
/**
|
|
19268
|
-
*
|
|
19284
|
+
* Overrides the default message of the remove confirmation dialog.
|
|
19269
19285
|
*
|
|
19270
19286
|
* When set, the confirmation dialog is shown with the provided message (setting this also enables the dialog for backward compatibility).
|
|
19271
19287
|
* If omitted, the framework default message is shown when the dialog is enabled via `hasRemoveConfirmation`.
|
|
@@ -19290,11 +19306,11 @@ interface QdQuickEditConfig<T extends string> {
|
|
|
19290
19306
|
i18n: string;
|
|
19291
19307
|
};
|
|
19292
19308
|
/**
|
|
19293
|
-
*
|
|
19309
|
+
* Text shown instead of the table while there is no row at all.
|
|
19294
19310
|
*/
|
|
19295
19311
|
emptyStateView?: QdQuickEditEmptyStateView;
|
|
19296
19312
|
/**
|
|
19297
|
-
*
|
|
19313
|
+
* Enables "viewonly" mode for quick edit.
|
|
19298
19314
|
*
|
|
19299
19315
|
* When set to `true`, the table displays its content as read-only.
|
|
19300
19316
|
* Combined with `secondaryActions`, this can be used to selectively show or hide secondary actions
|
|
@@ -19336,28 +19352,65 @@ interface QdQuickEditColumnBase<T extends string> {
|
|
|
19336
19352
|
*/
|
|
19337
19353
|
isHidden?: boolean;
|
|
19338
19354
|
/**
|
|
19339
|
-
*
|
|
19355
|
+
* Tooltip shown next to the column header.
|
|
19340
19356
|
*/
|
|
19341
19357
|
tooltip?: QdTooltip;
|
|
19342
19358
|
}
|
|
19343
19359
|
/**
|
|
19344
19360
|
* Column configuration for text in QdQuickEdit.
|
|
19361
|
+
*
|
|
19362
|
+
* Besides `type` it takes every field of `QdQuickEditColumnBase`: the required `name`, `i18n` and
|
|
19363
|
+
* `isEditable`, plus the optional `validators`, `isHidden` and `tooltip`.
|
|
19364
|
+
*
|
|
19365
|
+
* @example
|
|
19366
|
+
* { name: 'name', type: 'text', i18n: 'i18n.app.actors.name', isEditable: () => true }
|
|
19345
19367
|
*/
|
|
19346
19368
|
interface QdQuickEditColumnText<T extends string> extends QdQuickEditColumnBase<T> {
|
|
19369
|
+
/**
|
|
19370
|
+
* Renders the cell as a text input.
|
|
19371
|
+
*/
|
|
19347
19372
|
type: 'text';
|
|
19348
19373
|
}
|
|
19349
19374
|
/**
|
|
19350
19375
|
* Column configuration for integers in QdQuickEdit.
|
|
19376
|
+
*
|
|
19377
|
+
* Besides `type` it takes every field of `QdQuickEditColumnBase`: the required `name`, `i18n` and
|
|
19378
|
+
* `isEditable`, plus the optional `validators`, `isHidden` and `tooltip`.
|
|
19379
|
+
*
|
|
19380
|
+
* @example
|
|
19381
|
+
* { name: 'amount', type: 'integer', i18n: 'i18n.app.actors.amount', isEditable: () => true }
|
|
19351
19382
|
*/
|
|
19352
19383
|
interface QdQuickEditColumnInteger<T extends string> extends QdQuickEditColumnBase<T> {
|
|
19384
|
+
/**
|
|
19385
|
+
* Renders the cell as a number input.
|
|
19386
|
+
*/
|
|
19353
19387
|
type: 'integer';
|
|
19354
19388
|
}
|
|
19355
19389
|
/**
|
|
19356
19390
|
* Column configuration for dropdowns in QdQuickEdit.
|
|
19391
|
+
*
|
|
19392
|
+
* Besides `type` it takes every field of `QdQuickEditColumnBase`: the required `name`, `i18n` and
|
|
19393
|
+
* `isEditable`, plus the optional `validators`, `isHidden` and `tooltip`.
|
|
19394
|
+
*
|
|
19395
|
+
* On top of that it takes `options`, `placeholder`, `placeholderPrefix` and `filter`
|
|
19396
|
+
* from `QdFormDropdownConfiguration`. **`options` is required** — without it the cell renders an empty
|
|
19397
|
+
* dropdown. Every option carries the stored `value` and the `i18n` key shown to the user.
|
|
19398
|
+
*
|
|
19399
|
+
* @example
|
|
19400
|
+
* {
|
|
19401
|
+
* name: 'status',
|
|
19402
|
+
* type: 'enum',
|
|
19403
|
+
* i18n: 'i18n.app.actors.status',
|
|
19404
|
+
* isEditable: () => true,
|
|
19405
|
+
* options: [
|
|
19406
|
+
* { value: '1', i18n: 'i18n.app.actors.status.active' },
|
|
19407
|
+
* { value: '0', i18n: 'i18n.app.actors.status.inactive' }
|
|
19408
|
+
* ]
|
|
19409
|
+
* }
|
|
19357
19410
|
*/
|
|
19358
19411
|
interface QdQuickEditColumnEnum<T extends string> extends QdQuickEditColumnBase<T>, Pick<QdFormDropdownConfiguration, 'placeholder' | 'placeholderPrefix' | 'filter' | 'options'> {
|
|
19359
19412
|
/**
|
|
19360
|
-
*
|
|
19413
|
+
* Renders the cell as a dropdown. Needs `options`.
|
|
19361
19414
|
*/
|
|
19362
19415
|
type: 'enum';
|
|
19363
19416
|
}
|
|
@@ -19370,21 +19423,29 @@ type QdQuickEditColumn<T extends string> = QdQuickEditColumnInteger<T> | QdQuick
|
|
|
19370
19423
|
*/
|
|
19371
19424
|
interface QdQuickEditSecondaryAction<T extends string> {
|
|
19372
19425
|
/**
|
|
19373
|
-
*
|
|
19426
|
+
* Defines the secondary action type for the table.
|
|
19427
|
+
*/
|
|
19428
|
+
/**
|
|
19429
|
+
* Translation key of the entry shown in the row menu.
|
|
19374
19430
|
*/
|
|
19375
19431
|
label: {
|
|
19376
19432
|
i18n: string;
|
|
19377
19433
|
};
|
|
19378
19434
|
/**
|
|
19379
|
-
*
|
|
19435
|
+
* Greys the entry out, either always or per row.
|
|
19436
|
+
*
|
|
19437
|
+
* The entry stays visible in the menu and cannot be clicked.
|
|
19380
19438
|
*/
|
|
19381
19439
|
isDisabled?: boolean | ((row: QdQuickEditRow<T>) => boolean);
|
|
19382
19440
|
/**
|
|
19383
|
-
*
|
|
19441
|
+
* Runs when the user picks the entry.
|
|
19442
|
+
*
|
|
19443
|
+
* Receives the value of the row, not its position. Carry your own key in the row when you need to
|
|
19444
|
+
* find it again in your FormArray.
|
|
19384
19445
|
*/
|
|
19385
19446
|
handler: (selectedRow: QdQuickEditRow<T>) => void;
|
|
19386
19447
|
/**
|
|
19387
|
-
*
|
|
19448
|
+
* Controls in which operation mode this action is shown. May be set by the Quadrel Framework ('edit' or 'view').
|
|
19388
19449
|
*
|
|
19389
19450
|
* - Use `'edit'` to show the action only in editable mode.
|
|
19390
19451
|
* - Use `'view'` to show the action only in viewonly mode.
|
|
@@ -19419,25 +19480,34 @@ interface QdQuickEditSecondaryAction<T extends string> {
|
|
|
19419
19480
|
* #### Configuration
|
|
19420
19481
|
*
|
|
19421
19482
|
* ```ts
|
|
19422
|
-
* type ColumnDefinition = '
|
|
19483
|
+
* type ColumnDefinition = 'category' | 'amount' | 'status';
|
|
19423
19484
|
* const config: QdQuickEditConfig<ColumnDefinition> = {
|
|
19424
19485
|
* columns: [
|
|
19425
19486
|
* {
|
|
19426
|
-
* name: '
|
|
19487
|
+
* name: 'category',
|
|
19427
19488
|
* type: 'text',
|
|
19428
|
-
* i18n: 'translation.key.
|
|
19489
|
+
* i18n: 'translation.key.category',
|
|
19429
19490
|
* isEditable: () => false
|
|
19430
19491
|
* },
|
|
19431
19492
|
* {
|
|
19432
|
-
* name: '
|
|
19493
|
+
* name: 'amount',
|
|
19433
19494
|
* type: 'integer',
|
|
19434
|
-
* i18n: 'translation.key.
|
|
19435
|
-
* isEditable:
|
|
19495
|
+
* i18n: 'translation.key.amount',
|
|
19496
|
+
* isEditable: row => !!row['category'],
|
|
19436
19497
|
* validators: [Validators.required] // only relevant in template data mode
|
|
19498
|
+
* },
|
|
19499
|
+
* {
|
|
19500
|
+
* name: 'status',
|
|
19501
|
+
* type: 'enum',
|
|
19502
|
+
* i18n: 'translation.key.status',
|
|
19503
|
+
* isEditable: () => true,
|
|
19504
|
+
* options: [
|
|
19505
|
+
* { value: '1', i18n: 'translation.key.status.active' },
|
|
19506
|
+
* { value: '0', i18n: 'translation.key.status.inactive' }
|
|
19507
|
+
* ]
|
|
19437
19508
|
* }
|
|
19438
19509
|
* ],
|
|
19439
|
-
* canAdd: true
|
|
19440
|
-
* secondaryActions: [...]
|
|
19510
|
+
* canAdd: true
|
|
19441
19511
|
* }
|
|
19442
19512
|
* ```
|
|
19443
19513
|
*
|
|
@@ -19447,39 +19517,64 @@ interface QdQuickEditSecondaryAction<T extends string> {
|
|
|
19447
19517
|
*
|
|
19448
19518
|
* ```ts
|
|
19449
19519
|
* form = new FormGroup({
|
|
19450
|
-
*
|
|
19520
|
+
* rows: new FormArray([
|
|
19451
19521
|
* new FormGroup({
|
|
19452
|
-
*
|
|
19453
|
-
*
|
|
19522
|
+
* category: new QdFormControl('Text'),
|
|
19523
|
+
* amount: new QdFormControl(123),
|
|
19524
|
+
* status: new QdFormControl('1')
|
|
19454
19525
|
* })
|
|
19455
19526
|
* ])
|
|
19456
19527
|
* })
|
|
19457
19528
|
* ```
|
|
19458
19529
|
*
|
|
19459
|
-
* Then bind the `formArrayName` directive in the template
|
|
19530
|
+
* Then bind the `formArrayName` directive in the template. The name is the key of your FormArray,
|
|
19531
|
+
* it has nothing to do with the `data` input:
|
|
19460
19532
|
*
|
|
19461
19533
|
* ```html
|
|
19462
19534
|
* <form [formGroup]="form">
|
|
19463
|
-
* <qd-quick-edit [config]="config" formArrayName="
|
|
19535
|
+
* <qd-quick-edit [config]="config" formArrayName="rows"></qd-quick-edit>
|
|
19464
19536
|
* </form>
|
|
19465
19537
|
* ```
|
|
19466
19538
|
*
|
|
19467
|
-
*
|
|
19539
|
+
* In this mode the FormArray is the single source of truth for the rows. QuickEdit keeps no copy of its own.
|
|
19540
|
+
* What the FormArray holds is what the table shows.
|
|
19541
|
+
*
|
|
19542
|
+
* **Adding rows:** QuickEdit does not create the row for you. It emits `(addNewClicked)` and you insert a new FormGroup:
|
|
19468
19543
|
*
|
|
19469
19544
|
* ```ts
|
|
19470
|
-
*
|
|
19471
|
-
* this.form.
|
|
19545
|
+
* addRow(): void {
|
|
19546
|
+
* this.form.controls.rows.insert(0, new FormGroup({ ... }));
|
|
19472
19547
|
* }
|
|
19473
19548
|
* ```
|
|
19474
19549
|
*
|
|
19550
|
+
* **Removing rows:** QuickEdit removes the row for you. It calls `removeAt(index)` on your FormArray.
|
|
19551
|
+
* There is no separate output event, because the FormArray already tells you: `valueChanges` fires, `length` and `controls` are updated.
|
|
19552
|
+
* The remove action only appears when `canAdd` is set — that one flag switches adding and removing on together.
|
|
19553
|
+
* With `hasRemoveConfirmation` or `removeConfirmationMessage` in the config, a confirmation dialog is shown first.
|
|
19554
|
+
* The row is only removed after the user confirms.
|
|
19555
|
+
*
|
|
19556
|
+
* **Reacting to a changed set of rows:** subscribe to the FormArray, not to QuickEdit. This covers both directions,
|
|
19557
|
+
* rows you insert and rows QuickEdit removes:
|
|
19558
|
+
*
|
|
19559
|
+
* ```ts
|
|
19560
|
+
* ngOnInit(): void {
|
|
19561
|
+
* this.form.controls.rows.valueChanges
|
|
19562
|
+
* .pipe(takeUntilDestroyed(this.destroyRef))
|
|
19563
|
+
* .subscribe(rows => (this.rowCount = rows.length));
|
|
19564
|
+
* }
|
|
19565
|
+
* ```
|
|
19566
|
+
*
|
|
19567
|
+
* **Row actions:** an entry of `config.secondaryActions` receives the value of its row, never its position.
|
|
19568
|
+
* Carry your own key in the row when the handler has to find that row again in your FormArray.
|
|
19569
|
+
*
|
|
19475
19570
|
* #### Template Data (optional)
|
|
19476
19571
|
*
|
|
19477
19572
|
* Alternatively, you can provide a static `data` array. This is useful for read-only scenarios without reactive forms.
|
|
19478
19573
|
*
|
|
19479
19574
|
* ```ts
|
|
19480
|
-
* const data: QdQuickEditData<
|
|
19481
|
-
* {
|
|
19482
|
-
* {
|
|
19575
|
+
* const data: QdQuickEditData<ColumnDefinition> = [
|
|
19576
|
+
* { category: 'Foo', amount: 42, status: '1' },
|
|
19577
|
+
* { category: 'Bar', amount: 77, status: '0' }
|
|
19483
19578
|
* ];
|
|
19484
19579
|
* ```
|
|
19485
19580
|
*
|
|
@@ -19487,6 +19582,14 @@ interface QdQuickEditSecondaryAction<T extends string> {
|
|
|
19487
19582
|
* <qd-quick-edit [config]="config" [data]="data"></qd-quick-edit>
|
|
19488
19583
|
* ```
|
|
19489
19584
|
*
|
|
19585
|
+
* **How this mode differs:** QuickEdit builds its own FormGroup with a `rows` FormArray from the `data` input.
|
|
19586
|
+
* Here QuickEdit is the source of truth, not your array.
|
|
19587
|
+
*
|
|
19588
|
+
* - Adding a row: QuickEdit inserts an empty row at the top itself. `(addNewClicked)` is not emitted.
|
|
19589
|
+
* - Removing a row: QuickEdit removes the row from its own FormArray and also from the `data` array you passed in (in place, via `splice`).
|
|
19590
|
+
* - Reacting to a changed set of rows: `(formGroupChange)` emits QuickEdit's FormGroup on every change. Read the rows from `formGroup.get('rows')`.
|
|
19591
|
+
* - Passing a new `data` array reference rebuilds all rows from that array.
|
|
19592
|
+
*
|
|
19490
19593
|
* #### Validation
|
|
19491
19594
|
*
|
|
19492
19595
|
* - In **FormArray mode**, validators must be set directly on your FormControls. Validators in `config.columns` are ignored.
|
|
@@ -19510,39 +19613,46 @@ declare class QdQuickEditComponent<T extends string> implements OnInit, OnChange
|
|
|
19510
19613
|
private controlContainer;
|
|
19511
19614
|
private confirmationDialogService;
|
|
19512
19615
|
/**
|
|
19513
|
-
* Configuration of the QuickEdit. The generic type
|
|
19616
|
+
* Configuration of the QuickEdit. The generic type names the columns.
|
|
19514
19617
|
*
|
|
19515
|
-
*
|
|
19618
|
+
* Every column name must be a member of that type, and `name`, `type`, `i18n` and `isEditable`
|
|
19619
|
+
* are required on each column. The only column types are `text`, `integer` and `enum`.
|
|
19516
19620
|
*
|
|
19517
19621
|
* @example
|
|
19518
|
-
* type ColumnDefinition = 'article' | 'mass' | '
|
|
19622
|
+
* type ColumnDefinition = 'article' | 'mass' | 'unit';
|
|
19519
19623
|
* const config: QdQuickEditConfig<ColumnDefinition> = {
|
|
19520
19624
|
* columns: [
|
|
19521
19625
|
* {
|
|
19522
|
-
* name: '
|
|
19626
|
+
* name: 'article',
|
|
19523
19627
|
* type: 'text',
|
|
19524
|
-
* i18n: 'translation.key.
|
|
19628
|
+
* i18n: 'translation.key.article',
|
|
19525
19629
|
* isEditable: () => false
|
|
19526
19630
|
* },
|
|
19527
19631
|
* {
|
|
19528
|
-
* name: '
|
|
19632
|
+
* name: 'mass',
|
|
19529
19633
|
* type: 'integer',
|
|
19530
|
-
* i18n: 'translation.key.
|
|
19531
|
-
* isEditable:
|
|
19532
|
-
* validators: [Validators.required]
|
|
19634
|
+
* i18n: 'translation.key.mass',
|
|
19635
|
+
* isEditable: row => row['article'] != null,
|
|
19636
|
+
* validators: [Validators.required] // only applied in template data mode
|
|
19533
19637
|
* },
|
|
19534
19638
|
* {
|
|
19535
|
-
* name: '
|
|
19536
|
-
* type: '
|
|
19537
|
-
* i18n: 'translation.key.
|
|
19538
|
-
*
|
|
19639
|
+
* name: 'unit',
|
|
19640
|
+
* type: 'enum',
|
|
19641
|
+
* i18n: 'translation.key.unit',
|
|
19642
|
+
* isEditable: () => true,
|
|
19643
|
+
* options: [
|
|
19644
|
+
* { value: 'kg', i18n: 'translation.key.unit.kg' },
|
|
19645
|
+
* { value: 't', i18n: 'translation.key.unit.t' }
|
|
19646
|
+
* ]
|
|
19539
19647
|
* }
|
|
19540
|
-
* ]
|
|
19648
|
+
* ],
|
|
19649
|
+
* canAdd: true
|
|
19541
19650
|
* }
|
|
19542
19651
|
*/
|
|
19543
19652
|
config: QdQuickEditConfig<T>;
|
|
19544
19653
|
/**
|
|
19545
|
-
* Data provider for QuickEdit.
|
|
19654
|
+
* Data provider for QuickEdit. Only used in template data mode.
|
|
19655
|
+
* QuickEdit removes rows from this array in place. Ignored when `formArrayName` is bound.
|
|
19546
19656
|
*/
|
|
19547
19657
|
data: QdQuickEditData<T> | undefined;
|
|
19548
19658
|
get templateData(): QdQuickEditData<T>;
|
|
@@ -19555,8 +19665,13 @@ declare class QdQuickEditComponent<T extends string> implements OnInit, OnChange
|
|
|
19555
19665
|
/**
|
|
19556
19666
|
* The form group instance of QdQuickEdit.
|
|
19557
19667
|
* Use this form group to bind it to step-control of QdStepper or other custom logics.
|
|
19668
|
+
* Only emits in template data mode. In FormArray mode your own FormArray is the source of truth.
|
|
19558
19669
|
*/
|
|
19559
19670
|
formGroupChange: EventEmitter<any>;
|
|
19671
|
+
/**
|
|
19672
|
+
* Emitted in FormArray mode when the user clicks the add button.
|
|
19673
|
+
* Insert a new FormGroup into your FormArray. Not emitted in template data mode.
|
|
19674
|
+
*/
|
|
19560
19675
|
addNewClicked: EventEmitter<void>;
|
|
19561
19676
|
private focusables;
|
|
19562
19677
|
private customForDirective;
|
|
@@ -19570,6 +19685,9 @@ declare class QdQuickEditComponent<T extends string> implements OnInit, OnChange
|
|
|
19570
19685
|
get canAdd(): boolean;
|
|
19571
19686
|
get rows(): FormArray;
|
|
19572
19687
|
get visibleColumns(): QdQuickEditColumn<T>[];
|
|
19688
|
+
/**
|
|
19689
|
+
* Track function for the column loop. Keeps a column's cells alive while the rows change.
|
|
19690
|
+
*/
|
|
19573
19691
|
trackByColumnName(_: number, column: QdQuickEditColumn<T>): string;
|
|
19574
19692
|
get isFormControl(): boolean;
|
|
19575
19693
|
togglerDrawing: boolean;
|
|
@@ -19577,11 +19695,37 @@ declare class QdQuickEditComponent<T extends string> implements OnInit, OnChange
|
|
|
19577
19695
|
ngOnInit(): void;
|
|
19578
19696
|
ngOnChanges(changes: SimpleChanges): void;
|
|
19579
19697
|
ngOnDestroy(): void;
|
|
19698
|
+
/**
|
|
19699
|
+
* Whether a secondary action is disabled for one row.
|
|
19700
|
+
* Resolves the `isDisabled` of the action, which may be a flag or a function of the row.
|
|
19701
|
+
*/
|
|
19580
19702
|
isActionDisabled(action: QdQuickEditSecondaryAction<T>, row: QdQuickEditRow<T>): boolean;
|
|
19703
|
+
/**
|
|
19704
|
+
* Runs the handler of a secondary action for one row.
|
|
19705
|
+
* The handler receives the row value only, never its position.
|
|
19706
|
+
*/
|
|
19581
19707
|
handleSecondaryAction(action: QdQuickEditSecondaryAction<T>, rowIndex: number): void;
|
|
19708
|
+
/**
|
|
19709
|
+
* Maps a column type onto a facet component.
|
|
19710
|
+
*
|
|
19711
|
+
* @deprecated Nothing calls this any more, the template renders the cells directly. Planned for v22.
|
|
19712
|
+
*/
|
|
19582
19713
|
getComponentType(column: QdQuickEditColumn<T>): Type<unknown> | null;
|
|
19714
|
+
/**
|
|
19715
|
+
* Builds the inputs of the facet component for one cell.
|
|
19716
|
+
*
|
|
19717
|
+
* @deprecated Nothing calls this any more, the template renders the cells directly. Planned for v22.
|
|
19718
|
+
*/
|
|
19583
19719
|
getComponentInputs(column: QdQuickEditColumn<T>, row: QdQuickEditRow<T>): any;
|
|
19720
|
+
/**
|
|
19721
|
+
* Adds a row and focuses its first field.
|
|
19722
|
+
* FormArray mode: emits `addNewClicked` and leaves the insert to you. Template data mode: inserts an empty row at the top.
|
|
19723
|
+
*/
|
|
19584
19724
|
createRow(): void;
|
|
19725
|
+
/**
|
|
19726
|
+
* Removes the row at `index`, after the confirmation dialog when one is configured.
|
|
19727
|
+
* FormArray mode: calls `removeAt(index)` on your FormArray, no extra event. Template data mode: removes from the internal FormArray and from `data`.
|
|
19728
|
+
*/
|
|
19585
19729
|
removeRow(index: number): void;
|
|
19586
19730
|
private executeRemoveRow;
|
|
19587
19731
|
private initRows;
|
|
@@ -19625,6 +19769,11 @@ declare class QdFocusableModule {
|
|
|
19625
19769
|
static ɵinj: i0.ɵɵInjectorDeclaration<QdFocusableModule>;
|
|
19626
19770
|
}
|
|
19627
19771
|
|
|
19772
|
+
/**
|
|
19773
|
+
* Provides {@link QdQuickEditComponent} for editing rows inline.
|
|
19774
|
+
*
|
|
19775
|
+
* Import it where the table is used. It brings the form controls the cells need.
|
|
19776
|
+
*/
|
|
19628
19777
|
declare class QdQuickEditModule {
|
|
19629
19778
|
static ɵfac: i0.ɵɵFactoryDeclaration<QdQuickEditModule, never>;
|
|
19630
19779
|
static ɵmod: i0.ɵɵNgModuleDeclaration<QdQuickEditModule, [typeof QdQuickEditComponent, typeof QdCustomForDirective], [typeof QdCoreModule, typeof QdButtonModule, typeof i2.CommonModule, typeof QdFormModule, typeof i31.ReactiveFormsModule, typeof QdIconModule, typeof QdPopoverModule, typeof i5.TranslateModule, typeof QdPageModule, typeof QdFocusableModule, typeof QdTooltipModule], [typeof QdQuickEditComponent]>;
|