@chelone/vue 0.5.0 → 0.7.0

package/dist/data/mutations.js

@@ -1,127 +1,160 @@
-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";
+import { createMutationOptions, deleteMutationOptions, patchedRecord, resourceKey, undoableCallbacks, undoableDeleteOptions, undoableUpdateOptions, updateMutationOptions } from "@chelone/core";
+import { useMutation } from "@tanstack/vue-query";
+// src/data/mutations.ts
+/**
+* Data-mutation composables over `@tanstack/vue-query` — the Vue twin of the
+* mutation half of `@chelone/react`'s `hooks.ts` (`useUpdate` / `useDelete` +
+* the bulk pair). Wraps core's framework-agnostic `updateMutationOptions` /
+* `deleteMutationOptions` (`mutationFn` + cache invalidation) and hands it to
+* vue-query's `useMutation`, reusing the SAME `dataProvider` + `queryClient`
+* `<Admin>` provides. `<ApiKeyInput>` is the first consumer: it is NOT form-bound
+* — it reads the ambient record/resource and dispatches this mutation directly
+* to trigger a server-side key rotation.
+*
+* R3: each composable honors `options.mutationMode: "undoable"` by swapping its
+* `mutate` / `mutateAsync` for the optimistic-with-Undo flow (apply the cache
+* change now, defer the dataProvider call until the Undo window closes) via the
+* vanilla `startUndoableMutation` engine + an Undo notification. The default
+* (`"pessimistic"`) path is unchanged.
+*/
+/**
+* Create mutation for `resource` — the Vue twin of `@chelone/react`'s
+* `useCreate(resource)`. Call `.mutateAsync({ data })` to dispatch; the
+* resource's caches are invalidated on settle. Takes no mutation mode (create
+* has no record to patch optimistically), as React's does not.
+*/
 function useCreate(resource) {
-  const ctx = useCheloneContext();
-  return useMutation(createMutationOptions(ctx, resource));
+	const ctx = useCheloneContext();
+	return useMutation(createMutationOptions(ctx, resource));
 }
+/**
+* Update-one mutation for `resource`. Returns vue-query's mutation object; call
+* `.mutateAsync({ id, data, previousData })` to dispatch. Mirrors the React
+* `useUpdate(resource)` — `updateMutationOptions` binds the resource at call
+* time and invalidates that resource's caches on settle.
+*/
 function useUpdate(resource, options = {}) {
-  const ctx = useCheloneContext();
-  const runUndoable = useUndoable();
-  const mutation = useMutation(updateMutationOptions(ctx, resource, options));
-  if (options.mutationMode !== "undoable") return mutation;
-  const mutate = (params, callbacks) => {
-    const settle = undoableCallbacks(params, callbacks);
-    runUndoable({
-      ...undoableUpdateOptions(
-        ctx.queryClient,
-        resource,
-        [params.id],
-        params.data
-      ),
-      commit: settle.commit(() => ctx.dataProvider.update(resource, params))
-    });
-    settle.success(patchedRecord(params));
-  };
-  const undoable = {
-    ...mutation,
-    mutate,
-    mutateAsync: async (params) => {
-      mutate(params);
-    }
-  };
-  return undoable;
+	const ctx = useCheloneContext();
+	const runUndoable = useUndoable();
+	const mutation = useMutation(updateMutationOptions(ctx, resource, options));
+	if (options.mutationMode !== "undoable") return mutation;
+	const mutate = (params, callbacks) => {
+		const settle = undoableCallbacks(params, callbacks);
+		runUndoable({
+			...undoableUpdateOptions(ctx.queryClient, resource, [params.id], params.data),
+			commit: settle.commit(() => ctx.dataProvider.update(resource, params))
+		});
+		settle.success(patchedRecord(params));
+	};
+	return {
+		...mutation,
+		mutate,
+		mutateAsync: async (params) => {
+			mutate(params);
+		}
+	};
 }
