@chelone/vue 0.6.0 → 0.9.0

package/dist/router/vue-router-adapter.js

@@ -1,143 +1,207 @@
-import { matchPath, parseLocation } from "@chelone/core";
-import { provide, ref, shallowRef, toValue, onScopeDispose, shallowReadonly, computed } from "vue";
-import { useRouter, useRoute } from "vue-router";
 import { RouterAdapterKey } from "./adapter.js";
+import { computed, onScopeDispose, provide, ref, shallowReadonly, shallowRef, toValue } from "vue";
+import { matchPath, parseLocation, toLocationState } from "@chelone/core";
+import { useRoute, useRouter } from "vue-router";
+// src/router/vue-router-adapter.ts
+/**
+* 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.
+*/
+/** Read `window.history.state` when in a browser; `null` under SSR. */
 function readHistoryState() {
-  return typeof window !== "undefined" ? window.history.state : null;
+	return typeof window !== "undefined" ? toLocationState(window.history.state) : null;
 }
+/**
+* Compile a `UseMatchArgs | string` into the CORE pattern to match against.
+*
+* react-router's `useMatch` defaults to an EXACT match (`end: true`) and, with
+* `end: false`, also matches every descendant route (so a parent list entry
+* `/posts` stays active on `/posts/:id`). Core's `matchPath` is exact-only, so
+* a non-`end` match is synthesized as a trailing-splat pattern
+* (`/posts` → `/posts/*`): core matches that for the bare `/posts` AND every
+* child segment, while staying segment-safe (it never matches a mere textual
+* prefix like `/postscript`). A string pattern is always exact (`end: true`).
+*
+* Divergence from the React twin: react-router honors `end` natively; here it
+* is expressed over core's dependency-free matcher — ZERO core changes.
+*/
 function toCorePattern(pattern) {
-  if (typeof pattern === "string") return pattern;
-  if (pattern.end !== false) return pattern.path;
-  return `${pattern.path.replace(/\/+$/, "")}/*`;
+	if (typeof pattern === "string") return pattern;
+	if (pattern.end !== false) return pattern.path;
+	return `${pattern.path.replace(/\/+$/, "")}/*`;
 }
