@dyrected/vue 2.22.0 → 2.24.0

package/dist/bridge/react-in-vue.d.ts

@@ -6,21 +6,16 @@ import * as ReactModule from 'react';
  *
  * Rather than spinning up a full `createApp()` per rendered instance, each
  * island is mounted with Vue's low-level `render()` and shares a single
- * `appContext` — normally the host app's, captured by `<DyrectedAdmin>`. That
- * keeps the cost of many custom fields/slots low and lets host-app plugins,
- * `provide`/`inject`, Pinia, and i18n flow into custom components.
+ * `appContext` — normally the host app's, captured by `<DyrectedAdmin>`.
  *
- * React is imported from the host dependency graph. The Nuxt adapter dedupes
- * React resolution so custom Vue field components share the admin's React copy.
+ * An ambient ContextProvider automatically passes down React controllers and
+ * providers (form controller, field path, client, theme, and admin bridge) into
+ * Vue's `provide()`/`inject()` system so composables like `useDyrectedForm()`,
+ * `useField()`, `useAdminNavigate()`, `useAdminNotify()`, and `useAccess()` work
+ * out of the box with zero manual provider ceremony.
  */
 export declare function wrapVueComponent(VueComp: Component, appContext?: AppContext | null): {
-    (props: any): ReactModule.DetailedReactHTMLElement<{
-        ref: ReactModule.RefObject<HTMLDivElement | null>;
-        className: string;
-        style: {
-            display: "contents";
-        };
-    }, HTMLDivElement>;
+    (props: any): ReactModule.FunctionComponentElement<ReactModule.FragmentProps>;
     displayName: string;
 };
 /**

package/dist/bridge/react-slots.d.ts

@@ -0,0 +1,18 @@
+import { InjectionKey } from 'vue';
+/** Which React component a Vue placeholder asks the bridge to render. */
+export type ReactSlotKind = 'field' | 'fields' | 'defaultForm';
+export interface ReactSlotHandle {
+    update(props: Record<string, unknown>): void;
+    unmount(): void;
+}
+/**
+ * Lets a Vue component render a React component *inside the React tree* that
+ * hosts the Vue island, through a portal into `el`.
+ *
+ * Built-in inputs need React contexts (the form engine, react-hook-form, the
+ * nested editor). A separate React root would lose them; a portal keeps them.
+ */
+export interface ReactSlotRegistry {
+    mount(el: HTMLElement, kind: ReactSlotKind, props: Record<string, unknown>): ReactSlotHandle;
+}
+export declare const DYRECTED_REACT_SLOTS_KEY: InjectionKey<ReactSlotRegistry>;

