@chelone/vue 0.0.0-stage → 0.1.1

package/dist/controllers/use-show-controller.js

@@ -0,0 +1,38 @@
+import { createShowController } from "@chelone/core";
+import { reactive, computed } from "vue";
+import { useCheloneContext } from "../context.js";
+import { useRequiredResource } from "../resource-context.js";
+import { useRouterAdapterOptional } from "../router/adapter.js";
+import { useMicroStore } from "../store/use-micro-store.js";
+import { toControllerContext } from "./controller-context.js";
+function resolveId(explicit) {
+  if (explicit !== void 0) return explicit;
+  const adapter = useRouterAdapterOptional();
+  const id = adapter?.useParams().value.id;
+  if (id === void 0) {
+    throw new Error(
+      "useShowController: no `id` option and no `:id` route param — pass an id or render under a show route."
+    );
+  }
+  return id;
+}
+function useShowController(options = {}) {
+  const ctx = useCheloneContext();
+  const resource = useRequiredResource("useShowController", options);
+  const id = resolveId(options.id);
+  const controller = createShowController(
+    toControllerContext(ctx),
+    resource,
+    { ...options, id }
+  );
+  const state = useMicroStore(controller);
+  return reactive({
+    record: computed(() => state.value.record),
+    isPending: computed(() => state.value.isPending),
+    isFetching: computed(() => state.value.isFetching),
+    error: computed(() => state.value.error)
+  });
+}
+export {
+  useShowController
+};

package/dist/csv-import.d.ts

@@ -0,0 +1,2 @@
+export { type CsvImportProps, default as CsvImport, } from "./components/admin/csv-import/csv-import.vue.js";
+export { useCsvImport } from "./components/admin/csv-import/use-csv-import.js";

package/dist/csv-import.js

@@ -0,0 +1,6 @@
+import { default as default2 } from "./components/admin/csv-import/csv-import.vue.js";
+import { useCsvImport } from "./components/admin/csv-import/use-csv-import.js";
+export {
+  default2 as CsvImport,
+  useCsvImport
+};

package/dist/data/create-chelone-hooks.d.ts

