@chelone/vue 0.1.0 → 0.2.0

package/dist/data/mutations.d.ts

@@ -14,7 +14,17 @@
  * vanilla `startUndoableMutation` engine + an Undo notification. The default
  * (`"pessimistic"`) path is unchanged.
  */
-import { type DeleteManyParams, type DeleteParams, type MutationModeOptions, type RecordOf, type ResourceMap, type UpdateManyParams, type UpdateParams } from "@chelone/core";
+import { type DeleteManyParams, type DeleteParams, type Identifier, type MutationModeOptions, type RecordOf, type ResourceMap, type UndoableCallbacks, type UndoableUpdateManyCallbacks, type UpdateManyParams, type UpdateParams } from "@chelone/core";
+/**
+ * A mutation whose `mutate` / `mutateAsync` are swapped for the undoable pair,
+ * the state refs untouched. Naming it keeps the hook's inferred type
+ * declaration-emittable: spreading vue-query's refs over a generic record type
+ * would expand to `@vue/shared` types a `.d.ts` cannot name.
+ */
+type Undoable<TMutation, TParams, TData> = Omit<TMutation, "mutate" | "mutateAsync"> & {
+    mutate: (params: TParams, callbacks?: UndoableCallbacks<TData, TParams>) => void;
+    mutateAsync: (params: TParams) => Promise<void>;
+};
 /**
  * Create mutation for `resource` — the Vue twin of `@chelone/react`'s
  * `useCreate(resource)`. Call `.mutateAsync({ data })` to dispatch; the
@@ -98,7 +108,77 @@ export declare function useUpdate<TResources extends ResourceMap = ResourceMap,
         meta: {} | null;
     }];
     manySnapshot: [readonly unknown[], unknown][];
-}>, "reset" | "mutate">>;
+}>, "reset" | "mutate">> | Undoable<import("@tanstack/vue-query").UseMutationReturnType<RecordOf<TResources, TName>, unknown, UpdateParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}, Omit<import("@tanstack/query-core").MutationObserverIdleResult<RecordOf<TResources, TName>, unknown, UpdateParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverLoadingResult<RecordOf<TResources, TName>, unknown, UpdateParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverErrorResult<RecordOf<TResources, TName>, unknown, UpdateParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverSuccessResult<RecordOf<TResources, TName>, unknown, UpdateParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate">>, UpdateParams<RecordOf<TResources, TName>>, RecordOf<TResources, TName>>;
 /**
  * Delete-one mutation for `resource`. Returns vue-query's mutation object; call
  * `.mutateAsync({ id, previousData })` to dispatch. Mirrors the React delete
@@ -177,7 +257,77 @@ export declare function useDelete<TResources extends ResourceMap = ResourceMap,
         meta: {} | null;
     }];
     manySnapshot: [readonly unknown[], unknown][];
-}>, "reset" | "mutate">>;
+}>, "reset" | "mutate">> | Undoable<import("@tanstack/vue-query").UseMutationReturnType<RecordOf<TResources, TName>, unknown, DeleteParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}, Omit<import("@tanstack/query-core").MutationObserverIdleResult<RecordOf<TResources, TName>, unknown, DeleteParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverLoadingResult<RecordOf<TResources, TName>, unknown, DeleteParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverErrorResult<RecordOf<TResources, TName>, unknown, DeleteParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverSuccessResult<RecordOf<TResources, TName>, unknown, DeleteParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate">>, DeleteParams<RecordOf<TResources, TName>>, RecordOf<TResources, TName> | undefined>;
 /**
  * Delete-many mutation for `resource` — the Vue twin of the bulk delete path
  * `@chelone/react`'s `<BulkDeleteButton>` fires against
@@ -190,7 +340,91 @@ export declare function useDelete<TResources extends ResourceMap = ResourceMap,
  * `mutateAsync` for the optimistic-with-Undo flow (remove the rows now, defer the
  * server call until the Undo window closes) via the core `startUndoableMutation`.
  */
