@chelone/vue 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,42 @@
+/**
+ * `RecordContext` — the ambient CURRENT RECORD that record-scoped components
+ * (every field, a reference resolution, an iterator row) read to know which
+ * record they render. The Vue twin of `@chelone/react`'s
+ * `record/record-context.tsx` (`RecordContext` + `useRecordContext`).
+ *
+ * Idiom translation from the React twin: React threads the record through a
+ * `createContext` provider read with `useContext`. Vue `provide`s the record
+ * (a `Ref` so it stays reactive as a controller resolves it) under a typed
+ * `InjectionKey` and reads it with `inject`. A `record` prop always overrides
+ * the ambient value (parity with ra-core's `useRecordContext`), so a component
+ * can render a different record inline without a nested provider.
+ *
+ * The provided value is a `Ref<RecordValue>` (not a bare record): a DataTable
+ * row / an Edit view publishes a record that arrives asynchronously, and
+ * downstream fields must re-render when it lands. `useRecordContext` unwraps to
+ * the current value (a plain read) so field code never juggles refs.
+ */
+import type { LooseRecord } from "@chelone/core";
+import { type InjectionKey, type Ref } from "vue";
+/** A record in scope, or `undefined` when none is (mirrors ra-core's union). */
+export type RecordValue<RecordType = LooseRecord> = RecordType | undefined;
+/** The provide/inject key for the ambient record (a reactive ref). */
+export declare const RecordContextKey: InjectionKey<Ref<RecordValue>>;
+/**
+ * Provide the ambient record to the subtree. Accepts a bare record or a `Ref`
+ * (a controller's reactive record); a bare value is wrapped so the contract is
+ * uniform. Mirrors ra-core: an absent record still provides (an `undefined`
+ * ref) — a nested field reads `undefined` and renders its empty state.
+ */
+export declare function provideRecordContext<RecordType = LooseRecord>(record: RecordValue<RecordType> | Ref<RecordValue<RecordType>>): void;
+/** Options a record-scoped composable accepts to override the ambient record. */
+export interface UseRecordContextOptions<RecordType = LooseRecord> {
+    /** Target a specific record; wins over the ambient one. */
+    record?: RecordValue<RecordType>;
+}
+/**
+ * Read the ambient record's current value. A `record` prop always wins over the
+ * injected ref (parity: ra-core's `useRecordContext`). Returns `undefined` when
+ * neither a prop nor an ancestor provider supplies one.
+ */
+export declare function useRecordContext<RecordType = LooseRecord>(options?: UseRecordContextOptions<RecordType>): RecordValue<RecordType>;

package/dist/record/record-context.js

@@ -0,0 +1,18 @@
+import { isRef, ref, provide, inject } from "vue";
+const RecordContextKey = /* @__PURE__ */ Symbol(
+  "chelone-record-context"
+);
+function provideRecordContext(record) {
+  const asRef = isRef(record) ? record : ref(record);
+  provide(RecordContextKey, asRef);
+}
+function useRecordContext(options) {
+  if (options?.record !== void 0) return options.record;
+  const injected = inject(RecordContextKey, null);
+  return injected?.value;
+}
+export {
+  RecordContextKey,
+  provideRecordContext,
+  useRecordContext
+};

package/dist/record/use-field-value.d.ts

@@ -0,0 +1,32 @@
+/**
+ * `useFieldValue({ source, record?, defaultValue? })` — read the value at a
+ * (possibly deep) `source` path off the ambient record. The Vue twin of
+ * `@chelone/react`'s `record/use-field-value.ts` (ra-core's `useFieldValue`,
+ * clean-room, zero-lodash). Returns a `ComputedRef` so a field re-renders when
+ * the ambient record resolves (React re-renders instead; Vue tracks the ref).
+ *
+ * Path semantics match `lodash/get`: dot members (`author.name`), bracket
+ * indices (`tags[1].label`), and numeric-dot indices (`tags.0.label`) resolve;
+ * `defaultValue` replaces ONLY a resolved `undefined`, never a present `null` /
+ * `0` / `false` / `""`. Reads from the RecordContext (NOT a source scope) on
+ * purpose — a field tracks the record, not the form's source prefix.
+ */
+import type { LooseRecord } from "@chelone/core";
+import { type ComputedRef } from "vue";
+import { type RecordValue } from "./record-context.js";
+export interface UseFieldValueOptions<RecordType = LooseRecord> {
+    /** The field path — dot members and/or bracket/numeric indices. */
+    source: string;
+    /** Override the ambient record (a static record wins over the context ref). */
+    record?: RecordValue<RecordType>;
+    /** Returned only when the resolved value is `undefined`. */
+    defaultValue?: unknown;
+}
+/**
+ * The value at `source` off the ambient (or overridden) record, reactively.
+ *
+ * @example
+ * const name = useFieldValue({ source: "author.name" });
+ * // template: {{ name }}
+ */
+export declare function useFieldValue<RecordType = LooseRecord>(options: UseFieldValueOptions<RecordType>): ComputedRef<unknown>;

