@chelone/vue 0.0.0-stage → 0.1.0

package/dist/choices/choices-context.js

@@ -0,0 +1,62 @@
+import { provide, inject } from "vue";
+const noop = () => {
+};
+const DEFAULT_SORT = { field: "id", order: "DESC" };
+function toChoiceRecord(choice) {
+  return typeof choice === "string" ? { id: choice, name: choice } : choice;
+}
+function synthesizeInlineChoices(choices, source) {
+  const records = choices.map(toChoiceRecord);
+  return {
+    allChoices: records,
+    availableChoices: records,
+    selectedChoices: [],
+    total: records.length,
+    isPending: false,
+    isFetching: false,
+    error: null,
+    page: 1,
+    perPage: records.length,
+    sort: DEFAULT_SORT,
+    filter: {},
+    hasNextPage: false,
+    hasPreviousPage: false,
+    resource: void 0,
+    source,
+    isFromReference: false,
+    setPage: noop,
+    setPerPage: noop,
+    setSort: noop,
+    setFilters: noop,
+    setValue: noop,
+    refetch: noop
+  };
+}
+const ChoicesContextKey = /* @__PURE__ */ Symbol(
+  "chelone-choices-context"
+);
+function isInlineConfig(value) {
+  return !("isFromReference" in value);
+}
+function provideChoicesContext(value) {
+  provide(
+    ChoicesContextKey,
+    isInlineConfig(value) ? synthesizeInlineChoices(value.choices, value.source) : value
+  );
+}
+function useChoicesContext(options = {}) {
+  const ambient = inject(ChoicesContextKey, null);
+  const resolved = options.choices ? synthesizeInlineChoices(options.choices, options.source) : ambient;
+  if (!resolved) {
+    throw new Error(
+      "useChoicesContext: pass `choices` or call provideChoicesContext() above."
+    );
+  }
+  return resolved;
+}
+export {
+  ChoicesContextKey,
+  provideChoicesContext,
+  synthesizeInlineChoices,
+  useChoicesContext
+};

package/dist/choices/index.d.ts

@@ -0,0 +1,6 @@
+export type { ChoicesContextValue, InlineChoicesConfig, UseChoicesContextOptions, } from "./choices-context.js";
+export { ChoicesContextKey, provideChoicesContext, synthesizeInlineChoices, useChoicesContext, } from "./choices-context.js";
+export type { ChoiceRecord, OptionText, UseChoicesOptions, UseChoicesResult, } from "./use-choices.js";
+export { getChoicePath, useChoices } from "./use-choices.js";
+export type { UseReferenceInputOptions, UseReferenceInputResult, } from "./use-reference-input.js";
+export { useReferenceInput } from "./use-reference-input.js";

package/dist/choices/use-choices.d.ts