+/**
+* Delete-one mutation for `resource`. Returns vue-query's mutation object; call
+* `.mutateAsync({ id, previousData })` to dispatch. Mirrors the React delete
+* stack — `deleteMutationOptions` binds the resource at call time and
+* invalidates that resource's caches on settle. `<DeleteButton>` is the first
+* consumer: it dispatches this on confirm, then redirects + notifies itself
+* (chelone has no baked-in delete controller yet — see the button's header).
+*/
 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, callbacks) => {
-    const settle = undoableCallbacks(params, callbacks);
-    runUndoable({
-      ...undoableDeleteOptions(ctx.queryClient, resource, [params.id]),
-      commit: settle.commit(() => ctx.dataProvider.delete(resource, params))
-    });
-    settle.success(params.previousData);
-  };
-  const undoable = {
-    ...mutation,
-    mutate,
-    mutateAsync: async (params) => {
-      mutate(params);
-    }
-  };
-  return undoable;
+	const ctx = useCheloneContext();
+	const runUndoable = useUndoable();
+	const mutation = useMutation(deleteMutationOptions(ctx, resource, options));
+	if (options.mutationMode !== "undoable") return mutation;
+	const mutate = (params, callbacks) => {
+		const settle = undoableCallbacks(params, callbacks);
+		runUndoable({
+			...undoableDeleteOptions(ctx.queryClient, resource, [params.id]),
+			commit: settle.commit(() => ctx.dataProvider.delete(resource, params))
+		});
+		settle.success(params.previousData);
+	};
+	return {
+		...mutation,
+		mutate,
+		mutateAsync: async (params) => {
+			mutate(params);
+		}
+	};
 }
+/**
+* Delete-many mutation for `resource` — the Vue twin of the bulk delete path
+* `@chelone/react`'s `<BulkDeleteButton>` fires against
+* `dataProvider.deleteMany`. Core carries NO `deleteManyMutationOptions` (there
+* is no bulk mutation-options helper), so this wraps `dataProvider.deleteMany`
+* itself and invalidates the resource's caches on settle (the same
+* `resourceKey` scope core's single-record helpers invalidate). Call
+* `.mutateAsync({ ids })` to dispatch; `<BulkDeleteButton>` then clears the
+* selection + notifies. `options.mutationMode: "undoable"` swaps `mutate` /
+* `mutateAsync` for the optimistic-with-Undo flow (remove the rows now, defer the
+* server call until the Undo window closes) via the core `startUndoableMutation`.
+*/
 function useDeleteMany(resource, options = {}) {
-  const ctx = useCheloneContext();
-  const runUndoable = useUndoable();
-  const mutation = useMutation({
-    mutationFn: async (params) => {
-      const result = await ctx.dataProvider.deleteMany(resource, params);
-      return result.data;
-    },
-    onSettled: () => ctx.queryClient.invalidateQueries({ queryKey: resourceKey(resource) })
-  });
-  if (options.mutationMode !== "undoable") return mutation;
-  const mutate = (params, callbacks) => {
-    const settle = undoableCallbacks(params, callbacks);
-    runUndoable({
-      ...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);
-    }
-  };
+	const ctx = useCheloneContext();
+	const runUndoable = useUndoable();
+	const mutation = useMutation({
+		mutationFn: async (params) => {
+			return (await ctx.dataProvider.deleteMany(resource, params)).data;
+		},
+		onSettled: () => ctx.queryClient.invalidateQueries({ queryKey: resourceKey(resource) })
+	});
+	if (options.mutationMode !== "undoable") return mutation;
+	const mutate = (params, callbacks) => {
+		const settle = undoableCallbacks(params, callbacks);
+		runUndoable({
+			...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);
+		}
+	};
 }