package/dist/record/use-field-value.js

@@ -0,0 +1,32 @@
+import { inject, computed } from "vue";
+import { RecordContextKey } from "./record-context.js";
+function toPathSegments(source) {
+  if (source === "") return [];
+  const segments = [];
+  const pattern = /\[([^\]]*)\]|[^.[\]]+/g;
+  let match = pattern.exec(source);
+  while (match !== null) {
+    segments.push(match[1] !== void 0 ? match[1] : match[0]);
+    match = pattern.exec(source);
+  }
+  return segments;
+}
+function getAtPath(record, source, defaultValue) {
+  let current = record;
+  for (const key of toPathSegments(source)) {
+    if (current == null || typeof current !== "object") return defaultValue;
+    current = current[key];
+  }
+  return current === void 0 ? defaultValue : current;
+}
+function useFieldValue(options) {
+  const { source, defaultValue } = options;
+  const injected = inject(RecordContextKey, null);
+  return computed(() => {
+    const record = options.record !== void 0 ? options.record : injected?.value;
+    return getAtPath(record, source, defaultValue);
+  });
+}
+export {
+  useFieldValue
+};

package/dist/resource-context.d.ts

@@ -0,0 +1,41 @@
+/**
+ * `ResourceContext` — the ambient resource NAME a resource-scoped composable
+ * reads to know which resource it belongs to. The Vue twin of
+ * `@chelone/react`'s `resource/resource-context.tsx` (`ResourceContext` +
+ * `useResourceContext`). Distinct from the registry (`resource-registry.ts`):
+ * this carries only the *current* name; the registry carries every mounted
+ * resource's definition.
+ *
+ * Idiom translation from the React twin: React threads the name through a
+ * `createContext` provider read with `useContext`. Vue `provide`s the name under
+ * a typed `InjectionKey` and reads it with `inject`. A `resource` option always
+ * overrides the ambient value (parity with ra-core's `useResourceContext`), so a
+ * composable can target a different resource without a nested provider.
+ */
+import { type InjectionKey } from "vue";
+/** The provide/inject key for the ambient resource name. */
+export declare const ResourceContextKey: InjectionKey<string>;
+/**
+ * Provide the ambient resource name to the subtree (called by a `<Resource>`
+ * route view in a later wave). Mirrors ra-core: an empty name is NOT provided —
+ * pass a real resource name.
+ */
+export declare function provideResourceContext(name: string): void;
+/** Options a resource-scoped composable accepts to override the ambient resource. */
+export interface UseResourceContextOptions {
+    /** Target a specific resource; wins over the ambient `<Resource>` name. */
+    resource?: string;
+}
+/**
+ * Read the ambient resource name. A `resource` option always wins over the
+ * injected value (parity: ra-core's `useResourceContext`), so a caller can
+ * target a specific resource inline. Returns `undefined` when neither an option
+ * nor an ancestor provider supplies one.
+ */
+export declare function useResourceContext(options?: UseResourceContextOptions): string | undefined;
+/**
+ * Read the required resource name, throwing a descriptive error when absent.
+ * The controller composables call this: a controller with no resource is a
+ * wiring bug (parity with the React views' explicit throw).
+ */
+export declare function useRequiredResource(composable: string, options?: UseResourceContextOptions): string;

package/dist/resource-context.js

