@omnitend/dashboard-for-laravel 0.47.0 → 0.47.2

package/dist/components/extended/DXField.vue.d.ts

@@ -41,6 +41,20 @@ interface Props {
     hideLabel?: boolean;
 }
 declare function setValue(value: any): void;
+/**
+ * `update` for the `span` and `value` slots (and so DXTable's `edit-span` /
+ * `edit-value`). Like a plain set, it clears the field's own error. When the
+ * value is an array whose rows changed (added, removed, replaced or
+ * reordered, compared by identity with the rows as last seen), it also
+ * clears every error under `<key>.` (`lines.3.price`), as the repeater's add
+ * and remove do: a per-row error would otherwise stay under whichever row
+ * now sits at its index. An update that keeps the same rows in the same
+ * order (a row editor writing the array back on each keystroke), or a
+ * value that is not an array (an `address` object), keeps the nested
+ * errors: they still name the right place. They come back on the next
+ * submit either way.
+ */
+declare function setValueFromSlot(value: any): void;
 /**
  * The `password-actions` slot's handle on the reveal state: the same state
  * the eye toggles, so the two never disagree. Refused on a `revealable: false`
@@ -51,7 +65,7 @@ declare var __VLS_1: {
     field: FieldDefinition;
     model: any;
     value: any;
-    update: typeof setValue;
+    update: typeof setValueFromSlot;
 }, __VLS_6: {
     field: FieldDefinition;
     model: any;
@@ -62,12 +76,12 @@ declare var __VLS_1: {
     field: FieldDefinition;
     model: any;
     value: any;
-    update: typeof setValue;
+    update: typeof setValueFromSlot;
 }, __VLS_12: {
     field: FieldDefinition;
     model: any;
     value: any;
-    update: typeof setValue;
+    update: typeof setValueFromSlot;
 }, __VLS_54: {
     option: FieldOption;
     on: boolean;

package/dist/components/extended/DXForm.vue.d.ts

@@ -146,7 +146,11 @@ declare function goToErrorTab(): void;
  * its key whenever its element leaves the DOM (a re-render replacing it),
  * and a moment with none at all is waited out. When no marker renders
  * within the field's render frames, or nothing in it takes focus, focus
- * moves to the selected tab's button. Exposed so a summary rendered OUTSIDE
+ * moves to the selected tab's button. When the row the error named is gone
+ * (`focusKey` is the field's key while `errorKey` names something under it:
+ * the row was removed, replaced or soft-deleted), the field's container
+ * takes focus instead of a control, since every control in it belongs to
+ * another row (`focusFieldContainer`). Exposed so a summary rendered OUTSIDE
  * the form (DXTable's modal footer) can drive it.
  */
 declare function focusErrorTarget(target: ErrorSummarySelection): Promise<void>;

package/dist/components/extended/DXFormErrorSummary.vue.d.ts

@@ -10,6 +10,16 @@ export interface ErrorSummarySelection {
     tabKey: string | null;
     /** The error key as the server sent it. */
     errorKey: string;
+    /**
+     * Where to take the user: the error key at the failed row's current
+     * index, or the field's key when that row is gone (see
+     * `ErrorTarget.focusKey`), when DXForm's `focusErrorTarget` focuses the
+     * field's container rather than any row's control. Equal to `errorKey`
+     * for everything else.
+     * Always emitted; optional so a selection built by hand for DXForm's
+     * exposed `focusErrorTarget` still types (it then uses `errorKey`).
+     */
+    focusKey?: string;
 }
 interface Props {
     /** The form: a `useForm` return or a `defineForm` return. */

package/dist/composables/useForm.d.ts

@@ -15,6 +15,36 @@ export interface SubmitFailure {
     message: string;
     /** The validation errors the submit returned (`{}` when none). */
     errors: ValidationErrors;
+    /**
+     * The rows the errors named, keyed by row path: the path up to the
+     * key's FIRST numeric segment (`lines.2` for `lines.2.price` and for
+     * `lines.2.options.0.name`; a row nested inside a row is not recorded,
+     * since the summary follows the outer row). Absent when no error key
+     * names a row that exists in the form data. The error summary uses it
+     * to keep naming and finding the row that failed after rows are removed
+     * or reordered.
+     *
+     * The rows are read from the form data when the failure response
+     * ARRIVES, not when the request was sent. Rows added, removed or
+     * reordered while the request was in flight, or a submit `transform`
+     * that drops or reorders rows, can attach an error to the wrong row
+     * here, exactly as a bare index key always could.
+     */
+    failedRows?: Record<string, FailedRow>;
+}
+/** One row a failed submit's errors named (see `SubmitFailure.failedRows`). */
+export interface FailedRow {
+    /**
+     * The row object itself (raw, not a reactive proxy), so its current
+     * index can be found by identity. A row array replaced wholesale (a
+     * reload) holds new objects, and the row then counts as gone.
+     */
+    row: object;
+    /**
+     * A copy of the row taken when the submit failed, for labels: a row's
+     * name (`rowLabel`) reads it, so later edits do not rename the error.
+     */
+    snapshot: Record<string, any>;
 }
 export interface FormSubmitOptions<TPayload = unknown, TResponse = unknown> {
     onSuccess?: (data: TResponse) => void;