+/**
+* Update-many mutation for `resource` — the Vue twin of the bulk update path
+* `@chelone/react`'s `<BulkUpdateButton>` fires against
+* `dataProvider.updateMany`. Like {@link useDeleteMany}, core has no bulk
+* mutation-options helper, so this wraps `dataProvider.updateMany` itself and
+* invalidates the resource's caches on settle. Call `.mutateAsync({ ids, data })`
+* to dispatch; `<BulkUpdateButton>` then clears the selection + notifies.
+*/
 function useUpdateMany(resource, options = {}) {
-  const ctx = useCheloneContext();
-  const runUndoable = useUndoable();
-  const mutation = useMutation({
-    mutationFn: async (params) => {
-      const result = await ctx.dataProvider.updateMany(resource, params);
-      return result.data;
-    },
-    onSettled: () => ctx.queryClient.invalidateQueries({ queryKey: resourceKey(resource) })
-  });
-  if (options.mutationMode !== "undoable") return mutation;
-  const mutate = (params, callbacks) => {
-    const settle = undoableCallbacks(params, callbacks);
-    runUndoable({
-      ...undoableUpdateOptions(
-        ctx.queryClient,
-        resource,
-        params.ids,
-        params.data
-      ),
-      commit: settle.commit(
-        () => ctx.dataProvider.updateMany(resource, params)
-      )
-    });
-    settle.success(params.ids);
-  };
-  return {
-    ...mutation,
-    mutate,
-    mutateAsync: async (params) => {
-      mutate(params);
-    }
-  };
+	const ctx = useCheloneContext();
+	const runUndoable = useUndoable();
+	const mutation = useMutation({
+		mutationFn: async (params) => {
+			return (await ctx.dataProvider.updateMany(resource, params)).data;
+		},
+		onSettled: () => ctx.queryClient.invalidateQueries({ queryKey: resourceKey(resource) })
+	});
+	if (options.mutationMode !== "undoable") return mutation;
+	const mutate = (params, callbacks) => {
+		const settle = undoableCallbacks(params, callbacks);
+		runUndoable({
+			...undoableUpdateOptions(ctx.queryClient, resource, params.ids, params.data),
+			commit: settle.commit(() => ctx.dataProvider.updateMany(resource, params))
+		});
+		settle.success(params.ids);
+	};
+	return {
+		...mutation,
+		mutate,
+		mutateAsync: async (params) => {
+			mutate(params);
+		}
+	};
 }
-export {
-  useCreate,
-  useDelete,
-  useDeleteMany,
-  useUpdate,
-  useUpdateMany
-};
+export { useCreate, useDelete, useDeleteMany, useUpdate, useUpdateMany };

package/dist/data/queries.d.ts

@@ -36,13 +36,16 @@ export declare function useGetMany<TResources extends ResourceMap = ResourceMap,
 export declare function useGetManyAggregate<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: TName, params: MaybeRefOrGetter<GetManyParams>, options?: {
     enabled?: MaybeRefOrGetter<boolean>;
 }): import("@tanstack/vue-query").UseQueryReturnType<import("@chelone/core").RecordOf<TResources, TName>[], Error>;
+/** `refetchInterval` is in ms; `0`, a negative number or `false` turns polling off. */
+export type ListQueryOptions = {
+    enabled?: MaybeRefOrGetter<boolean>;
+    refetchInterval?: MaybeRefOrGetter<number | false>;
+};
 /**
  * Fetch a page of records, reactively. `resource` may be a ref or getter, so a
  * changing resource re-keys the query.
  */