@@ -0,0 +1,25 @@
+import { inject, provide } from "vue";
+const ResourceContextKey = /* @__PURE__ */ Symbol(
+  "chelone-resource-context"
+);
+function provideResourceContext(name) {
+  provide(ResourceContextKey, name);
+}
+function useResourceContext(options) {
+  return options?.resource ?? inject(ResourceContextKey, void 0);
+}
+function useRequiredResource(composable, options) {
+  const resource = useResourceContext(options);
+  if (!resource) {
+    throw new Error(
+      `${composable}: no resource. Pass a \`resource\` option or render inside a <Resource>.`
+    );
+  }
+  return resource;
+}
+export {
+  ResourceContextKey,
+  provideResourceContext,
+  useRequiredResource,
+  useResourceContext
+};

package/dist/router/adapter.d.ts

@@ -0,0 +1,118 @@
+/**
+ * The declarative router contract `@chelone/vue` owns and injects — the Vue
+ * twin of `@chelone/react`'s `RouterAdapter` (`packages/react/src/router/
+ * adapter.tsx`). A `RouterAdapter` is the reactive subscribe seam the shell
+ * needs: the hooks that read the *current* location / params / match, plus a
+ * stable navigator and the pure `matchPath`. vue-router is the default adapter
+ * (`vueRouterAdapter`, `./vue-router-adapter`); a second Vue router stays a
+ * reference slot — both satisfy THIS interface, so the shell never sees a
+ * concrete router.
+ *
+ * The one decision that makes ONE interface cover both routers (mirrors the
+ * React port): `to` is a STRING and Chelone owns search-param serialization, so
+ * neither router's typed-search / typed-params generics leak here.
+ *
+ * Idiom translation from the React twin: React's adapter hooks return plain
+ * snapshots (`useLocation(): CheloneLocation`) and reactivity comes from React
+ * re-rendering. Vue has no render phase — reactivity is a graph — so the Vue
+ * adapter's readers return `ComputedRef<…>` derived from vue-router's reactive
+ * `useRoute()`. The navigator is a plain stable function (no `useCallback`
+ * churn to defend against, unlike react-router).
+ */
+import type { CheloneLocation, NavigateOpts, PathMatch } from "@chelone/core";
+import { type ComputedRef, type InjectionKey, type Ref } from "vue";
+/** The nav options a caller may pass. Mirrors the React twin's `AdapterNavigate`. */
+export interface AdapterNavigateOpts {
+    replace?: boolean;
+    state?: NavigateOpts["state"];
+}
+/**
+ * `useNavigate`'s returned navigator — a stable function. A string `to`
+ * pushes/replaces a path; a numeric `delta` moves through history.
+ */
+export interface AdapterNavigate {
+    (to: string, opts?: AdapterNavigateOpts): void;
+    (delta: number): void;
+}
+/** `useMatch` argument: a pattern string, optionally with an `end` toggle. */
+export interface UseMatchArgs {
+    path: string;
+    end?: boolean;
+}
+/**
+ * What `useBlocker` returns. The Vue twin of the React `RouterBlocker`, with
+ * `state` / `location` as readonly refs because Vue has no render phase to
+ * re-read a snapshot. `proceed` / `reset` are plain functions that do nothing
+ * unless `state` is `"blocked"`, so callers never guard on presence.
+ */
+export interface RouterBlocker {
+    state: Readonly<Ref<"blocked" | "unblocked" | "proceeding">>;
+    /** The pending target while `blocked` / `proceeding`; else `null`. */
+    location: Readonly<Ref<CheloneLocation | null>>;
+    /** Let the blocked navigation through. */
+    proceed: () => void;
+    /** Cancel the blocked navigation. */
+    reset: () => void;
+}
+/** What `useBlocker` accepts: a flag, a ref to one, or a predicate. */
+export type ShouldBlock = boolean | Ref<boolean> | ((args: {
+    currentLocation: CheloneLocation;
+    nextLocation: CheloneLocation;
+}) => boolean);
+/**
+ * The reactive router contract. Every reader returns a `ComputedRef` so a
+ * component that consumes it updates when the route changes; the navigator and
+ * `matchPath` are plain (a function / a pure util). Implementing every member
+ * IS the whole contract — the shell depends only on this shape, never on
+ * vue-router directly.
+ */
+export interface RouterAdapter {
+    /** Current location as a framework-neutral `CheloneLocation`, reactively. */
+    useLocation(): ComputedRef<CheloneLocation>;
+    /** A stable navigator: a string path or a numeric history delta. */
+    useNavigate(): AdapterNavigate;
+    /** Current route params (splat joined under its catch-all key), reactively. */
+    useParams(): ComputedRef<Record<string, string | undefined>>;
+    /** Match the current pathname against a pattern, reactively. */
+    useMatch(pattern: string | UseMatchArgs): ComputedRef<PathMatch | null>;
+    /** Dependency-free path matcher (returns the neutral `PathMatch`). */
+    matchPath(pattern: string, pathname: string): PathMatch | null;
+    /**
+     * Hold a navigation while `shouldBlock`, until `proceed()` or `reset()`.
+     * Must run in a setup or effect scope: the guard goes with the scope.
+     */
+    useBlocker(shouldBlock: ShouldBlock): RouterBlocker;
+    /** Whether the router can block navigation (drives `warnWhenUnsaved`). */
+    useCanBlock(): boolean;
+}
+/**
+ * The provide/inject key for the injected `RouterAdapter`. `<Admin>` (or a
+ * standalone `provideVueRouterAdapter()`) provides it; every routing composable
+ * reads it via {@link useRouterAdapter}. A typed `InjectionKey` keeps the
+ * inject site fully typed with no cast.
+ */
+export declare const RouterAdapterKey: InjectionKey<RouterAdapter>;
+/**
+ * The provide/inject key for the app basename (default `''`). Consumed by
+ * {@link useBasename} → `useCreatePath` / `useRedirect`. `<Admin>` sets it when
+ * mounted under a host router with a basename; standalone it stays `''`.
+ */
+export declare const BasenameKey: InjectionKey<string>;
+/**
+ * Read the injected `RouterAdapter`. Throws if none is present — a routing
+ * composable used outside `<Admin>` / `provideVueRouterAdapter()` is a misuse
+ * that must fail loudly (parity with the React twin's `useRouterAdapter`).
+ * The null-tolerant path is {@link useRouterAdapterOptional}.
+ */
+export declare function useRouterAdapter(): RouterAdapter;
+/**
+ * Null-tolerant read of the injected `RouterAdapter` — the adapter when
+ * present, `null` when absent. Backs the router-optional degrade
+ * ({@link useRedirectOptional}) so standalone forms/controllers unit-test
+ * without a mounted router. Vue has no Rules of Hooks, so a conditional call of
+ * the real composables based on this is legal (unlike the React twin, which
+ * must suppress `useHookAtTopLevel`).
+ */
+export declare function useRouterAdapterOptional(): RouterAdapter | null;
+/** Read the app basename (default `''`). Mirrors the React twin's `useBasename`. */
+export declare function useBasename(): string;