@@ -0,0 +1,484 @@
+/**
+ * `createCheloneHooks` — the Vue twin of `@chelone/react`'s factory. Binds every
+ * data composable to a registry type once, so each call site infers its record
+ * type and rejects an unknown resource name. Each member forwards the Vue
+ * composable's own signature, so `MaybeRefOrGetter` params stay reactive.
+ * Adds `useUpdateMany` and `useDeleteMany`, which React does not export.
+ */
+import type { GetListParams, GetManyParams, GetManyReferenceParams, GetOneParams, MutationModeOptions, ResourceMap } from "@chelone/core";
+import type { MaybeRefOrGetter } from "vue";
+type QueryOptions = {
+    enabled?: MaybeRefOrGetter<boolean>;
+};
+/**
+ * Bind the composables to a registry type once:
+ *   const hooks = createCheloneHooks<typeof resources>();
+ *   hooks.useGetList('posts')  // data: Post[]; 'nope' rejects
+ */
+export declare function createCheloneHooks<TResources extends ResourceMap>(): {
+    useGetList: <TName extends keyof TResources & string>(resource: TName, params?: MaybeRefOrGetter<GetListParams>, options?: QueryOptions) => import("@tanstack/vue-query").UseQueryReturnType<import("@chelone/core").GetListResult<import("@chelone/core").RecordOf<TResources, TName>>, Error>;
+    useGetOne: <TName extends keyof TResources & string>(resource: TName, params: MaybeRefOrGetter<GetOneParams>, options?: QueryOptions) => import("@tanstack/vue-query").UseQueryReturnType<import("@chelone/core").RecordOf<TResources, TName>, Error>;
+    useGetMany: <TName extends keyof TResources & string>(resource: TName, params: MaybeRefOrGetter<GetManyParams>, options?: QueryOptions) => import("@tanstack/vue-query").UseQueryReturnType<import("@chelone/core").RecordOf<TResources, TName>[], Error>;
+    useGetManyAggregate: <TName extends keyof TResources & string>(resource: TName, params: MaybeRefOrGetter<GetManyParams>, options?: QueryOptions) => import("@tanstack/vue-query").UseQueryReturnType<import("@chelone/core").RecordOf<TResources, TName>[], Error>;
+    useGetManyReference: <TName extends keyof TResources & string>(resource: TName, params: MaybeRefOrGetter<GetManyReferenceParams>, options?: QueryOptions) => import("@tanstack/vue-query").UseQueryReturnType<import("@chelone/core").GetManyReferenceResult<import("@chelone/core").RecordOf<TResources, TName>>, Error>;
+    useCreate: <TName extends keyof TResources & string>(resource: TName) => import("@tanstack/vue-query").UseMutationReturnType<import("@chelone/core").RecordOf<TResources, TName>, Error, import("@chelone/core").CreateParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown, Omit<import("@tanstack/query-core").MutationObserverIdleResult<import("@chelone/core").RecordOf<TResources, TName>, Error, import("@chelone/core").CreateParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverLoadingResult<import("@chelone/core").RecordOf<TResources, TName>, Error, import("@chelone/core").CreateParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverErrorResult<import("@chelone/core").RecordOf<TResources, TName>, Error, import("@chelone/core").CreateParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverSuccessResult<import("@chelone/core").RecordOf<TResources, TName>, Error, import("@chelone/core").CreateParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>;
+    useUpdate: <TName extends keyof TResources & string>(resource: TName, options?: MutationModeOptions) => import("@tanstack/vue-query").UseMutationReturnType<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").UpdateParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").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<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").UpdateParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").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<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").UpdateParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").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<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").UpdateParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").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<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").UpdateParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").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/vue-query").UseMutationReturnType<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").UpdateParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").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<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").UpdateParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").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<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").UpdateParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").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<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").UpdateParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").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<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").UpdateParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").RecordOf<TResources, TName> | undefined;
+        key: readonly [string, "getOne", {
+            id: string;
+            meta?: undefined;
+        } | {
+            id: string;
+            meta: {} | null;
+        }];
+        manySnapshot: [readonly unknown[], unknown][];
+    }>, "reset" | "mutate">>, "mutate" | "mutateAsync"> & {
+        mutate: (params: import("@chelone/core").UpdateParams<import("@chelone/core").RecordOf<TResources, TName>>, callbacks?: import("@chelone/core").UndoableCallbacks<import("@chelone/core").RecordOf<TResources, TName>, import("@chelone/core").UpdateParams<import("@chelone/core").RecordOf<TResources, TName>>> | undefined) => void;
+        mutateAsync: (params: import("@chelone/core").UpdateParams<import("@chelone/core").RecordOf<TResources, TName>>) => Promise<void>;
+    });
+    useUpdateMany: <TName extends keyof TResources & string>(resource: TName, options?: MutationModeOptions) => (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverIdleResult<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>> & {
+        mutate: (variables: import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, options?: import("@tanstack/query-core").MutateOptions<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown> | undefined) => void;
+        mutateAsync: import("@tanstack/query-core").MutateFunction<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").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<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>> & {
+        mutate: (variables: import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, options?: import("@tanstack/query-core").MutateOptions<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown> | undefined) => void;
+        mutateAsync: import("@tanstack/query-core").MutateFunction<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").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<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>> & {
+        mutate: (variables: import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, options?: import("@tanstack/query-core").MutateOptions<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown> | undefined) => void;
+        mutateAsync: import("@tanstack/query-core").MutateFunction<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").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<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>> & {
+        mutate: (variables: import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, options?: import("@tanstack/query-core").MutateOptions<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown> | undefined) => void;
+        mutateAsync: import("@tanstack/query-core").MutateFunction<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    }) | {
+        mutate: (params: import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, callbacks?: import("@chelone/core").UndoableUpdateManyCallbacks<import("@chelone/core").RecordOf<TResources, TName>> | undefined) => void;
+        mutateAsync: (params: import("@chelone/core").UpdateManyParams<import("@chelone/core").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: import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, callbacks?: import("@chelone/core").UndoableUpdateManyCallbacks<import("@chelone/core").RecordOf<TResources, TName>> | undefined) => void;
+        mutateAsync: (params: import("@chelone/core").UpdateManyParams<import("@chelone/core").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<import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, import("@chelone/core").UpdateManyParams<import("@chelone/core").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: import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, callbacks?: import("@chelone/core").UndoableUpdateManyCallbacks<import("@chelone/core").RecordOf<TResources, TName>> | undefined) => void;
+        mutateAsync: (params: import("@chelone/core").UpdateManyParams<import("@chelone/core").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<import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, import("@chelone/core").UpdateManyParams<import("@chelone/core").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: import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, callbacks?: import("@chelone/core").UndoableUpdateManyCallbacks<import("@chelone/core").RecordOf<TResources, TName>> | undefined) => void;
+        mutateAsync: (params: import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>) => Promise<void>;
+        data: import("vue").Ref<import("@chelone/core").Identifier[], import("@chelone/core").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<import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, import("@chelone/core").UpdateManyParams<import("@chelone/core").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"];
+    };
+    useDelete: <TName extends keyof TResources & string>(resource: TName, options?: MutationModeOptions) => import("@tanstack/vue-query").UseMutationReturnType<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").DeleteParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").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<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").DeleteParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").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<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").DeleteParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").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<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").DeleteParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").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<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").DeleteParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").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/vue-query").UseMutationReturnType<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").DeleteParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").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<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").DeleteParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").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<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").DeleteParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").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<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").DeleteParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").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<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").DeleteParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").RecordOf<TResources, TName> | undefined;
+        key: readonly [string, "getOne", {
+            id: string;
+            meta?: undefined;
+        } | {
+            id: string;
+            meta: {} | null;
+        }];
+        manySnapshot: [readonly unknown[], unknown][];
+    }>, "reset" | "mutate">>, "mutate" | "mutateAsync"> & {
+        mutate: (params: import("@chelone/core").DeleteParams<import("@chelone/core").RecordOf<TResources, TName>>, callbacks?: import("@chelone/core").UndoableCallbacks<import("@chelone/core").RecordOf<TResources, TName> | undefined, import("@chelone/core").DeleteParams<import("@chelone/core").RecordOf<TResources, TName>>> | undefined) => void;
+        mutateAsync: (params: import("@chelone/core").DeleteParams<import("@chelone/core").RecordOf<TResources, TName>>) => Promise<void>;
+    });
+    useDeleteMany: <TName extends keyof TResources & string>(resource: TName, options?: MutationModeOptions) => (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverIdleResult<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown>, "reset" | "mutate">>> & {
+        mutate: (variables: import("@chelone/core").DeleteManyParams, options?: import("@tanstack/query-core").MutateOptions<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown> | undefined) => void;
+        mutateAsync: import("@tanstack/query-core").MutateFunction<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    }) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverLoadingResult<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown>, "reset" | "mutate">>> & {
+        mutate: (variables: import("@chelone/core").DeleteManyParams, options?: import("@tanstack/query-core").MutateOptions<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown> | undefined) => void;
+        mutateAsync: import("@tanstack/query-core").MutateFunction<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    }) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverErrorResult<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown>, "reset" | "mutate">>> & {
+        mutate: (variables: import("@chelone/core").DeleteManyParams, options?: import("@tanstack/query-core").MutateOptions<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown> | undefined) => void;
+        mutateAsync: import("@tanstack/query-core").MutateFunction<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    }) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverSuccessResult<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown>, "reset" | "mutate">>> & {
+        mutate: (variables: import("@chelone/core").DeleteManyParams, options?: import("@tanstack/query-core").MutateOptions<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown> | undefined) => void;
+        mutateAsync: import("@tanstack/query-core").MutateFunction<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    }) | {
+        mutate: (params: import("@chelone/core").DeleteManyParams, callbacks?: import("@chelone/core").UndoableCallbacks<import("@chelone/core").Identifier[], import("@chelone/core").DeleteManyParams>) => void;
+        mutateAsync: (params: import("@chelone/core").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: import("@chelone/core").DeleteManyParams, callbacks?: import("@chelone/core").UndoableCallbacks<import("@chelone/core").Identifier[], import("@chelone/core").DeleteManyParams>) => void;
+        mutateAsync: (params: import("@chelone/core").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<import("@chelone/core").DeleteManyParams, import("@chelone/core").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: import("@chelone/core").DeleteManyParams, callbacks?: import("@chelone/core").UndoableCallbacks<import("@chelone/core").Identifier[], import("@chelone/core").DeleteManyParams>) => void;
+        mutateAsync: (params: import("@chelone/core").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<import("@chelone/core").DeleteManyParams, import("@chelone/core").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: import("@chelone/core").DeleteManyParams, callbacks?: import("@chelone/core").UndoableCallbacks<import("@chelone/core").Identifier[], import("@chelone/core").DeleteManyParams>) => void;
+        mutateAsync: (params: import("@chelone/core").DeleteManyParams) => Promise<void>;
+        data: import("vue").Ref<import("@chelone/core").Identifier[], import("@chelone/core").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<import("@chelone/core").DeleteManyParams, import("@chelone/core").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"];
+    };
+};
+export {};