-export declare function useGetList<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: MaybeRefOrGetter<TName>, params?: MaybeRefOrGetter<GetListParams>, options?: {
-    enabled?: MaybeRefOrGetter<boolean>;
-}): import("@tanstack/vue-query").UseQueryReturnType<import("@chelone/core").GetListResult<import("@chelone/core").RecordOf<TResources, TName>>, Error>;
+export declare function useGetList<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: MaybeRefOrGetter<TName>, params?: MaybeRefOrGetter<GetListParams>, options?: ListQueryOptions): import("@tanstack/vue-query").UseQueryReturnType<import("@chelone/core").GetListResult<import("@chelone/core").RecordOf<TResources, TName>>, Error>;
 /** Fetch the records whose `target` field equals `id`, reactively. */
 export declare function useGetManyReference<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: TName, params: MaybeRefOrGetter<GetManyReferenceParams>, options?: {
     enabled?: MaybeRefOrGetter<boolean>;

package/dist/data/queries.js

@@ -1,56 +1,77 @@
-import { getListOptions, getManyAggregateOptions, getManyReferenceOptions, getManyOptions, getOneOptions } from "@chelone/core";
-import { useQuery } from "@tanstack/vue-query";
-import { computed, toValue } from "vue";
 import { useCheloneContext } from "../context.js";
+import { computed, toValue } from "vue";
+import { getListOptions, getManyAggregateOptions, getManyOptions, getManyReferenceOptions, getOneOptions } from "@chelone/core";
+import { useQuery } from "@tanstack/vue-query";
+// src/data/queries.ts
+/**
+* Data-fetch composables over `@tanstack/vue-query` — the Vue twin of
+* `@chelone/react`'s `hooks.ts` (`useGetOne` / `useGetMany` / `useGetList` /
+* `useGetManyAggregate` / `useGetManyReference`). A `<ReferenceField>`
+* resolves a to-one record, a `<ReferenceInput>` fetches choices. Each wraps
+* core's framework-agnostic `getOneOptions` / `getManyOptions` /
+* `getManyAggregateOptions` / `getListOptions` /
+* `getManyReferenceOptions` (queryKey + queryFn) and hands them to
+* vue-query's `useQuery`, reusing the SAME `dataProvider` + `queryClient`
+* `<Admin>` provides (it installs the vue-query client under `VUE_QUERY_CLIENT`).
+*
+* The controllers (Task 5) drive their fetches through core's own query-core
+* observers; these standalone reads use vue-query directly because a field /
+* choices fetch has no controller — it is a plain cached query. Options are
+* passed as a `computed` so a reactive param (the FK id off a resolving record)
+* re-keys the query when it changes.
+*/
+/** Fetch one record by id, reactively. `enabled` gates the fetch (skip a null id). */
 function useGetOne(resource, params, options = {}) {
-  const ctx = useCheloneContext();
-  return useQuery(
-    computed(() => ({
-      ...getOneOptions(ctx, resource, toValue(params)),
-      enabled: options.enabled === void 0 ? true : toValue(options.enabled)
-    }))
-  );
+	const ctx = useCheloneContext();
+	return useQuery(computed(() => ({
+		...getOneOptions(ctx, resource, toValue(params)),
+		enabled: options.enabled === void 0 ? true : toValue(options.enabled)
+	})));
 }
+/**
+* Fetch many records by an array of ids, reactively — the Vue twin of
+* `@chelone/react`'s `useGetMany`. Backs `<ReferenceArrayField>` (resolve an
+* FK array to its records). `enabled` gates the fetch (skip an empty id list).
+*/
 function useGetMany(resource, params, options = {}) {
-  const ctx = useCheloneContext();
-  return useQuery(
-    computed(() => ({
-      ...getManyOptions(ctx, resource, toValue(params)),
-      enabled: options.enabled === void 0 ? true : toValue(options.enabled)
-    }))
-  );
+	const ctx = useCheloneContext();
+	return useQuery(computed(() => ({
+		...getManyOptions(ctx, resource, toValue(params)),
+		enabled: options.enabled === void 0 ? true : toValue(options.enabled)
+	})));
 }
+/**
+* Same result as `useGetMany`, but reads started in the same tick by any
+* component reach the data provider as one `getMany` per resource.
+*/
 function useGetManyAggregate(resource, params, options = {}) {
-  const ctx = useCheloneContext();
-  return useQuery(
-    computed(() => ({
-      ...getManyAggregateOptions(ctx, resource, toValue(params)),
-      enabled: options.enabled === void 0 ? true : toValue(options.enabled)
-    }))
-  );
+	const ctx = useCheloneContext();
+	return useQuery(computed(() => ({
+		...getManyAggregateOptions(ctx, resource, toValue(params)),
+		enabled: options.enabled === void 0 ? true : toValue(options.enabled)
+	})));
 }
+/**
+* Fetch a page of records, reactively. `resource` may be a ref or getter, so a
+* changing resource re-keys the query.
+*/
 function useGetList(resource, params = {}, options = {}) {
-  const ctx = useCheloneContext();
-  return useQuery(
-    computed(() => ({
-      ...getListOptions(ctx, toValue(resource), toValue(params)),
-      enabled: options.enabled === void 0 ? true : toValue(options.enabled)
-    }))
-  );
+	const ctx = useCheloneContext();
+	return useQuery(computed(() => {
+		const interval = toValue(options.refetchInterval);
+		return {
+			...getListOptions(ctx, toValue(resource), toValue(params)),
+			enabled: options.enabled === void 0 ? true : toValue(options.enabled),
+			refetchInterval: typeof interval === "number" && interval > 0 ? interval : false
+		};
+	}));
 }
+/** Fetch the records whose `target` field equals `id`, reactively. */
 function useGetManyReference(resource, params, options = {}) {
-  const ctx = useCheloneContext();
-  return useQuery(
-    computed(() => ({
-      ...getManyReferenceOptions(ctx, resource, toValue(params)),
-      enabled: options.enabled === void 0 ? true : toValue(options.enabled)
-    }))
-  );
+	const ctx = useCheloneContext();
+	return useQuery(computed(() => ({
+		...getManyReferenceOptions(ctx, resource, toValue(params)),
+		enabled: options.enabled === void 0 ? true : toValue(options.enabled)
+	})));
 }
-export {
-  useGetList,
-  useGetMany,
-  useGetManyAggregate,
-  useGetManyReference,
-  useGetOne
-};
+export { useGetList, useGetMany, useGetManyAggregate, useGetManyReference, useGetOne };

package/dist/data/undoable.d.ts

@@ -17,7 +17,7 @@
  * `runUndoable` itself throws if actually invoked without a notification store —
  * an undoable mutation needs its Undo notification to drive the commit.
  */
-import { type UndoableHandle } from "@chelone/core";
+import { type TranslateParamValues, type UndoableHandle } from "@chelone/core";
 import type { QueryKey } from "@tanstack/vue-query";
 /**
  * The caller-facing options for {@link useUndoable}'s `runUndoable`. A button /
@@ -37,7 +37,7 @@ export interface RunUndoableOptions {
     commit: () => Promise<unknown>;
     /** i18n KEY for the undoable notification (e.g. `chelone.notification.deleted`). */
     message: string;
-    messageArgs?: Record<string, unknown>;
+    messageArgs?: TranslateParamValues;
     type?: "info" | "success" | "warning" | "error";
     /** Undo window in ms (default 5000). Auto-hide/dismiss ⇒ commit. */
     autoHideDuration?: number;

package/dist/data/undoable.js

@@ -1,41 +1,58 @@
-import { startUndoableMutation } from "@chelone/core";
 import { useCheloneContext } from "../context.js";
+import { startUndoableMutation } from "@chelone/core";
+// src/data/undoable.ts
+/**
+* `useUndoable` — the Vue twin of `@chelone/react`'s `undoable-hooks.ts`. Bridges
+* core's vanilla `startUndoableMutation` engine to the notification store: apply
+* the optimistic cache change NOW, enqueue an UNDOABLE notification, and hand its
+* `undo`/`onClose` callbacks the core handle. The `<Notification>` SFC renders the
+* Undo action (⇒ `handle.undo()`, server untouched) and treats the auto-hide
+* timeout / dismiss as a COMMIT (⇒ `handle.commit()`, server exactly once). Every
+* data-integrity guarantee (0 calls on undo, 1 on commit, rollback-on-error) lives
+* in the core handle — this composable is only the notification wiring.
+*
+* Idiom translation from the React twin: React reads the query client with
+* `useQueryClient()` and the store with `useCheloneNotifications()`; Vue reads both
+* off the ambient `<Admin>` context (`ctx.queryClient` + `ctx.notifications`) so
+* the returned `runUndoable` closure captures the SAME `dataProvider` /
+* `queryClient` the rest of the adapter uses. The composable never throws at call
+* time (so a button that merely CALLS it in pessimistic mode works with no store);
+* `runUndoable` itself throws if actually invoked without a notification store —
+* an undoable mutation needs its Undo notification to drive the commit.
+*/
+/**
+* Returns `runUndoable(options)`: start an undoable mutation (snapshot + apply +
+* deferred commit via the core engine) and enqueue its Undo notification. Read
+* the ambient `queryClient` + notification store once at setup; the returned
+* closure is safe to call from an event handler.
+*/
 function useUndoable() {
-  const { queryClient, notifications: store } = useCheloneContext();
-  return (options) => {
-    if (!store) {
-      throw new Error(
-        `useUndoable: mutationMode='undoable' requires a notification store — pass <Admin :notifications="createNotificationStore()">.`
-      );
-    }
-    const handle = startUndoableMutation({
-      queryClient,
-      queryKeys: options.queryKeys,
-      applyOptimistic: options.applyOptimistic,
-      commit: options.commit
-    });
-    store.notify(options.message, {
-      type: options.type ?? "info",
-      messageArgs: options.messageArgs,
-      undoable: true,
-      autoHideDuration: options.autoHideDuration ?? 5e3,
-      undo: () => handle.undo(),
-      onClose: () => {
-        void handle.commit().catch((error) => {
-          if (options.onCommitError) {
-            options.onCommitError(error);
-          } else {
-            store.notify("chelone.notification.http_error", {
-              type: "error",
-              messageArgs: { _: String(error) }
-            });
-          }
-        });
-      }
-    });
-    return handle;
-  };
+	const { queryClient, notifications: store } = useCheloneContext();
+	return (options) => {
+		if (!store) throw new Error("useUndoable: mutationMode='undoable' requires a notification store — pass <Admin :notifications=\"createNotificationStore()\">.");
+		const handle = startUndoableMutation({
+			queryClient,
+			queryKeys: options.queryKeys,
+			applyOptimistic: options.applyOptimistic,
+			commit: options.commit
+		});
+		store.notify(options.message, {
+			type: options.type ?? "info",
+			messageArgs: options.messageArgs,
+			undoable: true,
+			autoHideDuration: options.autoHideDuration ?? 5e3,
+			undo: () => handle.undo(),
+			onClose: () => {
+				handle.commit().catch((error) => {
+					if (options.onCommitError) options.onCommitError(error);
+					else store.notify("chelone.notification.http_error", {
+						type: "error",
+						messageArgs: { _: String(error) }
+					});
+				});
+			}
+		});
+		return handle;
+	};
 }
-export {
-  useUndoable
-};
+export { useUndoable };

package/dist/data/use-check-for-application-update.js

@@ -1,41 +1,45 @@
-import { createApplicationUpdateStore } from "@chelone/core";
-import { shallowRef, watch, toValue, effectScope, unref, computed } from "vue";
 import { useMicroStoreSelector } from "../store/use-micro-store.js";
-const IS_DEV = (typeof process !== "undefined" ? process.env?.NODE_ENV : void 0) !== "production";
+import { computed, effectScope, shallowRef, toValue, unref, watch } from "vue";
+import { createApplicationUpdateStore } from "@chelone/core";
+// src/data/use-check-for-application-update.ts
+/**
+* `useCheckForApplicationUpdate` — the Vue twin of `@chelone/react`'s hook of
+* the same name (`compat-hooks.ts`). Bridges core's
+* `createApplicationUpdateStore` through `useMicroStoreSelector`.
+*/
+var IS_DEV = (typeof process !== "undefined" ? process.env.NODE_ENV : void 0) !== "production";
+/**
+* `true` once the deployed page's body differs from the first one fetched, so
+* a new build is live (ra `useCheckForApplicationUpdate` parity). `disabled`
+* defaults to `true` outside production, so a dev server never polls.
+*
+* The poll restarts only when `url`, `interval` or `disabled` change:
+* `fetchOptions` and `onNewVersionAvailable` are read at each check.
+*/
 function useCheckForApplicationUpdate(options = {}) {
-  const current = shallowRef({
-    hasNewVersion: shallowRef(false)
-  });
-  watch(
-    [
-      () => toValue(options.url),
-      () => toValue(options.interval),
-      () => toValue(options.disabled) ?? IS_DEV
-    ],
-    ([url, interval, disabled], _previous, onCleanup) => {
-      const scope = effectScope(true);
-      onCleanup(() => scope.stop());
-      const hasNewVersion = scope.run(
-        () => useMicroStoreSelector(
-          createApplicationUpdateStore({
-            url,
-            interval,
-            disabled,
-            fetchOptions: () => {
-              const fetchOptions = unref(options.fetchOptions);
-              return (typeof fetchOptions === "function" ? fetchOptions() : fetchOptions) ?? {};
-            },
-            onNewVersionAvailable: () => unref(options.onNewVersionAvailable)?.()
-          }),
-          (snapshot) => snapshot.hasNewVersion
-        )
-      );
-      if (hasNewVersion) current.value = { hasNewVersion };
-    },
-    { immediate: true, flush: "sync" }
-  );
-  return computed(() => current.value.hasNewVersion.value);
+	const current = shallowRef({ hasNewVersion: shallowRef(false) });
+	watch([
+		() => toValue(options.url),
+		() => toValue(options.interval),
+		() => toValue(options.disabled) ?? IS_DEV
+	], ([url, interval, disabled], _previous, onCleanup) => {
+		const scope = effectScope(true);
+		onCleanup(() => scope.stop());
+		const hasNewVersion = scope.run(() => useMicroStoreSelector(createApplicationUpdateStore({
+			url,
+			interval,
+			disabled,
+			fetchOptions: () => {
+				const fetchOptions = unref(options.fetchOptions);
+				return (typeof fetchOptions === "function" ? fetchOptions() : fetchOptions) ?? {};
+			},
+			onNewVersionAvailable: () => unref(options.onNewVersionAvailable)?.()
+		}), (snapshot) => snapshot.hasNewVersion));
+		if (hasNewVersion) current.value = { hasNewVersion };
+	}, {
+		immediate: true,
+		flush: "sync"
+	});
+	return computed(() => current.value.hasNewVersion.value);
 }
-export {
-  useCheckForApplicationUpdate
-};
+export { useCheckForApplicationUpdate };

package/dist/data/use-is-offline.js

@@ -1,11 +1,17 @@
-import { createOfflineStore } from "@chelone/core";
 import { useMicroStoreSelector } from "../store/use-micro-store.js";
+import { createOfflineStore } from "@chelone/core";
+// src/data/use-is-offline.ts
+/**
+* `useIsOffline` — the Vue twin of `@chelone/react`'s `useIsOffline`
+* (`compat-hooks.ts`). Bridges core's `createOfflineStore` through
+* `useMicroStoreSelector`, so the `online`/`offline` listeners attach on setup
+* and detach on scope disposal.
+*/
+/**
+* `true` while the browser reports itself offline. Reads `navigator.onLine`,
+* so a page opened offline is offline from the first render.
+*/
 function useIsOffline() {
-  return useMicroStoreSelector(
-    createOfflineStore(),
-    (snapshot) => snapshot.isOffline
-  );
+	return useMicroStoreSelector(createOfflineStore(), (snapshot) => snapshot.isOffline);
 }
-export {
-  useIsOffline
-};
+export { useIsOffline };