package/dist/router/adapter.js

@@ -0,0 +1,27 @@
+import { inject } from "vue";
+const RouterAdapterKey = /* @__PURE__ */ Symbol(
+  "chelone-router-adapter"
+);
+const BasenameKey = /* @__PURE__ */ Symbol("chelone-basename");
+function useRouterAdapter() {
+  const adapter = inject(RouterAdapterKey, null);
+  if (!adapter) {
+    throw new Error(
+      "useRouterAdapter: no RouterAdapter found. Render inside <Admin> or call provideVueRouterAdapter() in an ancestor setup()."
+    );
+  }
+  return adapter;
+}
+function useRouterAdapterOptional() {
+  return inject(RouterAdapterKey, null);
+}
+function useBasename() {
+  return inject(BasenameKey, "");
+}
+export {
+  BasenameKey,
+  RouterAdapterKey,
+  useBasename,
+  useRouterAdapter,
+  useRouterAdapterOptional
+};

package/dist/router/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Public router surface for `@chelone/vue` (V1-a Task 3): the `RouterAdapter`
+ * interface + injection keys, the default `vueRouterAdapter` / its installer,
+ * and the bridged navigation composables. The Vue twin of
+ * `packages/react/src/router/index.ts`.
+ */
+export type { AdapterNavigate, AdapterNavigateOpts, RouterAdapter, RouterBlocker, ShouldBlock, UseMatchArgs, } from "./adapter.js";
+export { BasenameKey, RouterAdapterKey, useBasename, useRouterAdapter, useRouterAdapterOptional, } from "./adapter.js";
+export type { Redirect, RedirectTo } from "./nav-composables.js";
+export { useBlocker, useCanBlock, useCreatePath, useLocation, useMatch, useNavigate, useParams, useRedirect, useRedirectOptional, } from "./nav-composables.js";
+export type { LinkToType, UseGetPathForRecordOptions, } from "./use-get-path-for-record.js";
+export { useGetPathForRecord } from "./use-get-path-for-record.js";
+export { provideVueRouterAdapter, vueRouterAdapter, } from "./vue-router-adapter.js";