-function toNeutralParams(params) {
-  const out = {};
-  for (const key of Object.keys(params)) {
-    const value = params[key];
-    out[key] = Array.isArray(value) ? value.join("/") : value;
-  }
-  if ("pathMatch" in out) out["*"] = out.pathMatch;
-  return out;
+/** vue-router `route.params` → the neutral `Record<string, string | undefined>`. */
+function toNeutralParams({ params, matched }) {
+	const out = {};
+	for (const key of Object.keys(params)) {
+		const value = params[key];
+		out[key] = Array.isArray(value) ? value.join("/") : value;
+	}
+	if (matched.some(({ path }) => path.includes(":pathMatch"))) {
+		out.pathMatch ??= "";
+		out["*"] = out.pathMatch;
+	}
+	return out;
 }
-const navigations = /* @__PURE__ */ new WeakMap();
+/**
+* Per router, which navigation a blocker guard saw most recently. vue-router
+* keeps running a superseded navigation through the remaining guards until its
+* own cancelled check, so a later blocker would otherwise hold it. `to` is the
+* same object in every guard of one navigation, so a `to` already seen that is
+* not `latest` is superseded.
+*/
+var navigations = /* @__PURE__ */ new WeakMap();
 function isSuperseded(router, to) {
-  let tracker = navigations.get(router);
-  if (!tracker) {
-    tracker = { seen: /* @__PURE__ */ new WeakSet(), latest: null };
-    navigations.set(router, tracker);
-  }
-  if (tracker.seen.has(to)) return tracker.latest !== to;
-  tracker.seen.add(to);
-  tracker.latest = to;
-  return false;
+	let tracker = navigations.get(router);
+	if (!tracker) {
+		tracker = {
+			seen: /* @__PURE__ */ new WeakSet(),
+			latest: null
+		};
+		navigations.set(router, tracker);
+	}
+	if (tracker.seen.has(to)) return tracker.latest !== to;
+	tracker.seen.add(to);
+	tracker.latest = to;
+	return false;
 }
-const vueRouterAdapter = {
-  useLocation() {
-    const route = useRoute();
-    return computed(() => parseLocation(route.fullPath, readHistoryState()));
-  },
-  useNavigate() {
-    const router = useRouter();
-    return ((to, opts) => {
-      if (typeof to === "number") {
-        router.go(to);
-        return;
-      }
-      const state = opts?.state;
-      const resolved = router.resolve(to);
-      const location = {
-        path: resolved.path,
-        query: resolved.query,
-        hash: resolved.hash,
-        state
-      };
-      if (opts?.replace) {
-        void router.replace(location);
-        return;
-      }
-      void router.push(location);
-    });
-  },
-  useParams() {
-    const route = useRoute();
-    return computed(() => toNeutralParams(route.params));
-  },
-  useMatch(pattern) {
-    const route = useRoute();
-    const corePattern = toCorePattern(pattern);
-    return computed(() => matchPath(corePattern, route.path));
-  },
-  matchPath,
-  useBlocker(shouldBlock) {
-    const router = useRouter();
-    const state = ref("unblocked");
-    const location = shallowRef(null);
-    let settle = null;
-    const release = (proceed) => {
-      settle?.(proceed);
-      settle = null;
-    };
-    const stopGuard = router.beforeEach((to, from) => {
-      if (isSuperseded(router, to)) return true;
-      release(true);
-      const nextLocation = parseLocation(to.fullPath);
-      const blocks = typeof shouldBlock === "function" ? shouldBlock({
-        currentLocation: parseLocation(from.fullPath),
-        nextLocation
-      }) : toValue(shouldBlock);
-      if (!blocks) {
-        state.value = "unblocked";
-        location.value = null;
-        return true;
-      }
-      location.value = nextLocation;
-      state.value = "blocked";
-      return new Promise((resolve) => {
-        settle = resolve;
-      });
-    });
-    const stopAfter = router.afterEach(() => {
-      if (state.value !== "proceeding") return;
-      state.value = "unblocked";
-      location.value = null;
-    });
-    const stopError = router.onError(() => {
-      if (state.value !== "proceeding") return;
-      state.value = "unblocked";
-      location.value = null;
-    });
-    onScopeDispose(() => {
-      release(false);
-      state.value = "unblocked";
-      location.value = null;
-      stopGuard();
-      stopAfter();
-      stopError();
-    });
-    return {
-      state: shallowReadonly(state),
-      location: shallowReadonly(location),
-      proceed() {
-        if (state.value !== "blocked") return;
-        state.value = "proceeding";
-        release(true);
-      },
-      reset() {
-        if (state.value !== "blocked") return;
-        state.value = "unblocked";
-        location.value = null;
-        release(false);
-      }
-    };
-  },
-  useCanBlock() {
-    return true;
-  }
+/** The vue-router-backed default adapter. */
+var vueRouterAdapter = {
+	useLocation() {
+		const route = useRoute();
+		return computed(() => parseLocation(route.fullPath, readHistoryState()));
+	},
+	useNavigate() {
+		const router = useRouter();
+		function navigate(to, opts) {
+			if (typeof to === "number") {
+				router.go(to);
+				return;
+			}
+			const state = opts?.state;
+			const resolved = router.resolve(to);
+			const location = {
+				path: resolved.path,
+				query: resolved.query,
+				hash: resolved.hash,
+				state
+			};
+			if (opts?.replace) {
+				router.replace(location);
+				return;
+			}
+			router.push(location);
+		}
+		return navigate;
+	},
+	useParams() {
+		const route = useRoute();
+		return computed(() => toNeutralParams(route));
+	},
+	useMatch(pattern) {
+		const route = useRoute();
+		const corePattern = toCorePattern(pattern);
+		return computed(() => matchPath(corePattern, route.path));
+	},
+	matchPath,
+	useBlocker(shouldBlock) {
+		const router = useRouter();
+		const state = ref("unblocked");
+		const location = shallowRef(null);
+		let settle = null;
+		const release = (proceed) => {
+			settle?.(proceed);
+			settle = null;
+		};
+		const stopGuard = router.beforeEach((to, from) => {
+			if (isSuperseded(router, to)) return true;
+			release(true);
+			const nextLocation = parseLocation(to.fullPath);
+			if (!(typeof shouldBlock === "function" ? shouldBlock({
+				currentLocation: parseLocation(from.fullPath),
+				nextLocation
+			}) : toValue(shouldBlock))) {
+				state.value = "unblocked";
+				location.value = null;
+				return true;
+			}
+			location.value = nextLocation;
+			state.value = "blocked";
+			return new Promise((resolve) => {
+				settle = resolve;
+			});
+		});
+		const stopAfter = router.afterEach(() => {
+			if (state.value !== "proceeding") return;
+			state.value = "unblocked";
+			location.value = null;
+		});
+		const stopError = router.onError(() => {
+			if (state.value !== "proceeding") return;
+			state.value = "unblocked";
+			location.value = null;
+		});
+		onScopeDispose(() => {
+			release(false);
+			state.value = "unblocked";
+			location.value = null;
+			stopGuard();
+			stopAfter();
+			stopError();
+		});
+		return {
+			state: shallowReadonly(state),
+			location: shallowReadonly(location),
+			proceed() {
+				if (state.value !== "blocked") return;
+				state.value = "proceeding";
+				release(true);
+			},
+			reset() {
+				if (state.value !== "blocked") return;
+				state.value = "unblocked";
+				location.value = null;
+				release(false);
+			}
+		};
+	},
+	useCanBlock() {
+		return true;
+	}
 };
+/**
+* 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.
+*/
 function provideVueRouterAdapter() {
-  provide(RouterAdapterKey, vueRouterAdapter);
+	provide(RouterAdapterKey, vueRouterAdapter);
 }
-export {
-  provideVueRouterAdapter,
-  vueRouterAdapter
-};
+export { provideVueRouterAdapter, vueRouterAdapter };

package/dist/store/use-micro-store.d.ts

@@ -1,4 +1,4 @@
-import type { MicroStore } from "@chelone/core";
+import { type MicroStore } from "@chelone/core";
 import { type ComputedRef, type Ref } from "vue";
 /**
  * Vue reactivity bridge for Chelone's `MicroStore<T>` — the single subscribe

package/dist/store/use-micro-store.js

@@ -1,41 +1,59 @@
-import { shallowRef, onScopeDispose, computed } from "vue";
+import { computed, onScopeDispose, shallowRef } from "vue";
+import { shallowEqual } from "@chelone/core";
+// src/store/use-micro-store.ts
+/**
+* Vue reactivity bridge for Chelone's `MicroStore<T>` — the single subscribe
+* seam that lets a Vue adapter drive the *unchanged* core controllers. This is
+* the Vue analog of React's `useSyncExternalStore(subscribe, getSnapshot)`.
+*
+* The 4R (acquire/release) lifecycle maps 1:1 onto Vue's effect scope:
+* - **acquire** — the first `store.subscribe()` flips the store's subscriber
+*   count 0->1, firing its `onSubscribed` (the controller attaches its
+*   QueryObserver / KV subscriptions). Because the bridge subscribes during
+*   `setup`, mounting a component that reads a controller acquires its
+*   resources exactly as React's commit-phase subscribe does.
+* - **release** — `onScopeDispose(unsubscribe)` runs when the owning effect
+*   scope tears down (component unmount, or `effectScope().stop()` in tests).
+*   The unsubscribe flips the count back to 0, firing the `onSubscribed`
+*   teardown (detach). Vue's scope disposal replaces React's
+*   `useSyncExternalStore` teardown; there is no separate `destroy()` on the
+*   render path (mirrors the React twin's deliberate no-destroy-effect rule).
+*
+* The snapshot is held in a `shallowRef` — the whole object swaps on each
+* mutation (core guarantees snapshot stability: same reference until
+* `setState`), so a shallow ref is the right granularity and avoids deep-
+* proxying controller state. The returned `computed` view is genuinely
+* read-only (no cast) and does not re-proxy the snapshot.
+*/
 function useMicroStore(store) {
-  const state = shallowRef(store.getSnapshot());
-  const unsubscribe = store.subscribe(() => {
-    state.value = store.getSnapshot();
-  });
-  onScopeDispose(unsubscribe);
-  return computed(() => state.value);
-}
-function shallowEqual(a, b) {
-  if (Object.is(a, b)) return true;
-  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
-    return false;
-  }
-  const aRecord = a;
-  const bRecord = b;
-  const aKeys = Object.keys(aRecord);
-  const bKeys = Object.keys(bRecord);
-  if (aKeys.length !== bKeys.length) return false;
-  for (const key of aKeys) {
-    if (!Object.hasOwn(bRecord, key) || !Object.is(aRecord[key], bRecord[key])) {
-      return false;
-    }
-  }
-  return true;
+	const state = shallowRef(store.getSnapshot());
+	const unsubscribe = store.subscribe(() => {
+		state.value = store.getSnapshot();
+	});
+	onScopeDispose(unsubscribe);
+	return computed(() => state.value);
 }
+/**
+* Selector variant of {@link useMicroStore}: subscribe to `store`, project each
+* snapshot through `selector`, and only re-emit when the *selected slice*
+* changes under shallow equality. This is the Vue analog of React's
+* `useSyncExternalStoreWithSelector` — it lets a component depend on one field
+* (or a small derived object) and skip re-renders when unrelated slices mutate.
+*
+* A plain `computed(() => selector(state.value))` cannot do this: a selector
+* returning a fresh object each call is `!==` its predecessor, so Vue would
+* propagate on every store mutation. The shallow-equal guard below holds the
+* previous slice and only reassigns the backing ref when the projection
+* actually differs — so downstream watchers/renders fire solely on slice change.
+* The 4R acquire/release maps to scope disposal exactly as in {@link useMicroStore}.
+*/
 function useMicroStoreSelector(store, selector) {
-  const selected = shallowRef(selector(store.getSnapshot()));
-  const unsubscribe = store.subscribe(() => {
-    const next = selector(store.getSnapshot());
-    if (!shallowEqual(selected.value, next)) {
-      selected.value = next;
-    }
-  });
-  onScopeDispose(unsubscribe);
-  return computed(() => selected.value);
+	const selected = shallowRef(selector(store.getSnapshot()));
+	const unsubscribe = store.subscribe(() => {
+		const next = selector(store.getSnapshot());
+		if (!shallowEqual(selected.value, next)) selected.value = next;
+	});
+	onScopeDispose(unsubscribe);
+	return computed(() => selected.value);
 }
-export {
-  useMicroStore,
-  useMicroStoreSelector
-};
+export { useMicroStore, useMicroStoreSelector };

package/dist/store/use-saved-queries.js

@@ -1,20 +1,25 @@
-import { createSavedQueriesController } from "@chelone/core";
-import { computed } from "vue";
 import { useCheloneContext } from "../context.js";
 import { useMicroStore } from "./use-micro-store.js";
+import { computed } from "vue";
+import { createSavedQueriesController } from "@chelone/core";
+// src/store/use-saved-queries.ts
+/**
+* The named list queries of `resource`, persisted in the KV store. Several
+* instances over one store key stay in step. Without a store the queries live
+* in this instance only. The resource and options are read
+* once, in `setup`.
+*
+* Divergence from ra-core's `useSavedQueries`, which returns a
+* `[queries, setQueries]` tuple: this returns `{ queries, save, remove }`, with
+* `queries` a ref.
+*/
 function useSavedQueries(resource, options = {}) {
-  const controller = createSavedQueriesController(
-    { store: useCheloneContext().store },
-    resource,
-    options
-  );
-  const state = useMicroStore(controller);
-  return {
-    queries: computed(() => state.value.queries),
-    save: controller.save,
-    remove: controller.remove
-  };
+	const controller = createSavedQueriesController({ store: useCheloneContext().store }, resource, options);
+	const state = useMicroStore(controller);
+	return {
+		queries: computed(() => state.value.queries),
+		save: controller.save,
+		remove: controller.remove
+	};
 }
-export {
-  useSavedQueries
-};
+export { useSavedQueries };

package/dist/store/use-store-item.js

@@ -1,18 +1,23 @@
-import { shallowRef, onScopeDispose } from "vue";
 import { useCheloneStore } from "../context.js";
+import { onScopeDispose, shallowRef } from "vue";
+// src/store/use-store-item.ts
+/**
+* One key of the KV store as a ref and a setter, the Vue twin of React's
+* `useStoreItem`. It subscribes to its own key only, so writes to other keys
+* do not touch the ref.
+*
+* Divergence from the React twin: the value is a `Ref`. The key and default
+* are read once, in `setup`.
+*/
 function useStoreItem(key, defaultValue) {
-  const store = useCheloneStore();
-  const read = () => store.getItem(key) ?? defaultValue;
-  const value = shallowRef(read());
-  onScopeDispose(
-    store.subscribe(key, () => {
-      value.value = read();
-    })
-  );
-  return [value, (next) => store.setItem(key, next)];
+	const store = useCheloneStore();
+	const read = () => store.getItem(key) ?? defaultValue;
+	const value = shallowRef(read());
+	onScopeDispose(store.subscribe(key, () => {
+		value.value = read();
+	}));
+	return [value, (next) => store.setItem(key, next)];
 }
-const useStore = useStoreItem;
-export {
-  useStore,
-  useStoreItem
-};
+/** ra-parity alias of {@link useStoreItem}: the same function, not a wrapper. */
+var useStore = useStoreItem;
+export { useStore, useStoreItem };

package/dist/supabase.js

@@ -1,35 +1,9 @@
-import { default as default2 } from "./components/admin/supabase/forgot-password-form.vue.js";
-import { default as default3 } from "./components/admin/supabase/forgot-password-page.vue.js";
+import forgot_password_form_default from "./components/admin/supabase/forgot-password-form.js";
+import forgot_password_page_default from "./components/admin/supabase/forgot-password-page.js";
 import { AppleButton, AzureButton, BitbucketButton, DiscordButton, FacebookButton, GithubButton, GitlabButton, GoogleButton, KeycloakButton, LinkedinButton, NotionButton, SlackButton, SpotifyButton, TwitchButton, TwitterButton, WorkosButton } from "./components/admin/supabase/provider-buttons.js";
-import { default as default4 } from "./components/admin/supabase/set-password-form.vue.js";
-import { default as default5 } from "./components/admin/supabase/set-password-page.vue.js";
-import { default as default6 } from "./components/admin/supabase/social-auth-button.vue.js";
-import { default as default7 } from "./components/admin/supabase/supabase-login-page.vue.js";
+import set_password_form_default from "./components/admin/supabase/set-password-form.js";
+import set_password_page_default from "./components/admin/supabase/set-password-page.js";
+import social_auth_button_default from "./components/admin/supabase/social-auth-button.js";
+import supabase_login_page_default from "./components/admin/supabase/supabase-login-page.js";
 import { useResetPassword, useSetPassword, useSupabaseUrlTokens } from "./components/admin/supabase/use-password-recovery.js";
-export {
-  AppleButton,
-  AzureButton,
-  BitbucketButton,
-  DiscordButton,
-  FacebookButton,
-  default2 as ForgotPasswordForm,
-  default3 as ForgotPasswordPage,
-  GithubButton,
-  GitlabButton,
-  GoogleButton,
-  KeycloakButton,
-  LinkedinButton,
-  NotionButton,
-  default4 as SetPasswordForm,
-  default5 as SetPasswordPage,
-  SlackButton,
-  default6 as SocialAuthButton,
-  SpotifyButton,
-  default7 as SupabaseLoginPage,
-  TwitchButton,
-  TwitterButton,
-  WorkosButton,
-  useResetPassword,
-  useSetPassword,
-  useSupabaseUrlTokens
-};
+export { AppleButton, AzureButton, BitbucketButton, DiscordButton, FacebookButton, forgot_password_form_default as ForgotPasswordForm, forgot_password_page_default as ForgotPasswordPage, GithubButton, GitlabButton, GoogleButton, KeycloakButton, LinkedinButton, NotionButton, set_password_form_default as SetPasswordForm, set_password_page_default as SetPasswordPage, SlackButton, social_auth_button_default as SocialAuthButton, SpotifyButton, supabase_login_page_default as SupabaseLoginPage, TwitchButton, TwitterButton, WorkosButton, useResetPassword, useSetPassword, useSupabaseUrlTokens };