@@ -0,0 +1,47 @@
+/**
+ * `useChoices` — the choice accessors composable, the Vue twin of
+ * `@chelone/react`'s `useChoices` (`choices-hooks.ts`, ra's `useChoices`). It
+ * projects a raw choice record into the three things a choice input needs: the
+ * display text (a string path, optionally translated, or a formatter's output),
+ * the value (`optionValue` path or `id`), and the disabled flag.
+ *
+ * Idiom translation from the React twin: React memoizes the accessor object on
+ * `[optionText, optionValue, disableValue, translateChoice, translate]`. Vue's
+ * `setup` runs once, so the accessors are plain closures that read the option
+ * defaults LIVE off `options` each call — passing a reactive props object keeps
+ * the text/value resolution live if a prop is swapped, without a memo. `translate`
+ * comes from the ambient i18n via {@link useTranslate}, so `useChoices` must be
+ * called in `setup`.
+ */
+/** An erased choice record — choices carry arbitrary shapes (`{id, name, ...}`). */
+export type ChoiceRecord = Record<string, unknown>;
+/** The display path (dotted) or a formatter over the whole choice. */
+export type OptionText = string | ((choice: ChoiceRecord) => string);
+export interface UseChoicesOptions {
+    /** The display path or a formatter. Default `'name'`. */
+    optionText?: OptionText;
+    /** The value path. Default `'id'`. */
+    optionValue?: string;
+    /** The disabled-flag path. Default `'disabled'`. */
+    disableValue?: string;
+    /** Translate a string-path text through the catalog (default `true`). */
+    translateChoice?: boolean;
+}
+/** The choice accessors a choice input needs. */
+export interface UseChoicesResult {
+    /** The display text: string path (optionally translated) or the formatter's output. */
+    getChoiceText(choice: ChoiceRecord): string;
+    /** The value: `get(choice, optionValue)`, falling back to `choice.id`. */
+    getChoiceValue(choice: ChoiceRecord): unknown;
+    /** The disabled flag: `get(choice, disableValue)`. */
+    getDisableValue(choice: ChoiceRecord): unknown;
+}
+/** Reads a dotted path off a record (`get(choice, 'a.b')`), else `undefined`. */
+export declare function getChoicePath(record: ChoiceRecord, path: string): unknown;
+/**
+ * The choice accessors (ra's `useChoices`): text (string path or formatter,
+ * translated with a `{ _: name }` fallback so a non-key label renders as-is),
+ * value (`optionValue` path or `id`), and disabled flag. Defaults are read live
+ * off `options`, so a reactive props object stays live between reads.
+ */
+export declare function useChoices(options?: UseChoicesOptions): UseChoicesResult;

package/dist/choices/use-choices.js