package/dist/router/nav-composables.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Navigation composables bridged onto the injected `RouterAdapter` — the Vue
+ * twin of `@chelone/react`'s `nav-hooks.tsx`. Every reader is a thin
+ * pass-through to `useRouterAdapter().X` so swapping the router never touches
+ * these call sites; the path builders (`useCreatePath`) use core's pure
+ * `createPath` unchanged, and `useRedirect` reproduces ra-core's redirect
+ * contract exactly (see the twin's doc block).
+ */
+import { type CheloneLocation, type CreatePathParams, type CreatePathType, type Identifier, type PathMatch } from "@chelone/core";
+import type { ComputedRef } from "vue";
+import { type AdapterNavigate, type RouterBlocker, type ShouldBlock, type UseMatchArgs } from "./adapter.js";
+/** Current location (framework-neutral, reactive), via the adapter. */
+export declare function useLocation(): ComputedRef<CheloneLocation>;
+/** Current route params (reactive), via the adapter. */
+export declare function useParams(): ComputedRef<Record<string, string | undefined>>;
+/** A stable navigator — a string path or a numeric history delta. */
+export declare function useNavigate(): AdapterNavigate;
+/** Match the current pathname against a pattern (reactive), via the adapter. */
+export declare function useMatch(pattern: string | UseMatchArgs): ComputedRef<PathMatch | null>;
+/** Hold navigation while `shouldBlock`, via the adapter. */
+export declare function useBlocker(shouldBlock: ShouldBlock): RouterBlocker;
+/** Whether the router can block navigation, via the adapter. */
+export declare function useCanBlock(): boolean;
+export { useBasename } from "./adapter.js";
+/**
+ * A stable `createPath(params)` closure that applies the ambient basename
+ * (parity with the React twin). Basename-prefixed for the four known intents; a
+ * custom string type is returned verbatim by `createPath` (the author owns it).
+ *
+ * Unlike the React twin (which memoizes with `useCallback([basename])`), Vue
+ * reads the basename once at setup and closes over it — a basename change is a
+ * subtree remount (a new `provide`), so a per-setup snapshot is correct.
+ */
+export declare function useCreatePath(): (params: CreatePathParams) => string;
+/**
+ * What `redirect` / `useRedirect` accept (parity §0a-11). The function form
+ * returns a RAW PATH string (ra-core's `RouterTo`), navigated verbatim
+ * (basename-prefixed), never expanded through `createPath`. The string form is
+ * a `CreatePathType`.
+ */
+export type RedirectTo = CreatePathType | false | ((resource?: string, id?: Identifier, data?: unknown) => string | false);
+/**
+ * Navigate in the ra-core redirect forms — reproducing the React twin's
+ * `useRedirect` (which reproduces `ra-core/useRedirect`) EXACTLY:
+ *
+ * - `false` → no-op.
+ * - a **function** → invoked with `(resource, id, data)`; its result is a RAW
+ *   PATH string (or `false` → no-op), basename-prefixed + navigated verbatim,
+ *   ALWAYS pushing `{ _scrollToTop: true, ...state }` (no list exception).
+ * - an absolute `http(s)://` URL → hard `window.location.href` (SSR-guarded).
+ * - a `CreatePathType` → adapter navigate to `createPath({type, resource, id})`,
+ *   pushing `_scrollToTop` state EXCEPT for `'list'` (a list restores its own
+ *   scroll).
+ */
+export type Redirect = (to: RedirectTo, resource?: string, id?: Identifier, data?: unknown, state?: Record<string, unknown>) => void;
+export declare function useRedirect(): Redirect;
+/**
+ * A NULL-TOLERANT `useRedirect`: the real redirect when a `RouterAdapter` is
+ * present, a stable no-op `() => {}` when absent — never throwing.
+ *
+ * Standalone forms (custom bulk-edit-drawer forms, and many unit tests) compose
+ * the edit/create-form controllers WITHOUT a router. Those controllers still
+ * REQUEST a redirect on successful save (ra-core parity), so the composables
+ * that build them must degrade the redirect to a no-op rather than hard-require
+ * a router. `useRedirect` cannot: it calls `useRouterAdapter`, which THROWS with
+ * no adapter (a contract we keep — misuse of the routing composables outside
+ * `<Admin>` must still fail loudly).
+ *
+ * Vue has no Rules of Hooks, so this can legally call `useRedirect()` only when
+ * the adapter is present (the React twin must instead suppress
+ * `useHookAtTopLevel` and rely on mount-stable adapter presence).
+ */
+export declare function useRedirectOptional(): Redirect;

package/dist/router/nav-composables.js

@@ -0,0 +1,64 @@
+import { createPath } from "@chelone/core";
+import { useRouterAdapter, useBasename, useRouterAdapterOptional } from "./adapter.js";
+function useLocation() {
+  return useRouterAdapter().useLocation();
+}
+function useParams() {
+  return useRouterAdapter().useParams();
+}
+function useNavigate() {
+  return useRouterAdapter().useNavigate();
+}
+function useMatch(pattern) {
+  return useRouterAdapter().useMatch(pattern);
+}
+function useBlocker(shouldBlock) {
+  return useRouterAdapter().useBlocker(shouldBlock);
+}
+function useCanBlock() {
+  return useRouterAdapter().useCanBlock();
+}
+function useCreatePath() {
+  const basename = useBasename();
+  return (params) => createPath(params, basename);
+}
+function useRedirect() {
+  const navigate = useNavigate();
+  const basename = useBasename();
+  const createPathFn = useCreatePath();
+  return (to, resource, id, data, state = {}) => {
+    if (to === false) return;
+    if (typeof to === "function") {
+      const target = to(resource, id, data);
+      if (target === false) return;
+      const path2 = `${basename}${target.startsWith("/") ? "" : "/"}${target}`;
+      navigate(path2, { state: { _scrollToTop: true, ...state } });
+      return;
+    }
+    if (to.startsWith("http") && typeof window !== "undefined") {
+      window.location.href = to;
+      return;
+    }
+    const path = createPathFn({ type: to, resource, id });
+    const scrollState = to === "list" ? {} : { _scrollToTop: true };
+    navigate(path, { state: { ...scrollState, ...state } });
+  };
+}
+const noopRedirect = () => {
+};
+function useRedirectOptional() {
+  const adapter = useRouterAdapterOptional();
+  return adapter ? useRedirect() : noopRedirect;
+}
+export {
+  useBasename,
+  useBlocker,
+  useCanBlock,
+  useCreatePath,
+  useLocation,
+  useMatch,
+  useNavigate,
+  useParams,
+  useRedirect,
+  useRedirectOptional
+};

package/dist/router/use-get-path-for-record.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `useGetPathForRecord` — the path of the page a record links to. The Vue twin
+ * of `useGetPathForRecord` in `@chelone/react`'s `nav-hooks.tsx` (parity
+ * §0a-11): an explicit `link` builds that path; an omitted one infers `show`
+ * when the resource has a show view and `show` access, else `edit` the same way,
+ * else no link.
+ *
+ * Every input is a `MaybeRefOrGetter`, so a record that loads late re-evaluates
+ * the path. The access checks run only while inferring, and only for a view the
+ * resource registered: an explicit `link` fires no `canAccess` call.
+ */
+import type { CreatePathType, LooseRecord } from "@chelone/core";
+import { type ComputedRef, type MaybeRef, type MaybeRefOrGetter } from "vue";
+/** How a record link is forced or inferred (parity §0a-11). */
+export type LinkToType = CreatePathType | false | ((record: LooseRecord, resource: string) => CreatePathType | false);
+export interface UseGetPathForRecordOptions {
+    /** The resource the record belongs to. */
+    resource: MaybeRefOrGetter<string>;
+    /** The record whose id the link targets. No record (or no id) gives `false`. */
+    record: MaybeRefOrGetter<LooseRecord | undefined>;
+    /**
+     * An explicit link type or function, or omitted to infer show, then edit. A
+     * function is the link function itself, never a getter, so a reactive `link`
+     * is passed as a ref.
+     */
+    link?: MaybeRef<LinkToType | undefined>;
+}
+export declare function useGetPathForRecord(options: UseGetPathForRecordOptions): ComputedRef<string | false>;