package/dist/components/DocumentFields.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Renders one built-in input, wired to the form. Keeps the field's label,
+ * validation message, conditions, read-only state and `admin.component` override.
+ */
+export declare const DyrectedField: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {
+    [x: string]: any;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+/** Renders several built-in inputs with the schema's layout rules. Pass `names`, or `exclude` to render the rest. */
+export declare const DyrectedFields: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {
+    [x: string]: any;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+/** Renders the whole built-in form body. Pass `exclude` to leave some fields to your own markup. */
+export declare const DyrectedDefaultForm: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {
+    [x: string]: any;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/components/DyrectedAdmin.vue.d.ts

@@ -13,6 +13,12 @@ type __VLS_Props = {
      * Can be raw Vue components; they will be automatically wrapped.
      */
     components?: any;
+    /**
+     * In development, warn once for each registered component the schema never
+     * references. Set to `false` to silence it.
+     * @default true
+     */
+    warnUnusedComponents?: boolean;
     /** Optional externally managed admin theme controller. */
     themeController?: AdminThemeController;
     /** Preferred theme when the wrapper should control the admin theme. */

package/dist/composables/useAccess.d.ts

@@ -0,0 +1,20 @@
+import { AdminAccessHelpers } from './useAdminBridge';
+export type { AdminAccessHelpers };
+export interface UseAccessResult {
+    /**
+     * Evaluates whether the current user is permitted to perform an operation on a collection.
+     *
+     * IMPORTANT LIMITATIONS & SEMANTICS:
+     * 1. Evaluates collection-level boolean and string (JEXL) access rules only (`collection.access[operation]`).
+     * 2. Does not evaluate field-level access rules (`field.access`).
+     * 3. Function-based access rules and unknown/missing collection rules cannot be evaluated on the client and will return `true` as a non-blocking fallback.
+     * 4. This is purely a best-effort client-side UI hint to show/hide controls or disable actions. Server-side access rules remain the authoritative enforcement point.
+     */
+    can: (operation: "create" | "read" | "update" | "delete", collection: string, doc?: Record<string, unknown>) => boolean;
+}
+/**
+ * Vue composable for UI gating based on collection access rules.
+ *
+ * @experimental
+ */
+export declare function useAccess(): UseAccessResult;

package/dist/composables/useAdminBridge.d.ts

@@ -0,0 +1,8 @@
+import { InjectionKey } from 'vue';
+import { AdminBridgeBundle, AdminNavigateTarget, AdminNavigateHelpers, AdminNotifyHelpers, AdminNotifyOptions, AdminAccessHelpers } from '@dyrected/admin/public';
+export type { AdminBridgeBundle, AdminNavigateTarget, AdminNavigateHelpers, AdminNotifyHelpers, AdminNotifyOptions, AdminAccessHelpers, };
+export declare const DYRECTED_ADMIN_KEY: InjectionKey<AdminBridgeBundle>;
+/**
+ * Access the ambient admin bridge bundle injected across the React-in-Vue bridge.
+ */
+export declare function useAdminBridge(): AdminBridgeBundle;

package/dist/composables/useAdminNavigate.d.ts

@@ -0,0 +1,13 @@
+import { AdminNavigateHelpers, AdminNavigateTarget } from './useAdminBridge';
+export interface AdminNavigateResult {
+    navigate: (to: AdminNavigateTarget, options?: {
+        replace?: boolean;
+    }) => void;
+    to: AdminNavigateHelpers;
+}
+/**
+ * Vue composable for programmatic navigation in custom admin surfaces.
+ *
+ * @experimental
+ */
+export declare function useAdminNavigate(): AdminNavigateResult;

package/dist/composables/useAdminNotify.d.ts

@@ -0,0 +1,8 @@
+import { AdminNotifyHelpers, AdminNotifyOptions } from './useAdminBridge';
+export type { AdminNotifyHelpers, AdminNotifyOptions };
+/**
+ * Vue composable for displaying toast notifications in custom admin surfaces.
+ *
+ * @experimental
+ */
+export declare function useAdminNotify(): AdminNotifyHelpers;

package/dist/composables/useCollectionView.d.ts

@@ -0,0 +1,35 @@
+import { ComputedRef, InjectionKey } from 'vue';
+import { CollectionViewApi, DocumentGroup, ResolvedViewAction, ViewController, ViewDocument } from '@dyrected/admin/public';
+export type { CollectionViewApi, ResolvedViewAction, ViewDocument, DocumentGroup };
+/** Ambient key the bridge provides inside custom view layouts. */
+export declare const DYRECTED_VIEW_KEY: InjectionKey<ViewController>;
+/** Same shape as `CollectionViewApi`, with the state fields as refs. */
+export type VueCollectionViewApi = {
+    [K in keyof CollectionViewApi]: CollectionViewApi[K] extends (...args: any[]) => any ? CollectionViewApi[K] : ComputedRef<CollectionViewApi[K]>;
+};
+/**
+ * Vue composable for custom view layouts. Mirrors `useCollectionView()` in
+ * `@dyrected/react`; read state through `.value`.
+ *
+ * @experimental
+ */
+export declare function useCollectionView(): VueCollectionViewApi;
+export interface VueViewActionsApi {
+    actions: ComputedRef<ResolvedViewAction[]>;
+    run: (name: string, docs?: ViewDocument[], input?: Record<string, unknown>) => Promise<boolean>;
+    isRunning: (name: string, docs?: ViewDocument[]) => boolean;
+}
+/**
+ * Vue composable for running the view's actions from a custom layout. The host
+ * shows its own confirm dialog and input form.
+ *
+ * @experimental
+ */
+export declare function useViewActions(): VueViewActionsApi;
+/**
+ * Groups the view's documents by a field, resolving select labels and
+ * populated relationship names.
+ *
+ * @experimental
+ */
+export declare function useGroupedDocuments(groupBy: string | (() => string)): ComputedRef<import('@dyrected/admin/public').GroupedDocuments>;

package/dist/composables/useDocumentForm.d.ts

@@ -0,0 +1,30 @@
+import { ComputedRef, InjectionKey, ShallowRef } from 'vue';
+import { DocumentContextValue, DocumentFormApi, SubmitOptions, SubmitResult } from '@dyrected/admin/public';
+import { VueStateify } from './useAdminSchemas';
+export type { DocumentFormApi, SubmitOptions, SubmitResult };
+/**
+ * Ambient key the bridge provides inside custom create and edit forms. The value
+ * is a ref the bridge keeps current, so the document and permissions stay reactive.
+ */
+export declare const DYRECTED_DOCUMENT_KEY: InjectionKey<ShallowRef<DocumentContextValue>>;
+/** Same shape as `DocumentFormApi`, with the state fields as refs. */
+export interface VueDocumentFormApi {
+    mode: ComputedRef<DocumentFormApi['mode']>;
+    collection: ComputedRef<DocumentFormApi['collection']>;
+    document: ComputedRef<DocumentFormApi['document']>;
+    isLoadingDocument: ComputedRef<boolean>;
+    presentation: ComputedRef<DocumentFormApi['presentation']>;
+    permissions: ComputedRef<DocumentFormApi['permissions']>;
+    urls: ComputedRef<DocumentFormApi['urls']>;
+    /** Same as `useDyrectedForm()`: values, errors, `setValue` and the rest, as refs. */
+    form: VueStateify<DocumentFormApi['form']>;
+    submit: (options?: SubmitOptions) => Promise<SubmitResult>;
+    cancel: () => void;
+}
+/**
+ * Vue composable for custom create and edit forms. Mirrors `useDocumentForm()` in
+ * `@dyrected/react`; read state through `.value`.
+ *
+ * @experimental
+ */
+export declare function useDocumentForm(): VueDocumentFormApi;

package/dist/composables/usePageMeta.d.ts

@@ -0,0 +1,22 @@
+import { InjectionKey, MaybeRefOrGetter } from 'vue';
+import { PageAction, PageBreadcrumbItem, PageConfig } from '@dyrected/core';
+export interface PageMeta {
+    title?: string;
+    description?: string;
+    breadcrumbs?: PageBreadcrumbItem[];
+    actions?: PageAction[];
+}
+export interface PageMetaBridgeValue {
+    meta: PageMeta;
+    setMeta: (next: Partial<PageMeta> | ((prev: PageMeta) => PageMeta)) => void;
+    options?: Record<string, unknown>;
+    page?: PageConfig;
+}
+export declare const DYRECTED_PAGE_KEY: InjectionKey<PageMetaBridgeValue>;
+export interface UsePageMetaResult {
+    options?: Record<string, unknown>;
+    page?: PageConfig;
+    meta: PageMeta;
+    setMeta: (next: Partial<PageMeta> | ((prev: PageMeta) => PageMeta)) => void;
+}
+export declare function usePageMeta(meta?: MaybeRefOrGetter<Partial<PageMeta> | undefined>): UsePageMetaResult;

package/dist/composables/usePageRoute.d.ts

@@ -0,0 +1,15 @@
+import { InjectionKey } from 'vue';
+export interface PageRouteBridgeValue {
+    params: Record<string, string>;
+    splat: string;
+    searchParams: URLSearchParams;
+    setSearchParams: (next: any, opts?: {
+        replace?: boolean;
+    }) => void;
+    navigate: (subPath: string, opts?: {
+        replace?: boolean;
+    }) => void;
+}
+export declare const DYRECTED_PAGE_ROUTE_KEY: InjectionKey<PageRouteBridgeValue>;
+export type PageRoute = PageRouteBridgeValue;
+export declare function usePageRoute(): PageRoute;