@chelone/vue 0.0.0-stage → 0.1.0

package/dist/data/queries.d.ts

@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+import { type GetListParams, type GetManyParams, type GetManyReferenceParams, type GetOneParams, type ResourceMap } from "@chelone/core";
+import { type MaybeRefOrGetter } from "vue";
+/** Fetch one record by id, reactively. `enabled` gates the fetch (skip a null id). */
+export declare function useGetOne<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: TName, params: MaybeRefOrGetter<GetOneParams>, options?: {
+    enabled?: MaybeRefOrGetter<boolean>;
+}): import("@tanstack/vue-query").UseQueryReturnType<import("@chelone/core").RecordOf<TResources, TName>, Error>;
+/**
+ * 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).
+ */
+export declare function useGetMany<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>;
+/**
+ * Same result as `useGetMany`, but reads started in the same tick by any
+ * component reach the data provider as one `getMany` per resource.
+ */
+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>;
+/**
+ * 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>;
+/** 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>;
+}): import("@tanstack/vue-query").UseQueryReturnType<import("@chelone/core").GetManyReferenceResult<import("@chelone/core").RecordOf<TResources, TName>>, Error>;

package/dist/data/queries.js

@@ -0,0 +1,56 @@
+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";
+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)
+    }))
+  );
+}
+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)
+    }))
+  );
+}
+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)
+    }))
+  );
+}
+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)
+    }))
+  );
+}
+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)
+    }))
+  );
+}
+export {
+  useGetList,
+  useGetMany,
+  useGetManyAggregate,
+  useGetManyReference,
+  useGetOne
+};

package/dist/data/undoable.d.ts

@@ -0,0 +1,56 @@
+/**
+ * `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.
+ */
+import { type UndoableHandle } from "@chelone/core";
+import type { QueryKey } from "@tanstack/vue-query";
+/**
+ * The caller-facing options for {@link useUndoable}'s `runUndoable`. A button /
+ * composable supplies the affected query keys, the synchronous optimistic cache
+ * mutation, and the DEFERRED dataProvider call; `runUndoable` snapshots + applies
+ * + notifies, and returns the core {@link UndoableHandle}.
+ */
+export interface RunUndoableOptions {
+    /**
+     * Query keys snapshotted (before apply) and refetch-cancelled. Pass the
+     * resource root (`[[resource]]`) to cover every list/one/many variant.
+     */
+    queryKeys: QueryKey[];
+    /** Synchronous optimistic cache mutation (e.g. `removeRecordsFromCache`). */
+    applyOptimistic: () => void;
+    /** The DEFERRED dataProvider call — invoked once at commit, never on undo. */
+    commit: () => Promise<unknown>;
+    /** i18n KEY for the undoable notification (e.g. `chelone.notification.deleted`). */
+    message: string;
+    messageArgs?: Record<string, unknown>;
+    type?: "info" | "success" | "warning" | "error";
+    /** Undo window in ms (default 5000). Auto-hide/dismiss ⇒ commit. */
+    autoHideDuration?: number;
+    /**
+     * REPLACES the default commit-error handling. The default rolls the cache back
+     * (done by the core handle) and notifies `chelone.notification.http_error`.
+     */
+    onCommitError?: (error: unknown) => void;
+}
+/**
+ * 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.
+ */
+export declare function useUndoable(): (options: RunUndoableOptions) => UndoableHandle;

package/dist/data/undoable.js

@@ -0,0 +1,41 @@
+import { startUndoableMutation } from "@chelone/core";
+import { useCheloneContext } from "../context.js";
+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;
+  };
+}
+export {
+  useUndoable
+};

package/dist/data/use-check-for-application-update.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `useCheckForApplicationUpdate` — the Vue twin of `@chelone/react`'s hook of
+ * the same name (`compat-hooks.ts`). Bridges core's
+ * `createApplicationUpdateStore` through `useMicroStoreSelector`.
+ */
+import { type MaybeRef, type MaybeRefOrGetter, type Ref } from "vue";
+/** Options for {@link useCheckForApplicationUpdate}. Each may be a ref. */
+export interface UseCheckForApplicationUpdateOptions {
+    /** Page to fingerprint. Defaults to `${location.origin}/index.html`. */
+    url?: MaybeRefOrGetter<string | undefined>;
+    /** Milliseconds between checks. Defaults to one hour. */
+    interval?: MaybeRefOrGetter<number | undefined>;
+    /** Never fetch. Defaults to `true` outside production. */
+    disabled?: MaybeRefOrGetter<boolean | undefined>;
+    /** Read at each check. `cache: "no-store"` always overrides it. */
+    fetchOptions?: MaybeRef<RequestInit | (() => RequestInit) | undefined>;
+    /** Called once, when the first change is seen. Read at the time it fires. */
+    onNewVersionAvailable?: MaybeRef<(() => void) | undefined>;
+}
+/**
+ * `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.
+ */
+export declare function useCheckForApplicationUpdate(options?: UseCheckForApplicationUpdateOptions): Readonly<Ref<boolean>>;

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