package/dist/router/use-get-path-for-record.js

@@ -0,0 +1,55 @@
+import { toValue, computed, isRef } from "vue";
+import { useResourceDefinition } from "../admin/resource-registry.js";
+import { useMenuAccess } from "../components/admin/layout/use-menu-access.js";
+import { useCreatePath } from "./nav-composables.js";
+function useGetPathForRecord(options) {
+  const readLink = () => isRef(options.link) ? options.link.value : options.link;
+  const createPath = useCreatePath();
+  const definition = useResourceDefinition(() => ({
+    resource: toValue(options.resource)
+  }));
+  const inferring = computed(
+    () => readLink() == null && toValue(options.record) != null
+  );
+  const showAccess = useMenuAccess(
+    () => ({
+      action: "show",
+      resource: toValue(options.resource),
+      record: toValue(options.record)
+    }),
+    () => inferring.value && definition.value.hasShow
+  );
+  const editAccess = useMenuAccess(
+    () => ({
+      action: "edit",
+      resource: toValue(options.resource),
+      record: toValue(options.record)
+    }),
+    () => inferring.value && definition.value.hasEdit
+  );
+  return computed(() => {
+    const record = toValue(options.record);
+    const id = record?.id;
+    if (record == null || id == null) return false;
+    const resource = toValue(options.resource);
+    const link = readLink();
+    if (link === false) return false;
+    if (link != null) {
+      const type = typeof link === "function" ? link(record, resource) : link;
+      return type === false ? false : createPath({ type, resource, id });
+    }
+    if (definition.value.hasShow) {
+      if (showAccess.isPending.value) return false;
+      if (showAccess.canAccess.value) {
+        return createPath({ type: "show", resource, id });
+      }
+    }
+    if (definition.value.hasEdit && !editAccess.isPending.value && editAccess.canAccess.value) {
+      return createPath({ type: "edit", resource, id });
+    }
+    return false;
+  });
+}
+export {
+  useGetPathForRecord
+};