package/dist/data/create-chelone-hooks.js

@@ -0,0 +1,19 @@
+import { useDeleteMany, useDelete, useUpdateMany, useUpdate, useCreate } from "./mutations.js";
+import { useGetManyReference, useGetManyAggregate, useGetMany, useGetOne, useGetList } from "./queries.js";
+function createCheloneHooks() {
+  return {
+    useGetList: (resource, params, options) => useGetList(resource, params, options),
+    useGetOne: (resource, params, options) => useGetOne(resource, params, options),
+    useGetMany: (resource, params, options) => useGetMany(resource, params, options),
+    useGetManyAggregate: (resource, params, options) => useGetManyAggregate(resource, params, options),
+    useGetManyReference: (resource, params, options) => useGetManyReference(resource, params, options),
+    useCreate: (resource) => useCreate(resource),
+    useUpdate: (resource, options) => useUpdate(resource, options),
+    useUpdateMany: (resource, options) => useUpdateMany(resource, options),
+    useDelete: (resource, options) => useDelete(resource, options),
+    useDeleteMany: (resource, options) => useDeleteMany(resource, options)
+  };
+}
+export {
+  createCheloneHooks
+};

package/dist/data/infinite-queries.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `useInfiniteGetList` — the Vue twin of `@chelone/react`'s
+ * `useInfiniteGetList`: `useInfiniteQuery` over core's
+ * `getInfiniteListOptions`. A new `params` value is a new query and starts
+ * over. Kept apart from `queries.ts` so the two grow independently.
+ */
+import { type InfiniteListParams, type ResourceMap } from "@chelone/core";
+import { type MaybeRefOrGetter } from "vue";
+/** Read a list page by page, reactively. `enabled` gates the fetch. */
+export declare function useInfiniteGetList<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: TName, params: MaybeRefOrGetter<InfiniteListParams>, options?: {
+    enabled?: MaybeRefOrGetter<boolean>;
+    staleTime?: MaybeRefOrGetter<number>;
+}): import("@tanstack/vue-query").UseInfiniteQueryReturnType<import("@tanstack/query-core").InfiniteData<import("@chelone/core").GetListResult<import("@chelone/core").RecordOf<TResources, TName>>, unknown>, Error>;

package/dist/data/infinite-queries.js

@@ -0,0 +1,17 @@
+import { getInfiniteListOptions } from "@chelone/core";
+import { useInfiniteQuery } from "@tanstack/vue-query";
+import { computed, toValue } from "vue";
+import { useCheloneContext } from "../context.js";
+function useInfiniteGetList(resource, params, options = {}) {
+  const ctx = useCheloneContext();
+  return useInfiniteQuery(
+    computed(() => ({
+      ...getInfiniteListOptions(ctx, resource, toValue(params)),
+      enabled: options.enabled === void 0 ? true : toValue(options.enabled),
+      ...options.staleTime === void 0 ? {} : { staleTime: toValue(options.staleTime) }
+    }))
+  );
+}
+export {
+  useInfiniteGetList
+};