@@ -0,0 +1,35 @@
+import { useTranslate } from "../i18n/use-translate.js";
+function getChoicePath(record, path) {
+  if (path in record) return record[path];
+  let current = record;
+  for (const key of path.split(".")) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function useChoices(options = {}) {
+  const translate = useTranslate();
+  return {
+    getChoiceText(choice) {
+      const optionText = options.optionText ?? "name";
+      if (typeof optionText === "function") return optionText(choice);
+      const raw = getChoicePath(choice, optionText);
+      const text = raw == null ? "" : String(raw);
+      if (options.translateChoice === false) return text;
+      const translated = translate(text, { _: text });
+      return translated === text ? text : translated;
+    },
+    getChoiceValue(choice) {
+      const value = getChoicePath(choice, options.optionValue ?? "id");
+      return value !== void 0 ? value : choice.id;
+    },
+    getDisableValue(choice) {
+      return getChoicePath(choice, options.disableValue ?? "disabled");
+    }
+  };
+}
+export {
+  getChoicePath,
+  useChoices
+};

package/dist/choices/use-reference-input.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `useReferenceInput` — the Vue bridge for the VANILLA choices controller, the
+ * twin of `@chelone/react`'s `useReferenceInput` (`choices-hooks.ts`). It fetches
+ * a referenced resource's choices (a live list + selected-record resolution) and
+ * exposes them as a {@link ChoicesContextValue} a choice input consumes through
+ * {@link provideChoicesContext} + {@link useChoicesContext}.
+ *
+ * Idiom translation from the React twin: React holds the controller in `useState`
+ * (constructed once), bridges it with `useSyncExternalStore`, and re-derives the
+ * `ChoicesContextValue` object per render via `useMemo(snapshot)`. Vue constructs
+ * the controller once in `setup`, bridges it with {@link useMicroStore} (the MicroStore
+ * reactivity seam — subscribe drives the 4R acquire, `onScopeDispose` releases),
+ * and returns ONE object whose data fields are GETTERS over the store ref, so a
+ * plain property read tracks the store exactly where a consumer reads it. The
+ * action verbs delegate straight to the controller.
+ *
+ * `ctx`/`options` are read once at construction (parity with the React twin's
+ * `useState` capture) — remount the input to change the reference/options.
+ */
+import type { ChoicesControllerOptions, ResourceMap } from "@chelone/core";
+import type { ChoicesContextValue } from "./choices-context.js";
+/** `useReferenceInput` options: the controller options (the ctx is injected). */
+export type UseReferenceInputOptions<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string> = ChoicesControllerOptions<TResources, TName>;
+/** The reference-input result — the live choices context plus its actions. */
+export type UseReferenceInputResult = ChoicesContextValue;
+/**
+ * Vue bridge for the vanilla choices controller (reference input). Constructs
+ * the controller INERTLY, then {@link useMicroStore} subscribes on `setup` (the 4R
+ * acquire — both QueryObservers attach) and releases on scope disposal.
+ *
+ * Returns a {@link ChoicesContextValue} whose data fields are reactive getters
+ * over the controller store; pass it to {@link provideChoicesContext} so a choice
+ * input reads it via {@link useChoicesContext}.
+ */
+export declare function useReferenceInput<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(options: UseReferenceInputOptions<TResources, TName>): UseReferenceInputResult;

package/dist/choices/use-reference-input.js

@@ -0,0 +1,74 @@
+import { createChoicesController } from "@chelone/core";
+import { useCheloneContext } from "../context.js";
+import { useMicroStore } from "../store/use-micro-store.js";
+function toChoicesContext(ctx) {
+  const { dataProvider, queryClient, notifications, i18n } = ctx;
+  return {
+    dataProvider,
+    queryClient,
+    notifications,
+    translate: i18n ? (key) => i18n.translate(key) : void 0
+  };
+}
+function useReferenceInput(options) {
+  const ctx = useCheloneContext();
+  const controller = createChoicesController(toChoicesContext(ctx), options);
+  const state = useMicroStore(controller);
+  return {
+    get allChoices() {
+      return state.value.allChoices;
+    },
+    get availableChoices() {
+      return state.value.availableChoices;
+    },
+    get selectedChoices() {
+      return state.value.selectedChoices;
+    },
+    get total() {
+      return state.value.total;
+    },
+    get isPending() {
+      return state.value.isPending;
+    },
+    get isFetching() {
+      return state.value.isFetching;
+    },
+    get error() {
+      return state.value.error;
+    },
+    get page() {
+      return state.value.page;
+    },
+    get perPage() {
+      return state.value.perPage;
+    },
+    get sort() {
+      return state.value.sort;
+    },
+    get filter() {
+      return state.value.filter;
+    },
+    get hasNextPage() {
+      return state.value.hasNextPage;
+    },
+    get hasPreviousPage() {
+      return state.value.hasPreviousPage;
+    },
+    get resource() {
+      return state.value.resource;
+    },
+    get source() {
+      return state.value.source;
+    },
+    isFromReference: true,
+    setPage: controller.setPage,
+    setPerPage: controller.setPerPage,
+    setSort: controller.setSort,
+    setFilters: controller.setFilters,
+    setValue: controller.setValue,
+    refetch: controller.refetch
+  };
+}
+export {
+  useReferenceInput
+};

package/dist/components/admin/auth/access-denied.vue.d.ts

@@ -0,0 +1,24 @@
+import type { FunctionalComponent } from "vue";
+/** Props for {@link AccessDenied}. */
+export interface AccessDeniedProps {
+    /** Override the default padlock glyph. */
+    icon?: FunctionalComponent;
+    /** i18n key for the heading. Defaults to `ra.page.access_denied`. */
+    textPrimary?: string;
+    /** i18n key for the sub-text. Defaults to `ra.message.access_denied`. */
+    textSecondary?: string;
+    class?: string;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<AccessDeniedProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<AccessDeniedProps> & Readonly<{}>, {
+    textPrimary: string;
+    textSecondary: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    /** Override the default padlock glyph. */
+    icon?: () => unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/admin/auth/access-denied.vue.js

@@ -0,0 +1,37 @@
+import { defineComponent, computed, openBlock, createElementBlock, normalizeClass, unref, createElementVNode, renderSlot, createBlock, resolveDynamicComponent, toDisplayString } from "vue";
+import { useTranslate } from "../../../i18n/use-translate.js";
+import { cn } from "../../../lib/utils.js";
+import { LockIcon } from "./icons.js";
+const _hoisted_1 = { class: "flex flex-col items-center text-center pt-4 pb-4 opacity-50" };
+const _hoisted_2 = { class: "text-secondary-foreground text-2xl mt-3" };
+const _hoisted_3 = { class: "text-sm" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "access-denied",
+  props: {
+    icon: {},
+    textPrimary: { default: "ra.page.access_denied" },
+    textSecondary: { default: "ra.message.access_denied" },
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const translate = useTranslate();
+    const iconComponent = computed(() => props.icon ?? LockIcon);
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(unref(cn)("flex flex-col justify-center items-center h-full", props.class))
+      }, [
+        createElementVNode("div", _hoisted_1, [
+          renderSlot(_ctx.$slots, "icon", {}, () => [
+            (openBlock(), createBlock(resolveDynamicComponent(iconComponent.value), { class: "size-32" }))
+          ]),
+          createElementVNode("h5", _hoisted_2, toDisplayString(unref(translate)(props.textPrimary, { _: props.textPrimary })), 1),
+          createElementVNode("p", _hoisted_3, toDisplayString(unref(translate)(props.textSecondary, { _: props.textSecondary })), 1)
+        ])
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/auth/access-denied2.vue.js

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

package/dist/components/admin/auth/auth-callback.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/admin/auth/auth-callback.vue.js

@@ -0,0 +1,28 @@
+import { defineComponent, computed, unref, openBlock, createBlock, createElementBlock, createVNode } from "vue";
+import { useHandleAuthCallback } from "../../../admin/auth-gate.js";
+import _sfc_main$2 from "../../ui/spinner2.vue.js";
+import _sfc_main$1 from "./auth-error.vue.js";
+const _hoisted_1 = {
+  key: 1,
+  class: "flex flex-col justify-center items-center h-full"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "auth-callback",
+  setup(__props) {
+    const { error } = useHandleAuthCallback();
+    const errorMessage = computed(
+      () => error.value instanceof Error && error.value.message ? error.value.message : void 0
+    );
+    return (_ctx, _cache) => {
+      return unref(error) ? (openBlock(), createBlock(_sfc_main$1, {
+        key: 0,
+        message: errorMessage.value
+      }, null, 8, ["message"])) : (openBlock(), createElementBlock("div", _hoisted_1, [
+        createVNode(_sfc_main$2, { class: "size-9" })
+      ]));
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/auth/auth-callback2.vue.js

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

package/dist/components/admin/auth/auth-error.vue.d.ts

@@ -0,0 +1,13 @@
+/** Props for {@link AuthError}. */
+export interface AuthErrorProps {
+    /** i18n key for the heading. Defaults to `ra.page.error`. */
+    title?: string;
+    /** i18n key (or raw message) for the body. Defaults to `ra.message.auth_error`. */
+    message?: string;
+    class?: string;
+}
+declare const _default: import("vue").DefineComponent<AuthErrorProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<AuthErrorProps> & Readonly<{}>, {
+    message: string;
+    title: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/admin/auth/auth-error.vue.js

@@ -0,0 +1,49 @@
+import { defineComponent, computed, openBlock, createElementBlock, normalizeClass, unref, createElementVNode, createVNode, createTextVNode, toDisplayString, withCtx } from "vue";
+import { RouterLink } from "vue-router";
+import { useTranslate } from "../../../i18n/use-translate.js";
+import { cn } from "../../../lib/utils.js";
+import { buttonVariants } from "../../ui/button-variants.js";
+import { CircleAlertIcon, LockIcon } from "./icons.js";
+const _hoisted_1 = {
+  class: "flex items-center text-3xl my-5 gap-3",
+  role: "alert"
+};
+const _hoisted_2 = { class: "my-5" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "auth-error",
+  props: {
+    title: { default: "ra.page.error" },
+    message: { default: "ra.message.auth_error" },
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const translate = useTranslate();
+    const linkClasses = computed(() => buttonVariants({ variant: "default" }));
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(unref(cn)("flex flex-col justify-center items-center h-full", props.class))
+      }, [
+        createElementVNode("h1", _hoisted_1, [
+          createVNode(unref(CircleAlertIcon), { class: "w-[2em] h-[2em]" }),
+          createTextVNode(" " + toDisplayString(unref(translate)(props.title, { _: props.title })), 1)
+        ]),
+        createElementVNode("p", _hoisted_2, toDisplayString(unref(translate)(props.message, { _: props.message })), 1),
+        createVNode(unref(RouterLink), {
+          to: "/login",
+          class: normalizeClass(linkClasses.value),
+          "data-slot": "auth-error-signin"
+        }, {
+          default: withCtx(() => [
+            createVNode(unref(LockIcon)),
+            createTextVNode(" " + toDisplayString(unref(translate)("ra.auth.sign_in", { _: "Sign in" })), 1)
+          ]),
+          _: 1
+        }, 8, ["class"])
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/auth/auth-error2.vue.js

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

package/dist/components/admin/auth/auth-layout.vue.d.ts

@@ -0,0 +1,22 @@
+/** Props for {@link AuthLayout}. */
+export interface AuthLayoutProps {
+    /** Heading shown above the main-pane content. */
+    title?: string;
+    /** Subtitle shown below the heading. */
+    subtitle?: string;
+    class?: string;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<AuthLayoutProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<AuthLayoutProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    /** Main-pane content — typically a login / signup / password-reset form. */
+    default: () => unknown;
+    /** Left-pane brand content; when filled, the layout becomes two-column. */
+    aside?: () => unknown;
+    /** Replaces the default `<Notification />` toast region. */
+    notification?: () => unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/admin/auth/auth-layout.vue.js

@@ -0,0 +1,65 @@
+import { defineComponent, openBlock, createElementBlock, normalizeClass, unref, createElementVNode, renderSlot, createCommentVNode, toDisplayString, createVNode } from "vue";
+import { cn } from "../../../lib/utils.js";
+import _sfc_main$1 from "../feedback/notification.vue.js";
+const _hoisted_1 = {
+  key: 0,
+  class: "relative hidden h-full flex-col bg-zinc-900 p-10 text-white dark:border-r lg:flex"
+};
+const _hoisted_2 = { class: "lg:p-8" };
+const _hoisted_3 = { class: "mx-auto flex w-full flex-col justify-center gap-y-6 sm:w-87.5" };
+const _hoisted_4 = {
+  key: 0,
+  class: "flex flex-col gap-y-2 text-center"
+};
+const _hoisted_5 = {
+  key: 0,
+  class: "text-2xl font-semibold tracking-tight"
+};
+const _hoisted_6 = {
+  key: 1,
+  class: "text-sm leading-none text-muted-foreground"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "auth-layout",
+  props: {
+    title: {},
+    subtitle: {},
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(unref(cn)("min-h-screen flex", props.class))
+      }, [
+        createElementVNode("div", {
+          class: normalizeClass(
+            unref(cn)(
+              "container relative grid flex-col items-center justify-center sm:max-w-none lg:px-0",
+              _ctx.$slots.aside && "lg:grid-cols-2"
+            )
+          )
+        }, [
+          _ctx.$slots.aside ? (openBlock(), createElementBlock("div", _hoisted_1, [
+            renderSlot(_ctx.$slots, "aside")
+          ])) : createCommentVNode("", true),
+          createElementVNode("div", _hoisted_2, [
+            createElementVNode("div", _hoisted_3, [
+              __props.title || __props.subtitle ? (openBlock(), createElementBlock("div", _hoisted_4, [
+                __props.title ? (openBlock(), createElementBlock("h1", _hoisted_5, toDisplayString(__props.title), 1)) : createCommentVNode("", true),
+                __props.subtitle ? (openBlock(), createElementBlock("p", _hoisted_6, toDisplayString(__props.subtitle), 1)) : createCommentVNode("", true)
+              ])) : createCommentVNode("", true),
+              renderSlot(_ctx.$slots, "default")
+            ])
+          ])
+        ], 2),
+        renderSlot(_ctx.$slots, "notification", {}, () => [
+          createVNode(_sfc_main$1)
+        ])
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/auth/auth-layout2.vue.js

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

package/dist/components/admin/auth/authentication-error.vue.d.ts

@@ -0,0 +1,16 @@
+import type { FunctionalComponent } from "vue";
+/** Props for {@link AuthenticationError}. */
+export interface AuthenticationErrorProps {
+    /** Override the default warning-triangle glyph. */
+    icon?: FunctionalComponent;
+    /** i18n key for the heading. Defaults to `ra.page.authentication_error`. */
+    textPrimary?: string;
+    /** i18n key for the sub-text. Defaults to `ra.message.authentication_error`. */
+    textSecondary?: string;
+    class?: string;
+}
+declare const _default: import("vue").DefineComponent<AuthenticationErrorProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<AuthenticationErrorProps> & Readonly<{}>, {
+    textPrimary: string;
+    textSecondary: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/admin/auth/authentication-error.vue.js

@@ -0,0 +1,27 @@
+import { defineComponent, computed, openBlock, createBlock, normalizeClass } from "vue";
+import _sfc_main$1 from "./access-denied.vue.js";
+import { TriangleAlertIcon } from "./icons.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "authentication-error",
+  props: {
+    icon: {},
+    textPrimary: { default: "ra.page.authentication_error" },
+    textSecondary: { default: "ra.message.authentication_error" },
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const iconComponent = computed(() => props.icon ?? TriangleAlertIcon);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$1, {
+        icon: iconComponent.value,
+        "text-primary": props.textPrimary,
+        "text-secondary": props.textSecondary,
+        class: normalizeClass(props.class)
+      }, null, 8, ["icon", "text-primary", "text-secondary", "class"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/auth/authentication-error2.vue.js

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

package/dist/components/admin/auth/can-access.vue.d.ts

@@ -0,0 +1,23 @@
+/** Props for {@link CanAccess}. */
+export interface CanAccessProps {
+    /** The action to check (`'list' | 'create' | 'edit' | 'show' | 'delete'` or custom). */
+    action: string;
+    /** The resource to check (e.g. `'posts'`). */
+    resource: string;
+    /** Optional record the grant is scoped to (record-level predicates). */
+    record?: unknown;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<CanAccessProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<CanAccessProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    /** Rendered when access is granted. */
+    default?: () => unknown;
+    /** Rendered while the access check is pending. Defaults to nothing. */
+    loading?: () => unknown;
+    /** Rendered when access is denied. Defaults to nothing. */
+    accessDenied?: () => unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/admin/auth/can-access.vue.js

@@ -0,0 +1,26 @@
+import { defineComponent, computed, unref, renderSlot } from "vue";
+import { useMenuAccess } from "../layout/use-menu-access.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "can-access",
+  props: {
+    action: {},
+    resource: {},
+    record: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const { canAccess, isPending } = useMenuAccess(
+      computed(() => ({
+        action: props.action,
+        resource: props.resource,
+        record: props.record
+      }))
+    );
+    return (_ctx, _cache) => {
+      return unref(isPending) ? renderSlot(_ctx.$slots, "loading", { key: 0 }) : !unref(canAccess) ? renderSlot(_ctx.$slots, "accessDenied", { key: 1 }) : renderSlot(_ctx.$slots, "default", { key: 2 });
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/auth/can-access2.vue.js

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