@@ -0,0 +1,41 @@
+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";
+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);
+}
+export {
+  useCheckForApplicationUpdate
+};

package/dist/data/use-is-offline.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `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.
+ */
+import type { Ref } from "vue";
+/**
+ * `true` while the browser reports itself offline. Reads `navigator.onLine`,
+ * so a page opened offline is offline from the first render.
+ */
+export declare function useIsOffline(): Readonly<Ref<boolean>>;

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

@@ -0,0 +1,11 @@
+import { createOfflineStore } from "@chelone/core";
+import { useMicroStoreSelector } from "../store/use-micro-store.js";
+function useIsOffline() {
+  return useMicroStoreSelector(
+    createOfflineStore(),
+    (snapshot) => snapshot.isOffline
+  );
+}
+export {
+  useIsOffline
+};

package/dist/data/use-refresh.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `useRefresh` / `useLoading` — the Vue twins of `@chelone/react`'s
+ * `compat-hooks.ts` (`useRefresh` / `useLoading`). Both wrap
+ * `@tanstack/vue-query` against the SAME `queryClient` `<Admin>` provides.
+ * `<RefreshButton>` is the consumer: it invalidates every query on click and
+ * disables while any request is in flight.
+ */
+import { type ComputedRef } from "vue";
+/**
+ * Trigger a full refresh (ra `useRefresh` parity). The returned callback
+ * invalidates EVERY query (no filter) so the active ones refetch. Stable — the
+ * `queryClient` identity never changes within an `<Admin>`.
+ */
+export declare function useRefresh(): () => void;
+/**
+ * Global data-connection state (ra `useLoading` parity): `true` while ANY query
+ * or mutation is pending. The Vue twin needs no manual cache subscription — the
+ * `useIsFetching` / `useIsMutating` composables already return reactive refs
+ * over the two caches; this just ORs their counts into a boolean.
+ */
+export declare function useLoading(): ComputedRef<boolean>;

package/dist/data/use-refresh.js

@@ -0,0 +1,17 @@
+import { useQueryClient, useIsFetching, useIsMutating } from "@tanstack/vue-query";
+import { computed } from "vue";
+function useRefresh() {
+  const queryClient = useQueryClient();
+  return () => {
+    queryClient.invalidateQueries();
+  };
+}
+function useLoading() {
+  const isFetching = useIsFetching();
+  const isMutating = useIsMutating();
+  return computed(() => isFetching.value > 0 || isMutating.value > 0);
+}
+export {
+  useLoading,
+  useRefresh
+};

package/dist/form/field-error.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Field error normalization — the Vue twin of `@chelone/react`'s
+ * `field-error.ts`. form-core stores errors as `unknown` under an error-map
+ * keyed by validation cause; this projects the FIRST displayable error to a
+ * `string | TranslatableMessage` (ra's translatable-error contract) using core's
+ * `normalizeFormError` boundary. Inputs render that payload through i18n — never
+ * a raw `error.root.message` or a `@@react-admin@@` string.
+ */
+import { type TranslatableMessage } from "@chelone/core";
+/** The first displayable error across a field's error-map causes, normalized. */
+export declare function firstFieldError(errorMap: object): string | TranslatableMessage | undefined;

package/dist/form/field-error.js

@@ -0,0 +1,20 @@
+import { normalizeFormError } from "@chelone/core";
+const ERROR_MAP_PRIORITY = [
+  "onSubmit",
+  "onDynamic",
+  "onChange",
+  "onBlur",
+  "onMount",
+  "onServer"
+];
+function firstFieldError(errorMap) {
+  const map = errorMap;
+  for (const cause of ERROR_MAP_PRIORITY) {
+    const normalized = normalizeFormError(map[cause]);
+    if (normalized !== void 0) return normalized;
+  }
+  return void 0;
+}
+export {
+  firstFieldError
+};

package/dist/form/form-context.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The ambient form + source-scope contexts for `@chelone/vue` inputs — the Vue
+ * twin of `@chelone/react`'s `form-context.tsx` (`CheloneFormProvider` +
+ * `useCheloneFormContext` + `SourceContext`). `useForm` provides the form;
+ * `useInput` injects it to hang a field binding off it.
+ *
+ * Idiom translation from the React twin: React threads the form through a
+ * `createContext` provider read with `useContext`. Vue `provide`s it once (by
+ * `useForm`, in `setup`) under a typed `InjectionKey` and reads it with `inject`,
+ * so the inject site is fully typed with no cast. A React context cannot be
+ * generic, so — exactly as the React twin does — providers widen their
+ * `CheloneFormApi<TFormData>` to the erased `Record<string, unknown>` shape;
+ * field paths are runtime strings and values `unknown`, so nothing downstream
+ * needs the precise type back.
+ */
+import type { CheloneFormApi, SourceScope } from "@chelone/core";
+import { type InjectionKey } from "vue";
+/** The erased form-data shape ambient (context-provided) forms carry. */
+type UnknownFormValues = Record<string, unknown>;
+/**
+ * What input consumers need from an ambient form: the FormApi (field bindings
+ * hang off it) and the controller's submit pipeline (submit-on-enter, toolbar
+ * buttons). Provided by `useForm`.
+ */
+export interface CheloneFormContextValue {
+    form: CheloneFormApi<UnknownFormValues>;
+    submit: (() => Promise<void>) | undefined;
+}
+/**
+ * The provide/inject key for the ambient form. `useForm` provides it; `useInput`
+ * reads it via {@link useCheloneFormContext}.
+ */
+export declare const CheloneFormContextKey: InjectionKey<CheloneFormContextValue>;
+/** Provide the ambient form to the subtree (called by `useForm` in `setup`). */
+export declare function provideCheloneForm<TFormData>(value: {
+    form: CheloneFormApi<TFormData>;
+    submit?: () => Promise<void>;
+}): void;
+/** The ambient form context; throws without a `useForm` provider above. */
+export declare function useCheloneFormContext(): CheloneFormContextValue;
+/** The ambient form context, or `null` when no `useForm` provider is above. */
+export declare function useOptionalCheloneFormContext(): CheloneFormContextValue | null;
+/**
+ * The provide/inject key for the ambient source scope (ra's SourceContext).
+ * Composed inputs (iterator rows, grouped inputs — a later wave) prefix their
+ * children's `source`; the default is the identity scope, so top-level inputs
+ * need no provider. The scope OBJECT comes from core
+ * (`createRowSourceScope`/`createArraySourceScope`) — this file only transports
+ * it.
+ */
+export declare const SourceScopeKey: InjectionKey<SourceScope>;
+/** Scopes every `useInput`/`useWrappedSource` below to `scope`. */
+export declare function provideSourceScope(scope: SourceScope): void;
+/** The ambient source scope — the identity scope when no provider is above. */
+export declare function useSourceScope(): SourceScope;
+/** The FINAL field path for `source` under the ambient scope (ra parity). */
+export declare function useWrappedSource(source: string): string;
+export {};

package/dist/form/form-context.js

@@ -0,0 +1,44 @@
+import { rootSourceScope } from "@chelone/core";
+import { inject, provide } from "vue";
+const CheloneFormContextKey = /* @__PURE__ */ Symbol("chelone-form-context");
+function provideCheloneForm(value) {
+  provide(CheloneFormContextKey, {
+    // Erasure cast only — the runtime object is untouched.
+    form: value.form,
+    submit: value.submit
+  });
+}
+function useCheloneFormContext() {
+  const ctx = inject(CheloneFormContextKey, null);
+  if (!ctx) {
+    throw new Error(
+      "useCheloneFormContext: no ambient form found. Call useForm() in an ancestor setup() (e.g. an <Edit>/<Create> view) above this input."
+    );
+  }
+  return ctx;
+}
+function useOptionalCheloneFormContext() {
+  return inject(CheloneFormContextKey, null);
+}
+const SourceScopeKey = /* @__PURE__ */ Symbol(
+  "chelone-source-scope"
+);
+function provideSourceScope(scope) {
+  provide(SourceScopeKey, scope);
+}
+function useSourceScope() {
+  return inject(SourceScopeKey, rootSourceScope);
+}
+function useWrappedSource(source) {
+  return useSourceScope().getSource(source);
+}
+export {
+  CheloneFormContextKey,
+  SourceScopeKey,
+  provideCheloneForm,
+  provideSourceScope,
+  useCheloneFormContext,
+  useOptionalCheloneFormContext,
+  useSourceScope,
+  useWrappedSource
+};

package/dist/form/form-group-provider.vue.d.ts

@@ -0,0 +1,14 @@
+/** Props for {@link FormGroupProvider}. */
+export interface FormGroupProviderProps {
+    /** The group name inputs below auto-register into (tab/step name). */
+    name: string;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<FormGroupProviderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FormGroupProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/form/form-group-provider.vue.js

@@ -0,0 +1,18 @@
+import { defineComponent, renderSlot } from "vue";
+import { provideFormGroup } from "./form-groups.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "form-group-provider",
+  props: {
+    name: {}
+  },
+  setup(__props) {
+    const props = __props;
+    provideFormGroup(() => props.name);
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default");
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/form/form-group-provider2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./form-group-provider.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/form/form-groups-provider.vue.d.ts

@@ -0,0 +1,15 @@
+import type { FormGroups } from "@chelone/core";
+/** Props for {@link FormGroupsProvider}. */
+export interface FormGroupsProviderProps {
+    /** An externally created registry (advanced/testing). Omit to create one. */
+    groups?: FormGroups;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<FormGroupsProviderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FormGroupsProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/form/form-groups-provider.vue.js

@@ -0,0 +1,18 @@
+import { defineComponent, renderSlot } from "vue";
+import { provideFormGroups } from "./form-groups.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "form-groups-provider",
+  props: {
+    groups: {}
+  },
+  setup(__props) {
+    const props = __props;
+    provideFormGroups(() => props.groups);
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default");
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/form/form-groups-provider2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./form-groups-provider.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/form/form-groups.d.ts

@@ -0,0 +1,44 @@
+/**
+ * FormGroups Vue layer — the twin of `@chelone/react`'s `group-hooks.tsx`. Wires
+ * core's string-membership `createFormGroups` registry to the ambient form's
+ * `form.store.state.fieldMeta` so a tab/step badge reads just its own members'
+ * validity.
+ *
+ * `useFormGroup` runs the reducer inside the consuming badge and swaps its ref
+ * only when the aggregate differs by value, so a keystroke in a field outside
+ * the group never wakes the badge.
+ */
+import { type FormGroups, type GroupState } from "@chelone/core";
+import { type MaybeRefOrGetter, type Ref } from "vue";
+/**
+ * Provides one {@link FormGroups} registry to the subtree and returns the one
+ * in effect now. Made with `createFormGroups()` unless an external registry is
+ * passed. Pass a ref or getter to follow a changing prop: consumers switch to
+ * the new registry.
+ */
+export declare function provideFormGroups(groups?: MaybeRefOrGetter<FormGroups | undefined>): FormGroups;
+/** The ambient {@link FormGroups} registry; throws without a provider. */
+export declare function useFormGroups(): FormGroups;
+/** The ambient registry, or `undefined` so `useInput` never throws outside a grouped form. */
+export declare function useOptionalFormGroups(): FormGroups | undefined;
+/**
+ * Scopes every `useInput` below into the group `name`. Pass a ref or getter to
+ * follow a changing prop: inputs move to the new group. A nested scope adds to
+ * the groups above it rather than replacing them, so an input joins every
+ * enclosing group.
+ */
+export declare function provideFormGroup(name: MaybeRefOrGetter<string>): void;
+/** The innermost ambient group name as a ref, `undefined` outside a `<FormGroupProvider>`. */
+export declare function useFormGroupName(): Readonly<Ref<string | undefined>>;
+/**
+ * Registers `source` into every enclosing group in setup, re-registers when the
+ * groups or registry change, and unregisters on scope disposal. Does nothing
+ * without a registry or a group name.
+ */
+export declare function useRegisterFieldGroup(source: string): void;
+/**
+ * The reactive aggregated state of the named group (tab/step badge), reduced
+ * over the ambient form's `fieldMeta` for the group's current members. Pass a
+ * ref or getter for `name` to follow a changing prop.
+ */
+export declare function useFormGroup(name: MaybeRefOrGetter<string>): Readonly<Ref<GroupState>>;