@jielga/tmdatagrid 2.0.0-beta.12 → 2.0.0-beta.13
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/dist/index.d.ts +18 -3
- package/dist/index.js +162 -151
- package/dist/index.js.map +1 -1
- package/package.json +1 -1
- package/skills/appearance/SKILL.md +1 -1
- package/skills/cell-selection/SKILL.md +1 -1
- package/skills/columns/SKILL.md +1 -1
- package/skills/data/SKILL.md +1 -1
- package/skills/editing/SKILL.md +1 -1
- package/skills/filtering/SKILL.md +1 -1
- package/skills/getting-started/SKILL.md +1 -1
- package/skills/grouping/SKILL.md +1 -1
- package/skills/options/SKILL.md +1 -1
- package/skills/rows/SKILL.md +1 -1
- package/skills/server-side/SKILL.md +1 -1
- package/skills/testing/SKILL.md +1 -1
- package/src/tmdatagrid/components/TMDataGridEditColumn.tsx +1 -1
- package/src/tmdatagrid/core/editEngine.ts +68 -12
package/dist/index.d.ts
CHANGED
|
@@ -802,11 +802,26 @@ type TMDataGridEditApi<TData extends RowData = TMDataGridRowData> = {
|
|
|
802
802
|
addRows: (rows: ReadonlyArray<Partial<TData>>, options?: TMDataGridAddRowsOptions) => Promise<TMDataGridAddRowsResult>;
|
|
803
803
|
/**
|
|
804
804
|
* Deletes a row: `onRowDelete` straight away, or under `editing.draft` a
|
|
805
|
-
*
|
|
806
|
-
*
|
|
807
|
-
*
|
|
805
|
+
* mark in `deletedRowIds` - the row renders struck through until
|
|
806
|
+
* `saveDrafts` reports it. Idempotent: deleting a marked row again leaves
|
|
807
|
+
* it marked, and {@link restoreRow} is the undo. On an entry row,
|
|
808
|
+
* committed or not, it just discards the entry; an id the grid does not
|
|
809
|
+
* know is a no-op.
|
|
808
810
|
*/
|
|
809
811
|
deleteRow: (rowId: string) => void;
|
|
812
|
+
/**
|
|
813
|
+
* {@link deleteRow} for several rows in one call - one notification for
|
|
814
|
+
* the batch, for a bulk action over a selection. Because `deleteRow` is
|
|
815
|
+
* idempotent and ignores unknown ids, the list may be passed exactly as
|
|
816
|
+
* the selection stands - already-marked rows stay marked, duplicates and
|
|
817
|
+
* stale ids do nothing.
|
|
818
|
+
*/
|
|
819
|
+
deleteRows: (rowIds: ReadonlyArray<string>) => void;
|
|
820
|
+
/**
|
|
821
|
+
* Removes a row's deletion mark - the lane's Restore. A no-op on a row
|
|
822
|
+
* that is not marked, and outside `editing.draft`, where no marks exist.
|
|
823
|
+
*/
|
|
824
|
+
restoreRow: (rowId: string) => void;
|
|
810
825
|
/** Whether delete chrome makes sense - the lane's trash gate. */
|
|
811
826
|
canDeleteRows: () => boolean;
|
|
812
827
|
};
|
package/dist/index.js
CHANGED
|
@@ -431,13 +431,13 @@ async function Jt(e, t) {
|
|
|
431
431
|
}
|
|
432
432
|
}
|
|
433
433
|
function Yt(e) {
|
|
434
|
-
let t = new he(Lt), n = /* @__PURE__ */ new Map(), r = 0, i =
|
|
434
|
+
let t = new he(Lt), n = /* @__PURE__ */ new Map(), r = 0, i = "__new__", a = !1, o = null, s = null, c = (t) => {
|
|
435
435
|
if (jn(t.id) || Bt(t) === null) return !1;
|
|
436
436
|
let n = e().editableColumnIds;
|
|
437
437
|
return n !== void 0 && !n.includes(t.id) ? !1 : !On(t);
|
|
438
|
-
},
|
|
439
|
-
let r = n ? void 0 :
|
|
440
|
-
for (let t of
|
|
438
|
+
}, l = () => e().table.getAllLeafColumns().filter(c), u = async (e, t, n) => {
|
|
439
|
+
let r = n ? void 0 : D(t), i = {};
|
|
440
|
+
for (let t of l()) {
|
|
441
441
|
if (r !== void 0 && !kn(t, r)) continue;
|
|
442
442
|
let n = Bt(t);
|
|
443
443
|
if (n === null) continue;
|
|
@@ -455,7 +455,7 @@ function Yt(e) {
|
|
|
455
455
|
}
|
|
456
456
|
}
|
|
457
457
|
return Object.keys(i).length > 0 ? i : void 0;
|
|
458
|
-
},
|
|
458
|
+
}, d = (r, i, a) => {
|
|
459
459
|
let o = new Set(t.state.deletedRowIds), s = [], c = e().table.getCoreRowModel();
|
|
460
460
|
for (let e of c.flatRows) {
|
|
461
461
|
if (o.has(e.id)) continue;
|
|
@@ -484,17 +484,17 @@ function Yt(e) {
|
|
|
484
484
|
rowId: r,
|
|
485
485
|
value: i
|
|
486
486
|
}), s;
|
|
487
|
-
},
|
|
487
|
+
}, f = async (t, n, r) => {
|
|
488
488
|
let i = e().tableValidators;
|
|
489
489
|
if (i?.onSubmit === void 0 && i?.onSubmitAsync === void 0) return;
|
|
490
490
|
let a = {
|
|
491
491
|
value: t,
|
|
492
492
|
rowId: n,
|
|
493
493
|
isNew: r,
|
|
494
|
-
rows:
|
|
494
|
+
rows: d(n, t, r)
|
|
495
495
|
}, o = i.onSubmit?.(a);
|
|
496
496
|
return qt(o) ? o : await i.onSubmitAsync?.(a);
|
|
497
|
-
},
|
|
497
|
+
}, p = (e, t) => {
|
|
498
498
|
let n = e.filter(qt);
|
|
499
499
|
if (n.length === 0) return t === void 0 ? void 0 : { fields: t };
|
|
500
500
|
if (n.length === 1) {
|
|
@@ -525,18 +525,18 @@ function Yt(e) {
|
|
|
525
525
|
} else r = e;
|
|
526
526
|
let a = {};
|
|
527
527
|
return r !== void 0 && (a.form = r), Object.keys(i).length > 0 && (a.fields = i), a;
|
|
528
|
-
},
|
|
528
|
+
}, m = (t, n) => {
|
|
529
529
|
let r = e().rowValidators ?? {}, i = r.onSubmitAsync;
|
|
530
530
|
return {
|
|
531
531
|
...r,
|
|
532
532
|
onSubmitAsync: async (e) => {
|
|
533
|
-
let r = e.value, a = i === void 0 ? void 0 : await i(e), o = await
|
|
534
|
-
return
|
|
533
|
+
let r = e.value, a = i === void 0 ? void 0 : await i(e), o = await f(r, t, n), s = await u(r, t, n);
|
|
534
|
+
return p([o, a], s);
|
|
535
535
|
}
|
|
536
536
|
};
|
|
537
|
-
},
|
|
537
|
+
}, h = (e, t) => {
|
|
538
538
|
let n = [];
|
|
539
|
-
for (let r of
|
|
539
|
+
for (let r of l()) {
|
|
540
540
|
let i = Bt(r);
|
|
541
541
|
if (i === null) continue;
|
|
542
542
|
let a = pe(e.original, i), o = pe(t, i);
|
|
@@ -548,7 +548,7 @@ function Yt(e) {
|
|
|
548
548
|
});
|
|
549
549
|
}
|
|
550
550
|
return n;
|
|
551
|
-
},
|
|
551
|
+
}, g = (e) => {
|
|
552
552
|
let t = e.form.state, n = t.values, r = Object.entries(t.fieldMeta).flatMap(([e, t]) => {
|
|
553
553
|
if (e === "") return [];
|
|
554
554
|
let n = t.errors;
|
|
@@ -561,39 +561,39 @@ function Yt(e) {
|
|
|
561
561
|
message: t
|
|
562
562
|
}))];
|
|
563
563
|
return {
|
|
564
|
-
dirtyFields:
|
|
564
|
+
dirtyFields: h(e, n).map((e) => e.field),
|
|
565
565
|
errorFields: a.map((e) => e.field),
|
|
566
566
|
errorMessages: a,
|
|
567
567
|
hasRowError: Wt(t.errors),
|
|
568
568
|
isSubmitting: t.isSubmitting,
|
|
569
569
|
values: n
|
|
570
570
|
};
|
|
571
|
-
},
|
|
571
|
+
}, _ = (e) => {
|
|
572
572
|
let r = n.get(e);
|
|
573
573
|
t.setState((t) => {
|
|
574
574
|
let i = { ...t.rows };
|
|
575
|
-
return r === void 0 ? delete i[e] : i[e] =
|
|
575
|
+
return r === void 0 ? delete i[e] : i[e] = g(r), {
|
|
576
576
|
...t,
|
|
577
577
|
rows: i,
|
|
578
578
|
openRowIds: [...n.keys()]
|
|
579
579
|
};
|
|
580
580
|
});
|
|
581
|
-
},
|
|
581
|
+
}, v = (e) => {
|
|
582
582
|
t.setState((t) => ({
|
|
583
583
|
...t,
|
|
584
584
|
active: e
|
|
585
585
|
}));
|
|
586
|
-
},
|
|
586
|
+
}, y = (e, t) => {
|
|
587
587
|
let r = n.get(t)?.form.state.values;
|
|
588
588
|
return r === void 0 || e.committedValues[t] === r ? e.committedValues : {
|
|
589
589
|
...e.committedValues,
|
|
590
590
|
[t]: r
|
|
591
591
|
};
|
|
592
|
-
},
|
|
592
|
+
}, b = (e, n) => {
|
|
593
593
|
t.setState((t) => {
|
|
594
594
|
let r = t.newRows.find((t) => t.tempId === e);
|
|
595
595
|
if (r === void 0) return t;
|
|
596
|
-
let i = n ?
|
|
596
|
+
let i = n ? y(t, e) : t.committedValues;
|
|
597
597
|
return r.committed === n && i === t.committedValues ? t : {
|
|
598
598
|
...t,
|
|
599
599
|
committedValues: i,
|
|
@@ -603,21 +603,21 @@ function Yt(e) {
|
|
|
603
603
|
} : t)
|
|
604
604
|
};
|
|
605
605
|
});
|
|
606
|
-
},
|
|
606
|
+
}, x = (e, r) => {
|
|
607
607
|
let i = n.get(e);
|
|
608
608
|
i !== void 0 && (i.committed = r), t.setState((t) => {
|
|
609
|
-
let n = t.committedRowIds.includes(e), i = r ?
|
|
609
|
+
let n = t.committedRowIds.includes(e), i = r ? y(t, e) : t.committedValues;
|
|
610
610
|
return n === r && i === t.committedValues ? t : {
|
|
611
611
|
...t,
|
|
612
612
|
committedValues: i,
|
|
613
613
|
committedRowIds: n === r ? t.committedRowIds : r ? [...t.committedRowIds, e] : t.committedRowIds.filter((t) => t !== e)
|
|
614
614
|
};
|
|
615
615
|
});
|
|
616
|
-
},
|
|
616
|
+
}, S = (e, t) => {
|
|
617
617
|
if (!(t in e.committedValues)) return e.committedValues;
|
|
618
618
|
let { [t]: n, ...r } = e.committedValues;
|
|
619
619
|
return r;
|
|
620
|
-
},
|
|
620
|
+
}, C = (e) => {
|
|
621
621
|
let r = n.get(e);
|
|
622
622
|
r !== void 0 && (r.unsubscribe(), r.unmount(), n.delete(e), t.setState((t) => {
|
|
623
623
|
let i = { ...t.rows };
|
|
@@ -626,13 +626,13 @@ function Yt(e) {
|
|
|
626
626
|
rows: i,
|
|
627
627
|
openRowIds: [...n.keys()],
|
|
628
628
|
committedRowIds: t.committedRowIds.filter((t) => t !== e),
|
|
629
|
-
committedValues:
|
|
629
|
+
committedValues: S(t, e),
|
|
630
630
|
newRows: r.isNew ? t.newRows.filter((t) => t.tempId !== e) : t.newRows,
|
|
631
631
|
active: t.active?.rowId === e ? null : t.active
|
|
632
632
|
};
|
|
633
633
|
}));
|
|
634
|
-
},
|
|
635
|
-
let
|
|
634
|
+
}, w = (t, r, i) => {
|
|
635
|
+
let a = {
|
|
636
636
|
original: r,
|
|
637
637
|
isNew: i,
|
|
638
638
|
committed: !1,
|
|
@@ -644,25 +644,25 @@ function Yt(e) {
|
|
|
644
644
|
unmount: () => {},
|
|
645
645
|
form: new fe({
|
|
646
646
|
defaultValues: r,
|
|
647
|
-
validators:
|
|
647
|
+
validators: m(t, i),
|
|
648
648
|
onSubmit: async ({ value: n }) => {
|
|
649
|
-
if (
|
|
649
|
+
if (a.isNew) {
|
|
650
650
|
let r = {
|
|
651
651
|
tempId: t,
|
|
652
652
|
value: n
|
|
653
653
|
};
|
|
654
|
-
if (
|
|
655
|
-
|
|
654
|
+
if (s !== null) {
|
|
655
|
+
s.push(r), a.lastSubmitOk = !0;
|
|
656
656
|
return;
|
|
657
657
|
}
|
|
658
|
-
if (
|
|
659
|
-
|
|
658
|
+
if (a.parkOnly) {
|
|
659
|
+
a.lastSubmitOk = !0;
|
|
660
660
|
return;
|
|
661
661
|
}
|
|
662
662
|
try {
|
|
663
|
-
await e().onRowAdd?.(r),
|
|
663
|
+
await e().onRowAdd?.(r), a.lastSubmitOk = !0;
|
|
664
664
|
} catch (e) {
|
|
665
|
-
|
|
665
|
+
a.form.setErrorMap({ onSubmit: e instanceof Error ? e.message : String(e) });
|
|
666
666
|
}
|
|
667
667
|
return;
|
|
668
668
|
}
|
|
@@ -670,38 +670,38 @@ function Yt(e) {
|
|
|
670
670
|
rowId: t,
|
|
671
671
|
value: n,
|
|
672
672
|
original: r,
|
|
673
|
-
changes:
|
|
673
|
+
changes: h(a, n),
|
|
674
674
|
source: e().editMode
|
|
675
675
|
};
|
|
676
|
-
if (
|
|
677
|
-
|
|
676
|
+
if (o !== null) {
|
|
677
|
+
o.push(i), a.lastSubmitOk = !0;
|
|
678
678
|
return;
|
|
679
679
|
}
|
|
680
|
-
if (
|
|
681
|
-
|
|
680
|
+
if (a.parkOnly) {
|
|
681
|
+
a.lastSubmitOk = !0;
|
|
682
682
|
return;
|
|
683
683
|
}
|
|
684
684
|
try {
|
|
685
|
-
await e().onEditCommit?.(i),
|
|
685
|
+
await e().onEditCommit?.(i), a.lastSubmitOk = !0;
|
|
686
686
|
} catch (e) {
|
|
687
|
-
|
|
687
|
+
a.form.setErrorMap({ onSubmit: e instanceof Error ? e.message : String(e) });
|
|
688
688
|
}
|
|
689
689
|
}
|
|
690
690
|
})
|
|
691
691
|
};
|
|
692
|
-
|
|
693
|
-
let c =
|
|
694
|
-
return
|
|
695
|
-
},
|
|
692
|
+
a.unmount = a.form.mount();
|
|
693
|
+
let c = a.form.store.subscribe(() => _(t));
|
|
694
|
+
return a.unsubscribe = () => c.unsubscribe(), n.set(t, a), _(t), a;
|
|
695
|
+
}, T = (t) => !t.getIsGrouped() && e().isRowEditable?.(t) !== !1, E = (t, n) => {
|
|
696
696
|
let r = e();
|
|
697
|
-
return !(t.getIsGrouped() || !
|
|
698
|
-
},
|
|
697
|
+
return !(t.getIsGrouped() || !c(n) || !kn(n, t) || r.isRowEditable !== void 0 && !r.isRowEditable(t));
|
|
698
|
+
}, D = (t) => {
|
|
699
699
|
try {
|
|
700
700
|
return e().table.getRow(t);
|
|
701
701
|
} catch {
|
|
702
702
|
return;
|
|
703
703
|
}
|
|
704
|
-
},
|
|
704
|
+
}, O = (e) => {
|
|
705
705
|
let t = e.form.state.values;
|
|
706
706
|
return Object.entries(e.form.state.fieldMeta).flatMap(([e, n]) => {
|
|
707
707
|
if (e === "") return [];
|
|
@@ -712,40 +712,40 @@ function Yt(e) {
|
|
|
712
712
|
message: i
|
|
713
713
|
}];
|
|
714
714
|
});
|
|
715
|
-
},
|
|
716
|
-
let
|
|
717
|
-
return
|
|
715
|
+
}, k = async (r) => {
|
|
716
|
+
let i = n.get(r);
|
|
717
|
+
return i === void 0 ? !0 : i.pendingCommit === null ? !i.isNew && h(i, i.form.state.values).length === 0 ? (C(r), !0) : (Ht(i.form), i.lastSubmitOk = !1, i.submitErrors = [], i.parkOnly = e().draft && !a, i.pendingCommit = (async () => {
|
|
718
718
|
try {
|
|
719
|
-
await
|
|
719
|
+
await i.form.handleSubmit();
|
|
720
720
|
} finally {
|
|
721
|
-
|
|
721
|
+
i.pendingCommit = null;
|
|
722
722
|
}
|
|
723
|
-
return
|
|
723
|
+
return n.get(r) === i ? i.lastSubmitOk ? i.parkOnly ? (i.committed = !0, i.isNew ? b(r, !0) : x(r, !0), t.setState((e) => e.active?.rowId === r ? {
|
|
724
724
|
...e,
|
|
725
725
|
active: null
|
|
726
|
-
} : e), !0) : (
|
|
727
|
-
})(),
|
|
728
|
-
},
|
|
726
|
+
} : e), !0) : (C(r), !0) : (i.submitErrors = O(i), _(r), !1) : !0;
|
|
727
|
+
})(), i.pendingCommit) : i.pendingCommit;
|
|
728
|
+
}, A = (t, r) => {
|
|
729
729
|
let i = n.get(t);
|
|
730
730
|
if (i?.isNew === !0) {
|
|
731
|
-
i.committed = !1,
|
|
731
|
+
i.committed = !1, b(t, !1), v({
|
|
732
732
|
rowId: t,
|
|
733
733
|
columnId: r
|
|
734
734
|
});
|
|
735
735
|
return;
|
|
736
736
|
}
|
|
737
|
-
let a =
|
|
737
|
+
let a = D(t);
|
|
738
738
|
if (a !== void 0) {
|
|
739
739
|
if (r !== null) {
|
|
740
740
|
let t = e().table.getColumn(r);
|
|
741
|
-
if (t === void 0 || !
|
|
741
|
+
if (t === void 0 || !E(a, t)) return;
|
|
742
742
|
} else if (e().isRowEditable?.(a) === !1) return;
|
|
743
|
-
n.has(t) ? n.get(t)?.committed === !0 &&
|
|
743
|
+
n.has(t) ? n.get(t)?.committed === !0 && x(t, !1) : w(t, a.original, !1), v({
|
|
744
744
|
rowId: t,
|
|
745
745
|
columnId: r
|
|
746
746
|
});
|
|
747
747
|
}
|
|
748
|
-
},
|
|
748
|
+
}, j = ({ rowId: t, columnId: r }) => {
|
|
749
749
|
let { editMode: i } = e();
|
|
750
750
|
if (i === "cell") {
|
|
751
751
|
let e = [...n.keys()].find((e) => {
|
|
@@ -753,19 +753,19 @@ function Yt(e) {
|
|
|
753
753
|
return e !== t && r?.committed !== !0 && r?.isNew !== !0;
|
|
754
754
|
});
|
|
755
755
|
if (e !== void 0) {
|
|
756
|
-
|
|
757
|
-
e &&
|
|
756
|
+
k(e).then((e) => {
|
|
757
|
+
e && A(t, r);
|
|
758
758
|
});
|
|
759
759
|
return;
|
|
760
760
|
}
|
|
761
761
|
}
|
|
762
|
-
|
|
763
|
-
},
|
|
764
|
-
|
|
765
|
-
}, M = () => {
|
|
766
|
-
_(null);
|
|
762
|
+
A(t, r);
|
|
763
|
+
}, M = (e) => {
|
|
764
|
+
C(e);
|
|
767
765
|
}, N = () => {
|
|
768
|
-
|
|
766
|
+
v(null);
|
|
767
|
+
}, P = () => {
|
|
768
|
+
for (let e of [...n.keys()]) C(e);
|
|
769
769
|
t.setState((e) => ({
|
|
770
770
|
...e,
|
|
771
771
|
active: null,
|
|
@@ -773,86 +773,95 @@ function Yt(e) {
|
|
|
773
773
|
committedValues: {},
|
|
774
774
|
deletedRowIds: []
|
|
775
775
|
}));
|
|
776
|
-
},
|
|
776
|
+
}, F = (e) => {
|
|
777
777
|
r += 1;
|
|
778
|
-
let n =
|
|
779
|
-
return
|
|
778
|
+
let n = `${i}${r}`;
|
|
779
|
+
return w(n, I(e), !0), t.setState((e) => ({
|
|
780
780
|
...e,
|
|
781
781
|
newRows: [...e.newRows, {
|
|
782
782
|
tempId: n,
|
|
783
783
|
committed: !1
|
|
784
784
|
}]
|
|
785
785
|
})), n;
|
|
786
|
-
},
|
|
786
|
+
}, I = (t) => {
|
|
787
787
|
let { newRowDefaults: n } = e();
|
|
788
788
|
return {
|
|
789
789
|
...typeof n == "function" ? n() : n ?? {},
|
|
790
790
|
...t
|
|
791
791
|
};
|
|
792
|
-
},
|
|
793
|
-
let
|
|
792
|
+
}, L = async (e, n) => {
|
|
793
|
+
let a = [];
|
|
794
794
|
if (ge(() => {
|
|
795
795
|
for (let t of e) {
|
|
796
796
|
r += 1;
|
|
797
|
-
let e =
|
|
798
|
-
|
|
797
|
+
let e = `${i}${r}`;
|
|
798
|
+
w(e, I(t), !0), a.push(e);
|
|
799
799
|
}
|
|
800
800
|
t.setState((e) => ({
|
|
801
801
|
...e,
|
|
802
|
-
newRows: [...e.newRows, ...
|
|
802
|
+
newRows: [...e.newRows, ...a.map((e) => ({
|
|
803
803
|
tempId: e,
|
|
804
804
|
committed: !1
|
|
805
805
|
}))]
|
|
806
806
|
}));
|
|
807
807
|
}), n?.commit !== !0) return {
|
|
808
808
|
committed: [],
|
|
809
|
-
open:
|
|
809
|
+
open: a
|
|
810
810
|
};
|
|
811
|
-
let
|
|
812
|
-
for (let e of
|
|
811
|
+
let o = [], s = [];
|
|
812
|
+
for (let e of a) (await k(e) ? o : s).push(e);
|
|
813
813
|
return {
|
|
814
|
-
committed:
|
|
815
|
-
open:
|
|
814
|
+
committed: o,
|
|
815
|
+
open: s
|
|
816
816
|
};
|
|
817
|
-
},
|
|
817
|
+
}, R = (r) => {
|
|
818
818
|
if (n.get(r)?.isNew === !0) {
|
|
819
|
-
|
|
819
|
+
C(r);
|
|
820
820
|
return;
|
|
821
821
|
}
|
|
822
|
-
let
|
|
823
|
-
if (
|
|
824
|
-
t.setState((e) => ({
|
|
822
|
+
let a = e();
|
|
823
|
+
if (a.draft) {
|
|
824
|
+
t.setState((e) => e.deletedRowIds.includes(r) || r.startsWith(i) || !(r in a.table.getCoreRowModel().rowsById) ? e : {
|
|
825
825
|
...e,
|
|
826
|
-
deletedRowIds:
|
|
827
|
-
})
|
|
826
|
+
deletedRowIds: [...e.deletedRowIds, r]
|
|
827
|
+
});
|
|
828
828
|
return;
|
|
829
829
|
}
|
|
830
|
-
let
|
|
831
|
-
|
|
830
|
+
let o = D(r);
|
|
831
|
+
o !== void 0 && a.onRowDelete?.({
|
|
832
832
|
rowId: r,
|
|
833
|
-
row:
|
|
833
|
+
row: o
|
|
834
|
+
});
|
|
835
|
+
}, z = (e) => {
|
|
836
|
+
ge(() => {
|
|
837
|
+
for (let t of e) R(t);
|
|
834
838
|
});
|
|
835
|
-
},
|
|
839
|
+
}, B = (e) => {
|
|
840
|
+
t.setState((t) => t.deletedRowIds.includes(e) ? {
|
|
841
|
+
...t,
|
|
842
|
+
deletedRowIds: t.deletedRowIds.filter((t) => t !== e)
|
|
843
|
+
} : t);
|
|
844
|
+
}, V = () => {
|
|
836
845
|
let t = e();
|
|
837
846
|
return t.draft ? t.onRowDelete !== void 0 || t.onSaveDrafts !== void 0 : t.onRowDelete !== void 0;
|
|
838
|
-
},
|
|
847
|
+
}, ee = () => {
|
|
839
848
|
let e = [...t.state.deletedRowIds];
|
|
840
849
|
return e.length > 0 && t.setState((e) => ({
|
|
841
850
|
...e,
|
|
842
851
|
deletedRowIds: []
|
|
843
852
|
})), e;
|
|
844
|
-
},
|
|
853
|
+
}, H = () => [...n.keys()].filter((e) => n.get(e)?.committed === !0), te = async () => {
|
|
845
854
|
let e = [...n.keys()].filter((e) => n.get(e)?.committed !== !0);
|
|
846
|
-
return (await Promise.all(e.map((e) =>
|
|
847
|
-
},
|
|
848
|
-
|
|
849
|
-
}),
|
|
850
|
-
let r =
|
|
855
|
+
return (await Promise.all(e.map((e) => k(e)))).every(Boolean);
|
|
856
|
+
}, U = null, ne = () => U === null ? (a = !0, U = re().finally(() => {
|
|
857
|
+
a = !1, U = null;
|
|
858
|
+
}), U) : U, re = async () => {
|
|
859
|
+
let r = H(), i = [...t.state.deletedRowIds];
|
|
851
860
|
if (r.length === 0 && i.length === 0) return !0;
|
|
852
861
|
if (e().onSaveDrafts === void 0) {
|
|
853
|
-
let t = await Promise.all(r.map((e) =>
|
|
854
|
-
for (let t of
|
|
855
|
-
let n =
|
|
862
|
+
let t = await Promise.all(r.map((e) => k(e)));
|
|
863
|
+
for (let t of ee()) {
|
|
864
|
+
let n = D(t);
|
|
856
865
|
n !== void 0 && await e().onRowDelete?.({
|
|
857
866
|
rowId: t,
|
|
858
867
|
row: n
|
|
@@ -860,8 +869,8 @@ function Yt(e) {
|
|
|
860
869
|
}
|
|
861
870
|
return t.every(Boolean);
|
|
862
871
|
}
|
|
863
|
-
let
|
|
864
|
-
|
|
872
|
+
let a = [], c = [];
|
|
873
|
+
o = a, s = c;
|
|
865
874
|
let l = !0;
|
|
866
875
|
try {
|
|
867
876
|
for (let e of r) {
|
|
@@ -869,45 +878,45 @@ function Yt(e) {
|
|
|
869
878
|
t !== void 0 && (t.lastSubmitOk = !1, await t.form.handleSubmit(), t.lastSubmitOk || (l = !1));
|
|
870
879
|
}
|
|
871
880
|
} finally {
|
|
872
|
-
|
|
881
|
+
o = null, s = null;
|
|
873
882
|
}
|
|
874
883
|
let u = i;
|
|
875
|
-
if (
|
|
884
|
+
if (a.length > 0 || c.length > 0 || u.length > 0) {
|
|
876
885
|
let n;
|
|
877
886
|
try {
|
|
878
887
|
n = await e().onSaveDrafts?.({
|
|
879
|
-
updated:
|
|
888
|
+
updated: a,
|
|
880
889
|
created: c,
|
|
881
890
|
deleted: u,
|
|
882
|
-
rows:
|
|
891
|
+
rows: a,
|
|
883
892
|
added: c
|
|
884
893
|
});
|
|
885
894
|
} catch {
|
|
886
895
|
return !1;
|
|
887
896
|
}
|
|
888
897
|
let r = n ?? {}, i = !0;
|
|
889
|
-
for (let e of
|
|
890
|
-
for (let e of c) zt(r.created, e.tempId) ?
|
|
891
|
-
let
|
|
892
|
-
if (
|
|
898
|
+
for (let e of a) zt(r.updated, e.rowId) ? C(e.rowId) : i = !1;
|
|
899
|
+
for (let e of c) zt(r.created, e.tempId) ? C(e.tempId) : i = !1;
|
|
900
|
+
let o = u.filter((e) => zt(r.deleted, e));
|
|
901
|
+
if (o.length > 0 && t.setState((e) => ({
|
|
893
902
|
...e,
|
|
894
|
-
deletedRowIds: e.deletedRowIds.filter((e) => !
|
|
895
|
-
})),
|
|
903
|
+
deletedRowIds: e.deletedRowIds.filter((e) => !o.includes(e))
|
|
904
|
+
})), o.length < u.length && (i = !1), !i) return !1;
|
|
896
905
|
}
|
|
897
906
|
return l;
|
|
898
|
-
},
|
|
899
|
-
let e = await
|
|
907
|
+
}, ie = async () => {
|
|
908
|
+
let e = await te(), t = await ne();
|
|
900
909
|
return e && t;
|
|
901
|
-
},
|
|
902
|
-
let r =
|
|
910
|
+
}, ae = async (e, t) => {
|
|
911
|
+
let r = D(e);
|
|
903
912
|
if (r === void 0) return !1;
|
|
904
913
|
if (t.length === 0) return !0;
|
|
905
|
-
let i = n.get(e) ??
|
|
914
|
+
let i = n.get(e) ?? w(e, r.original, !1);
|
|
906
915
|
for (let { field: e, value: n } of t) i.form.setFieldValue(e, n);
|
|
907
|
-
return
|
|
908
|
-
},
|
|
909
|
-
let r =
|
|
910
|
-
return r === void 0 || i === void 0 || !
|
|
916
|
+
return k(e);
|
|
917
|
+
}, oe = (t, n) => {
|
|
918
|
+
let r = D(t), i = e().table.getColumn(n);
|
|
919
|
+
return r === void 0 || i === void 0 || !E(r, i) ? null : Bt(i);
|
|
911
920
|
};
|
|
912
921
|
return {
|
|
913
922
|
store: t,
|
|
@@ -917,7 +926,7 @@ function Yt(e) {
|
|
|
917
926
|
getForm: (e) => n.get(e)?.form,
|
|
918
927
|
getRowValues: (e) => {
|
|
919
928
|
let t = n.get(e);
|
|
920
|
-
return t === void 0 ?
|
|
929
|
+
return t === void 0 ? D(e)?.original : t.form.state.values;
|
|
921
930
|
},
|
|
922
931
|
getRows: () => {
|
|
923
932
|
let r = new Set(t.state.deletedRowIds), i = [], a = e().table.getCoreRowModel();
|
|
@@ -942,27 +951,27 @@ function Yt(e) {
|
|
|
942
951
|
}
|
|
943
952
|
return i;
|
|
944
953
|
},
|
|
945
|
-
canEditCell:
|
|
946
|
-
canEditRow:
|
|
947
|
-
isColumnEditable:
|
|
948
|
-
begin:
|
|
949
|
-
commit:
|
|
950
|
-
cancel:
|
|
951
|
-
deactivate:
|
|
952
|
-
cancelAll:
|
|
953
|
-
commitAll:
|
|
954
|
-
saveDrafts:
|
|
955
|
-
submitAll:
|
|
954
|
+
canEditCell: E,
|
|
955
|
+
canEditRow: T,
|
|
956
|
+
isColumnEditable: c,
|
|
957
|
+
begin: j,
|
|
958
|
+
commit: k,
|
|
959
|
+
cancel: M,
|
|
960
|
+
deactivate: N,
|
|
961
|
+
cancelAll: P,
|
|
962
|
+
commitAll: te,
|
|
963
|
+
saveDrafts: ne,
|
|
964
|
+
submitAll: ie,
|
|
956
965
|
clearCell: async (t, n) => {
|
|
957
|
-
let r = e().table.getColumn(n), i =
|
|
958
|
-
return i === null || r === void 0 ? !1 :
|
|
966
|
+
let r = e().table.getColumn(n), i = oe(t, n);
|
|
967
|
+
return i === null || r === void 0 ? !1 : ae(t, [{
|
|
959
968
|
field: i,
|
|
960
969
|
value: Vt(r.columnDef.meta?.type ?? "string")
|
|
961
970
|
}]);
|
|
962
971
|
},
|
|
963
972
|
setCellValue: async (e, t, n) => {
|
|
964
|
-
let r =
|
|
965
|
-
return r !== null &&
|
|
973
|
+
let r = oe(e, t);
|
|
974
|
+
return r !== null && ae(e, [{
|
|
966
975
|
field: r,
|
|
967
976
|
value: n
|
|
968
977
|
}]);
|
|
@@ -970,19 +979,21 @@ function Yt(e) {
|
|
|
970
979
|
setRowValues: async (e, t) => {
|
|
971
980
|
let n = [];
|
|
972
981
|
for (let [r, i] of Object.entries(t)) {
|
|
973
|
-
let t =
|
|
982
|
+
let t = oe(e, r);
|
|
974
983
|
if (t === null) return !1;
|
|
975
984
|
n.push({
|
|
976
985
|
field: t,
|
|
977
986
|
value: i
|
|
978
987
|
});
|
|
979
988
|
}
|
|
980
|
-
return
|
|
989
|
+
return ae(e, n);
|
|
981
990
|
},
|
|
982
|
-
addRow:
|
|
983
|
-
addRows:
|
|
984
|
-
deleteRow:
|
|
985
|
-
|
|
991
|
+
addRow: F,
|
|
992
|
+
addRows: L,
|
|
993
|
+
deleteRow: R,
|
|
994
|
+
deleteRows: z,
|
|
995
|
+
restoreRow: B,
|
|
996
|
+
canDeleteRows: V
|
|
986
997
|
};
|
|
987
998
|
}
|
|
988
999
|
function Xt(e) {
|
|
@@ -1196,7 +1207,7 @@ function $t(t) {
|
|
|
1196
1207
|
}), n[82] = o.rowStateDeleted, n[83] = c, n[84] = e) : e = n[84];
|
|
1197
1208
|
let t;
|
|
1198
1209
|
n[85] !== i || n[86] !== c ? (t = (e) => {
|
|
1199
|
-
e.stopPropagation(), i.
|
|
1210
|
+
e.stopPropagation(), i.restoreRow(c);
|
|
1200
1211
|
}, n[85] = i, n[86] = c, n[87] = t) : t = n[87];
|
|
1201
1212
|
let r;
|
|
1202
1213
|
n[88] === Symbol.for("react.memo_cache_sentinel") ? (r = /* @__PURE__ */ q(M, {
|