-export declare function useDeleteMany<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: TName, options?: MutationModeOptions): import("@tanstack/vue-query").UseMutationReturnType<import("@chelone/core").Identifier[], Error, DeleteManyParams, unknown, Omit<import("@tanstack/query-core").MutationObserverIdleResult<import("@chelone/core").Identifier[], Error, DeleteManyParams, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverLoadingResult<import("@chelone/core").Identifier[], Error, DeleteManyParams, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverErrorResult<import("@chelone/core").Identifier[], Error, DeleteManyParams, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverSuccessResult<import("@chelone/core").Identifier[], Error, DeleteManyParams, unknown>, "reset" | "mutate">>;
+export declare function useDeleteMany<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: TName, options?: MutationModeOptions): (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverIdleResult<Identifier[], Error, DeleteManyParams, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: DeleteManyParams, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, DeleteManyParams, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, DeleteManyParams, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverLoadingResult<Identifier[], Error, DeleteManyParams, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: DeleteManyParams, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, DeleteManyParams, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, DeleteManyParams, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverErrorResult<Identifier[], Error, DeleteManyParams, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: DeleteManyParams, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, DeleteManyParams, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, DeleteManyParams, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverSuccessResult<Identifier[], Error, DeleteManyParams, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: DeleteManyParams, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, DeleteManyParams, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, DeleteManyParams, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | {
+    mutate: (params: DeleteManyParams, callbacks?: UndoableCallbacks<Identifier[], DeleteManyParams>) => void;
+    mutateAsync: (params: DeleteManyParams) => Promise<void>;
+    data: import("vue").Ref<undefined, undefined>;
+    error: import("vue").Ref<null, null>;
+    status: import("vue").Ref<"idle", "idle">;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<false, false>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<undefined, undefined>;
+    isIdle: import("vue").Ref<true, true>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+} | {
+    mutate: (params: DeleteManyParams, callbacks?: UndoableCallbacks<Identifier[], DeleteManyParams>) => void;
+    mutateAsync: (params: DeleteManyParams) => Promise<void>;
+    data: import("vue").Ref<undefined, undefined>;
+    error: import("vue").Ref<null, null>;
+    status: import("vue").Ref<"pending", "pending">;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<true, true>;
+    isSuccess: import("vue").Ref<false, false>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<DeleteManyParams, DeleteManyParams>;
+    isIdle: import("vue").Ref<false, false>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+} | {
+    mutate: (params: DeleteManyParams, callbacks?: UndoableCallbacks<Identifier[], DeleteManyParams>) => void;
+    mutateAsync: (params: DeleteManyParams) => Promise<void>;
+    data: import("vue").Ref<undefined, undefined>;
+    error: import("vue").Ref<Error, Error>;
+    status: import("vue").Ref<"error", "error">;
+    isError: import("vue").Ref<true, true>;
+    isPending: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<false, false>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<DeleteManyParams, DeleteManyParams>;
+    isIdle: import("vue").Ref<false, false>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+} | {
+    mutate: (params: DeleteManyParams, callbacks?: UndoableCallbacks<Identifier[], DeleteManyParams>) => void;
+    mutateAsync: (params: DeleteManyParams) => Promise<void>;
+    data: import("vue").Ref<Identifier[], Identifier[]>;
+    error: import("vue").Ref<null, null>;
+    status: import("vue").Ref<"success", "success">;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<true, true>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<DeleteManyParams, DeleteManyParams>;
+    isIdle: import("vue").Ref<false, false>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+};
 /**
  * Update-many mutation for `resource` — the Vue twin of the bulk update path
  * `@chelone/react`'s `<BulkUpdateButton>` fires against
@@ -199,4 +433,89 @@ export declare function useDeleteMany<TResources extends ResourceMap = ResourceM
  * invalidates the resource's caches on settle. Call `.mutateAsync({ ids, data })`
  * to dispatch; `<BulkUpdateButton>` then clears the selection + notifies.
  */
-export declare function useUpdateMany<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: TName, options?: MutationModeOptions): import("@tanstack/vue-query").UseMutationReturnType<import("@chelone/core").Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown, Omit<import("@tanstack/query-core").MutationObserverIdleResult<import("@chelone/core").Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverLoadingResult<import("@chelone/core").Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverErrorResult<import("@chelone/core").Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverSuccessResult<import("@chelone/core").Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>;
+export declare function useUpdateMany<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: TName, options?: MutationModeOptions): (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverIdleResult<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: UpdateManyParams<RecordOf<TResources, TName>>, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverLoadingResult<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: UpdateManyParams<RecordOf<TResources, TName>>, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverErrorResult<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: UpdateManyParams<RecordOf<TResources, TName>>, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverSuccessResult<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: UpdateManyParams<RecordOf<TResources, TName>>, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | {
+    mutate: (params: UpdateManyParams<RecordOf<TResources, TName>>, callbacks?: UndoableUpdateManyCallbacks<RecordOf<TResources, TName>>) => void;
+    mutateAsync: (params: UpdateManyParams<RecordOf<TResources, TName>>) => Promise<void>;
+    data: import("vue").Ref<undefined, undefined>;
+    error: import("vue").Ref<null, null>;
+    status: import("vue").Ref<"idle", "idle">;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<false, false>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<undefined, undefined>;
+    isIdle: import("vue").Ref<true, true>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+} | {
+    mutate: (params: UpdateManyParams<RecordOf<TResources, TName>>, callbacks?: UndoableUpdateManyCallbacks<RecordOf<TResources, TName>>) => void;
+    mutateAsync: (params: UpdateManyParams<RecordOf<TResources, TName>>) => Promise<void>;
+    data: import("vue").Ref<undefined, undefined>;
+    error: import("vue").Ref<null, null>;
+    status: import("vue").Ref<"pending", "pending">;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<true, true>;
+    isSuccess: import("vue").Ref<false, false>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<UpdateManyParams<RecordOf<TResources, TName>>, UpdateManyParams<RecordOf<TResources, TName>>>;
+    isIdle: import("vue").Ref<false, false>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+} | {
+    mutate: (params: UpdateManyParams<RecordOf<TResources, TName>>, callbacks?: UndoableUpdateManyCallbacks<RecordOf<TResources, TName>>) => void;
+    mutateAsync: (params: UpdateManyParams<RecordOf<TResources, TName>>) => Promise<void>;
+    data: import("vue").Ref<undefined, undefined>;
+    error: import("vue").Ref<Error, Error>;
+    status: import("vue").Ref<"error", "error">;
+    isError: import("vue").Ref<true, true>;
+    isPending: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<false, false>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<UpdateManyParams<RecordOf<TResources, TName>>, UpdateManyParams<RecordOf<TResources, TName>>>;
+    isIdle: import("vue").Ref<false, false>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+} | {
+    mutate: (params: UpdateManyParams<RecordOf<TResources, TName>>, callbacks?: UndoableUpdateManyCallbacks<RecordOf<TResources, TName>>) => void;
+    mutateAsync: (params: UpdateManyParams<RecordOf<TResources, TName>>) => Promise<void>;
+    data: import("vue").Ref<Identifier[], Identifier[]>;
+    error: import("vue").Ref<null, null>;
+    status: import("vue").Ref<"success", "success">;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<true, true>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<UpdateManyParams<RecordOf<TResources, TName>>, UpdateManyParams<RecordOf<TResources, TName>>>;
+    isIdle: import("vue").Ref<false, false>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+};
+export {};

package/dist/data/mutations.js

@@ -1,4 +1,4 @@
-import { updateMutationOptions, resourceKey, createMutationOptions, deleteMutationOptions, updateRecordsInCache, removeRecordsFromCache } from "@chelone/core";
+import { updateMutationOptions, resourceKey, createMutationOptions, deleteMutationOptions, undoableCallbacks, undoableUpdateOptions, patchedRecord, undoableDeleteOptions } from "@chelone/core";
 import { useMutation } from "@tanstack/vue-query";
 import { useCheloneContext } from "../context.js";
 import { useUndoable } from "./undoable.js";
@@ -11,45 +11,49 @@ function useUpdate(resource, options = {}) {
   const runUndoable = useUndoable();
   const mutation = useMutation(updateMutationOptions(ctx, resource, options));
   if (options.mutationMode !== "undoable") return mutation;
-  const mutate = (params) => {
+  const mutate = (params, callbacks) => {
+    const settle = undoableCallbacks(params, callbacks);
     runUndoable({
-      queryKeys: [[resource]],
-      applyOptimistic: () => updateRecordsInCache(
+      ...undoableUpdateOptions(
         ctx.queryClient,
         resource,
         [params.id],
         params.data
       ),
-      commit: () => ctx.dataProvider.update(resource, params),
-      message: "chelone.notification.updated",
-      messageArgs: { smart_count: 1 }
+      commit: settle.commit(() => ctx.dataProvider.update(resource, params))
     });
+    settle.success(patchedRecord(params));
   };
-  mutation.mutate = mutate;
-  mutation.mutateAsync = (async (params) => {
-    mutate(params);
-  });
-  return mutation;
+  const undoable = {
+    ...mutation,
+    mutate,
+    mutateAsync: async (params) => {
+      mutate(params);
+    }
+  };
+  return undoable;
 }
 function useDelete(resource, options = {}) {
   const ctx = useCheloneContext();
   const runUndoable = useUndoable();
   const mutation = useMutation(deleteMutationOptions(ctx, resource, options));
   if (options.mutationMode !== "undoable") return mutation;
-  const mutate = (params) => {
+  const mutate = (params, callbacks) => {
+    const settle = undoableCallbacks(params, callbacks);
     runUndoable({
-      queryKeys: [[resource]],
-      applyOptimistic: () => removeRecordsFromCache(ctx.queryClient, resource, [params.id]),
-      commit: () => ctx.dataProvider.delete(resource, params),
-      message: "chelone.notification.deleted",
-      messageArgs: { smart_count: 1 }
+      ...undoableDeleteOptions(ctx.queryClient, resource, [params.id]),
+      commit: settle.commit(() => ctx.dataProvider.delete(resource, params))
     });
+    settle.success(params.previousData);
   };
-  mutation.mutate = mutate;
-  mutation.mutateAsync = (async (params) => {
-    mutate(params);
-  });
-  return mutation;
+  const undoable = {
+    ...mutation,
+    mutate,
+    mutateAsync: async (params) => {
+      mutate(params);
+    }
+  };
+  return undoable;
 }
 function useDeleteMany(resource, options = {}) {
   const ctx = useCheloneContext();
@@ -62,20 +66,23 @@ function useDeleteMany(resource, options = {}) {
     onSettled: () => ctx.queryClient.invalidateQueries({ queryKey: resourceKey(resource) })
   });
   if (options.mutationMode !== "undoable") return mutation;
-  const mutate = (params) => {
+  const mutate = (params, callbacks) => {
+    const settle = undoableCallbacks(params, callbacks);
     runUndoable({
-      queryKeys: [[resource]],
-      applyOptimistic: () => removeRecordsFromCache(ctx.queryClient, resource, params.ids),
-      commit: () => ctx.dataProvider.deleteMany(resource, params),
-      message: "chelone.notification.deleted",
-      messageArgs: { smart_count: params.ids.length }
+      ...undoableDeleteOptions(ctx.queryClient, resource, params.ids),
+      commit: settle.commit(
+        () => ctx.dataProvider.deleteMany(resource, params)
+      )
     });
+    settle.success(params.ids);
+  };
+  return {
+    ...mutation,
+    mutate,
+    mutateAsync: async (params) => {
+      mutate(params);
+    }
   };
-  mutation.mutate = mutate;
-  mutation.mutateAsync = (async (params) => {
-    mutate(params);
-  });
-  return mutation;
 }
 function useUpdateMany(resource, options = {}) {
   const ctx = useCheloneContext();
@@ -88,25 +95,28 @@ function useUpdateMany(resource, options = {}) {
     onSettled: () => ctx.queryClient.invalidateQueries({ queryKey: resourceKey(resource) })
   });
   if (options.mutationMode !== "undoable") return mutation;
-  const mutate = (params) => {
+  const mutate = (params, callbacks) => {
+    const settle = undoableCallbacks(params, callbacks);
     runUndoable({
-      queryKeys: [[resource]],
-      applyOptimistic: () => updateRecordsInCache(
+      ...undoableUpdateOptions(
         ctx.queryClient,
         resource,
         params.ids,
         params.data
       ),
-      commit: () => ctx.dataProvider.updateMany(resource, params),
-      message: "chelone.notification.updated",
-      messageArgs: { smart_count: params.ids.length }
+      commit: settle.commit(
+        () => ctx.dataProvider.updateMany(resource, params)
+      )
     });
+    settle.success(params.ids);
+  };
+  return {
+    ...mutation,
+    mutate,
+    mutateAsync: async (params) => {
+      mutate(params);
+    }
   };
-  mutation.mutate = mutate;
-  mutation.mutateAsync = (async (params) => {
-    mutate(params);
-  });
-  return mutation;
 }
 export {
   useCreate,

package/dist/list/use-list.js

@@ -1,4 +1,4 @@
-import { createClientListController } from "@chelone/core";
+import { createClientListController, listControllerActions } from "@chelone/core";
 import { toValue, watch, reactive, computed } from "vue";
 import { useMicroStore } from "../store/use-micro-store.js";
 function useList(options = {}) {
@@ -40,18 +40,7 @@ function useList(options = {}) {
     selectedIds: computed(() => state.value.selectedIds),
     hasNextPage: computed(() => state.value.hasNextPage),
     hasPreviousPage: computed(() => state.value.hasPreviousPage),
-    setPage: controller.setPage,
-    setPerPage: controller.setPerPage,
-    setSort: controller.setSort,
-    setFilters: controller.setFilters,
-    setParams: controller.setParams,
-    showFilter: controller.showFilter,
-    hideFilter: controller.hideFilter,
-    select: controller.select,
-    toggleItem: controller.toggleItem,
-    unselectAll: controller.unselectAll,
-    selectAll: controller.selectAll,
-    refetch: controller.refetch
+    ...listControllerActions(controller)
   });
 }
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chelone/vue",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -57,7 +57,7 @@
   "dependencies": {
     "cronstrue": "^3.24.0",
     "libphonenumber-js": "^1.13.8",
-    "@chelone/core": "0.1.0"
+    "@chelone/core": "0.2.0"
   },
   "peerDependencies": {
     "@guolao/vue-monaco-editor": "^1.6.0",
@@ -76,7 +76,7 @@
     "terra-draw-maplibre-gl-adapter": "^1.5.0",
     "vue": "^3.4.0",
     "vue-router": "^4.0.0",
-    "@chelone/supabase": "0.1.0"
+    "@chelone/supabase": "0.2.0"
   },
   "peerDependenciesMeta": {
     "@chelone/supabase": {
@@ -150,7 +150,7 @@
     "vue-router": "^4.0.0",
     "vue-tsc": "^2.0.0",
     "zod": "^3.24.0",
-    "@chelone/supabase": "0.1.0"
+    "@chelone/supabase": "0.2.0"
   },
   "scripts": {
     "build": "vite build && vue-tsc -p tsconfig.build.json && node ../../scripts/strip-dts-css-imports.mjs dist && node ../../scripts/dts-extensions.mjs dist",