package/dist/router/vue-router-adapter.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The DEFAULT `RouterAdapter`, implemented over vue-router v4 — the Vue twin of
+ * `@chelone/react`'s `reactRouterAdapter` (`packages/react/src/router/
+ * react-router-adapter.tsx`). vue-router is a peer+dev dep of `@chelone/vue`
+ * ONLY (never of core).
+ *
+ * Every member is a thin mapping from vue-router onto Chelone's neutral
+ * contract, reused verbatim from core:
+ * - `useLocation`: vue-router's reactive `route.fullPath` → the neutral
+ *   `CheloneLocation` via core's pure `parseLocation` (no re-implementation of
+ *   the pathname/search/hash split). History `state` is threaded from
+ *   `window.history.state` when in a browser (SSR-guarded → `null`).
+ * - `useNavigate`: a stable function over `router.push` / `router.replace` /
+ *   `router.go`. vue-router's navigate identity is already stable (unlike
+ *   react-router's declarative-router churn the React twin defends against), so
+ *   no latest-ref dance is needed.
+ * - `useParams`: `route.params` (`string | string[]`) → `Record<string,
+ *   string | undefined>`, catch-all arrays joined with `/`, with `pathMatch`
+ *   also exposed under `*`.
+ * - `useMatch` / `matchPath`: core's dependency-free `matchPath` over the
+ *   reactive `route.path`. `useMatch`'s `end` toggle (default exact; `end:
+ *   false` also matches descendants, for a parent list that stays active on a
+ *   child route) is synthesized over core's exact matcher via a trailing splat
+ *   (see `toCorePattern`) — react-router honors `end` natively.
+ *
+ * The adapter is a stateless const of methods (like `reactRouterAdapter`): each
+ * method calls `useRoute()` / `useRouter()` itself, so it is invoked from the
+ * consuming component's own setup — where a router IS present — not from the
+ * provider's setup.
+ */
+import { type RouterAdapter } from "./adapter.js";
+/** The vue-router-backed default adapter. */
+export declare const vueRouterAdapter: RouterAdapter;
+/**
+ * Install the default vue-router adapter for the subtree — the Vue analog of
+ * wrapping the tree in `<RouterAdapterProvider adapter={reactRouterAdapter}>`.
+ * Call it in a `setup()` that sits under a mounted vue-router (`<Admin>` does
+ * this); every routing composable below it then resolves the adapter.
+ */
+export declare function provideVueRouterAdapter(): void;