@meeovi/layer-lists 1.0.2 → 1.0.3

package/dist/layers/shared/app/composables/globals/useDirectusForm.js

@@ -0,0 +1,66 @@
+import { ref, provide } from 'vue';
+export function useDirectusForm(collectionName, fieldsRef, opts) {
+    const form = ref({});
+    const formError = ref(null);
+    const formSuccess = ref(null);
+    // provide form context for DirectusFormElement children
+    provide('directusForm', {
+        form,
+        fields: fieldsRef,
+    });
+    const submitForm = async () => {
+        formError.value = null;
+        formSuccess.value = null;
+        // Validate form data against field validation rules
+        for (const field of fieldsRef.value) {
+            if (field.meta?.validation) {
+                try {
+                    const validation = field.meta.validation;
+                    if (validation._and) {
+                        for (const rule of validation._and) {
+                            const fieldName = Object.keys(rule)[0];
+                            if (!fieldName)
+                                continue;
+                            const ruleDef = rule[fieldName];
+                            if (ruleDef && ruleDef._regex) {
+                                const regex = new RegExp(ruleDef._regex);
+                                const valueToTest = String(form.value[field.field] ?? '');
+                                if (!regex.test(valueToTest)) {
+                                    formError.value = field.meta.validation_message || field.meta.field + ' failed validation';
+                                    console.error(`Validation failed for ${field.field}: ${field.meta.validation_message || 'Invalid format'}`);
+                                    return; // Stop submission if validation fails
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (err) {
+                    console.error(`Error parsing validation for ${field.field}:`, err);
+                }
+            }
+        }
+        const { $directus, $createItem } = useNuxtApp();
+        const result = await $directus.request($createItem(collectionName, form.value));
+        if (result.error) {
+            formError.value = result.error.message;
+            console.error(`Error creating ${collectionName}:`, result.error);
+            return; // Stop submission if error occurs
+        }
+        formSuccess.value = `${collectionName} created successfully`;
+        if (opts?.clearOnSuccess) {
+            form.value = {};
+        }
+        if (opts?.closeDialogRef) {
+            try {
+                opts.closeDialogRef.value = false;
+            }
+            catch (e) { }
+        }
+    };
+    return {
+        form,
+        formError,
+        formSuccess,
+        submitForm,
+    };
+}

package/dist/lists/app/composables/config.d.ts

@@ -0,0 +1,7 @@
+export interface ListsConfig {
+    provider: string;
+    baseUrl?: string;
+    apiKey?: string;
+}
+export declare function setListsConfig(newConfig: Partial<ListsConfig>): void;
+export declare function getListsConfig(): ListsConfig;

package/dist/lists/app/composables/config.js

@@ -0,0 +1,9 @@
+let config = {
+    provider: 'directus'
+};
+export function setListsConfig(newConfig) {
+    config = { ...config, ...newConfig };
+}
+export function getListsConfig() {
+    return config;
+}

package/dist/lists/app/composables/globals/useDirectusForm.d.ts

@@ -0,0 +1 @@
+export * from '#shared/app/composables/globals/useDirectusForm';

package/dist/lists/app/composables/globals/useDirectusForm.js

@@ -0,0 +1 @@
+export * from '#shared/app/composables/globals/useDirectusForm';

package/dist/lists/app/composables/module.d.ts

@@ -0,0 +1,7 @@
+import { type AlternateContext } from '@meeovi/core';
+declare const _default: {
+    id: string;
+    adapters: {};
+    setup(ctx: AlternateContext): Promise<void>;
+};
+export default _default;

package/dist/lists/app/composables/module.js

@@ -0,0 +1,60 @@
+import { defineAlternateModule, useAlternateEventBus } from '@meeovi/core';
+import { getListsConfig } from './config';
+import { registerListsProviderRuntime } from './registry';
+export default defineAlternateModule({
+    id: 'lists',
+    adapters: {},
+    async setup(ctx) {
+        const bus = useAlternateEventBus();
+        const config = getListsConfig();
+        // If a core adapter was registered under the `lists` key, register it
+        // into the local provider registry so UI code can consume it via `useLists()`.
+        // If a core adapter was registered under the `lists` key, adapt it
+        // into the `ListsProvider` shape and register it into the local registry.
+        try {
+            const runtimeAdapter = ctx.getAdapter('lists');
+            if (runtimeAdapter) {
+                const provider = {
+                    getList: (id) => runtimeAdapter.getList(id),
+                    listLists: (params) => runtimeAdapter.listLists(params),
+                    createList: (data) => runtimeAdapter.createList(data),
+                    updateList: (id, data) => runtimeAdapter.updateList(id, data),
+                    deleteList: (id) => runtimeAdapter.deleteList(id),
+                    addItem: (listId, item) => runtimeAdapter.addItem(listId, item),
+                    updateItem: (listId, itemId, data) => runtimeAdapter.updateItem(listId, itemId, data),
+                    deleteItem: (listId, itemId) => runtimeAdapter.deleteItem(listId, itemId),
+                    reorderItems: runtimeAdapter.reorderItems ? (listId, itemIds) => runtimeAdapter.reorderItems(listId, itemIds) : undefined
+                };
+                registerListsProviderRuntime('core', provider);
+            }
+        }
+        catch (e) {
+            // noop
+        }
+        // Listen for runtime adapter registrations from ModuleRegistry
+        bus.on('adapter:registered', (payload) => {
+            try {
+                if (payload?.key === 'lists') {
+                    const runtimeAdapter = ctx.getAdapter('lists');
+                    if (runtimeAdapter) {
+                        const provider = {
+                            getList: (id) => runtimeAdapter.getList(id),
+                            listLists: (params) => runtimeAdapter.listLists(params),
+                            createList: (data) => runtimeAdapter.createList(data),
+                            updateList: (id, data) => runtimeAdapter.updateList(id, data),
+                            deleteList: (id) => runtimeAdapter.deleteList(id),
+                            addItem: (listId, item) => runtimeAdapter.addItem(listId, item),
+                            updateItem: (listId, itemId, data) => runtimeAdapter.updateItem(listId, itemId, data),
+                            deleteItem: (listId, itemId) => runtimeAdapter.deleteItem(listId, itemId),
+                            reorderItems: runtimeAdapter.reorderItems ? (listId, itemIds) => runtimeAdapter.reorderItems(listId, itemIds) : undefined
+                        };
+                        registerListsProviderRuntime('core', provider);
+                    }
+                }
+            }
+            catch (e) {
+                /* noop */
+            }
+        });
+    }
+});

package/dist/lists/app/composables/providers/atproto.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lists/app/composables/providers/atproto.js

@@ -0,0 +1,133 @@
+import { registerListsProvider } from '../registry';
+import { wrapSocialRequest } from '@meeovi/social';
+import { transformList, transformItem } from '../utils/transforms';
+import { validateListInput, validateItemInput } from '../utils/validation';
+import { getListsConfig } from '../config';
+async function atprotoFetch(path, options = {}) {
+    const { baseUrl, apiKey } = getListsConfig();
+    const res = await fetch(`${baseUrl}${path}`, {
+        ...options,
+        headers: {
+            'Content-Type': 'application/json',
+            ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+            ...(options.headers || {})
+        }
+    });
+    if (!res.ok) {
+        const error = new Error(`ATProto error: ${res.status}`);
+        error.status = res.status;
+        error.response = res;
+        throw error;
+    }
+    return res.json();
+}
+const AtprotoListsProvider = {
+    async getList(id) {
+        return wrapSocialRequest('atproto', async () => {
+            const data = await atprotoFetch(`/xrpc/app.bsky.graph.getList?list=${id}`);
+            return transformList(data.list);
+        }, {
+            cacheKey: `atproto:list:${id}`,
+            ttlMs: 1000 * 30,
+            retry: true,
+            swr: true
+        });
+    },
+    async listLists() {
+        return wrapSocialRequest('atproto', async () => {
+            const data = await atprotoFetch(`/xrpc/app.bsky.graph.getLists`);
+            return data.lists.map(transformList);
+        }, {
+            cacheKey: `atproto:lists`,
+            ttlMs: 1000 * 30,
+            retry: true,
+            swr: true
+        });
+    },
+    async createList(data) {
+        validateListInput(data);
+        return wrapSocialRequest('atproto', async () => {
+            const result = await atprotoFetch(`/xrpc/app.bsky.graph.createList`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    name: data.title,
+                    purpose: data.type ?? 'list',
+                    description: data.metadata?.description ?? ''
+                })
+            });
+            return transformList(result);
+        });
+    },
+    async updateList(id, data) {
+        validateListInput(data);
+        return wrapSocialRequest('atproto', async () => {
+            const result = await atprotoFetch(`/xrpc/app.bsky.graph.updateList`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    list: id,
+                    name: data.title,
+                    description: data.metadata?.description
+                })
+            });
+            return transformList(result);
+        });
+    },
+    async deleteList(id) {
+        return wrapSocialRequest('atproto', async () => {
+            await atprotoFetch(`/xrpc/app.bsky.graph.deleteList`, {
+                method: 'POST',
+                body: JSON.stringify({ list: id })
+            });
+        });
+    },
+    async addItem(listId, item) {
+        validateItemInput(item);
+        return wrapSocialRequest('atproto', async () => {
+            const result = await atprotoFetch(`/xrpc/app.bsky.graph.addListItem`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    list: listId,
+                    subject: item.title // ATProto uses "subject" for list entries
+                })
+            });
+            return transformItem(result);
+        });
+    },
+    async updateItem(listId, itemId, data) {
+        validateItemInput(data);
+        return wrapSocialRequest('atproto', async () => {
+            const result = await atprotoFetch(`/xrpc/app.bsky.graph.updateListItem`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    list: listId,
+                    item: itemId,
+                    ...data
+                })
+            });
+            return transformItem(result);
+        });
+    },
+    async deleteItem(listId, itemId) {
+        return wrapSocialRequest('atproto', async () => {
+            await atprotoFetch(`/xrpc/app.bsky.graph.deleteListItem`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    list: listId,
+                    item: itemId
+                })
+            });
+        });
+    },
+    async reorderItems(listId, itemIds) {
+        return wrapSocialRequest('atproto', async () => {
+            await atprotoFetch(`/xrpc/app.bsky.graph.reorderListItems`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    list: listId,
+                    items: itemIds
+                })
+            });
+        });
+    }
+};
+registerListsProvider('atproto', AtprotoListsProvider);

package/dist/lists/app/composables/providers/directus.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lists/app/composables/providers/directus.js

@@ -0,0 +1,130 @@
+import { registerListsProvider } from '../registry';
+import { getListsConfig } from '../config';
+async function directusFetch(path, options = {}) {
+    const cfg = getListsConfig();
+    const base = cfg.baseUrl?.replace(/\/$/, '') || '';
+    const res = await fetch(`${base}${path}`, {
+        ...options,
+        headers: {
+            'Content-Type': 'application/json',
+            ...(cfg.apiKey ? { Authorization: `Bearer ${cfg.apiKey}` } : {}),
+            ...(options.headers || {})
+        }
+    });
+    if (!res.ok) {
+        const err = new Error(`Directus error: ${res.status}`);
+        err.status = res.status;
+        err.response = res;
+        throw err;
+    }
+    return res.json();
+}
+const DirectusListsProvider = {
+    async getList(id) {
+        const json = await directusFetch(`/lists/${id}`);
+        return json.list ?? json;
+    },
+    async listLists() {
+        const json = await directusFetch(`/lists`);
+        return json.lists ?? json;
+    },
+    async createList(data) {
+        const json = await directusFetch(`/lists`, { method: 'POST', body: JSON.stringify(data) });
+        return json.list ?? json;
+    },
+    async updateList(id, data) {
+        const json = await directusFetch(`/lists/${id}`, { method: 'PUT', body: JSON.stringify(data) });
+        return json.list ?? json;
+    },
+    async deleteList(id) {
+        await directusFetch(`/lists/${id}`, { method: 'DELETE' });
+    },
+    async addItem(listId, item) {
+        const json = await directusFetch(`/lists/${listId}/items`, { method: 'POST', body: JSON.stringify(item) });
+        return json.item ?? json;
+    },
+    async updateItem(listId, itemId, data) {
+        const json = await directusFetch(`/lists/${listId}/items/${itemId}`, { method: 'PUT', body: JSON.stringify(data) });
+        return json.item ?? json;
+    },
+    async deleteItem(listId, itemId) {
+        await directusFetch(`/lists/${listId}/items/${itemId}`, { method: 'DELETE' });
+    },
+    async reorderItems(listId, itemIds) {
+        await directusFetch(`/lists/${listId}/reorder`, { method: 'POST', body: JSON.stringify({ items: itemIds }) });
+    },
+    async toggleComplete(listId, itemId, completed = true) {
+        try {
+            const json = await directusFetch(`/lists/${listId}/items/${itemId}/toggle`, { method: 'POST', body: JSON.stringify({ completed }) });
+            return json.item ?? json;
+        }
+        catch (e) {
+            const json = await directusFetch(`/lists/${listId}/items/${itemId}`, { method: 'PUT', body: JSON.stringify({ completed }) });
+            return json.item ?? json;
+        }
+    },
+    async setDueDate(listId, itemId, dueDate) {
+        try {
+            const json = await directusFetch(`/lists/${listId}/items/${itemId}/due`, { method: 'POST', body: JSON.stringify({ dueDate }) });
+            return json.item ?? json;
+        }
+        catch (e) {
+            const json = await directusFetch(`/lists/${listId}/items/${itemId}`, { method: 'PUT', body: JSON.stringify({ metadata: { dueDate } }) });
+            return json.item ?? json;
+        }
+    },
+    async setReminder(listId, itemId, reminder) {
+        try {
+            const json = await directusFetch(`/lists/${listId}/items/${itemId}/reminder`, { method: 'POST', body: JSON.stringify({ reminder }) });
+            return json.item ?? json;
+        }
+        catch (e) {
+            const json = await directusFetch(`/lists/${listId}/items/${itemId}`, { method: 'PUT', body: JSON.stringify({ metadata: { reminder } }) });
+            return json.item ?? json;
+        }
+    },
+    async setPriority(listId, itemId, priority) {
+        try {
+            const json = await directusFetch(`/lists/${listId}/items/${itemId}/priority`, { method: 'POST', body: JSON.stringify({ priority }) });
+            return json.item ?? json;
+        }
+        catch (e) {
+            const json = await directusFetch(`/lists/${listId}/items/${itemId}`, { method: 'PUT', body: JSON.stringify({ metadata: { priority } }) });
+            return json.item ?? json;
+        }
+    },
+    async shareList(listId, userId, role = 'editor') {
+        try {
+            await directusFetch(`/lists/${listId}/share`, { method: 'POST', body: JSON.stringify({ userId, role }) });
+        }
+        catch (e) {
+            const json = await directusFetch(`/lists/${listId}`);
+            const list = json.list ?? json;
+            const collaborators = (list.metadata?.collaborators || []).concat({ userId, role });
+            await directusFetch(`/lists/${listId}`, { method: 'PUT', body: JSON.stringify({ metadata: { ...(list.metadata || {}), collaborators } }) });
+        }
+    },
+    async searchItems(listId, query) {
+        try {
+            const json = await directusFetch(`/lists/${listId}/search?q=${encodeURIComponent(String(query))}`);
+            return json.items ?? json;
+        }
+        catch (e) {
+            const json = await directusFetch(`/lists/${listId}`);
+            const list = json.list ?? json;
+            const q = String(query).toLowerCase();
+            return list.items.filter((i) => (i.title || '').toLowerCase().includes(q) || (i.description || '').toLowerCase().includes(q));
+        }
+    },
+    async archiveList(listId) {
+        try {
+            await directusFetch(`/lists/${listId}/archive`, { method: 'POST' });
+        }
+        catch (e) {
+            const json = await directusFetch(`/lists/${listId}`);
+            const list = json.list ?? json;
+            await directusFetch(`/lists/${listId}`, { method: 'PUT', body: JSON.stringify({ metadata: { ...(list.metadata || {}), archived: true } }) });
+        }
+    }
+};
+registerListsProvider('directus', DirectusListsProvider);

package/dist/lists/app/composables/providers/memory.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lists/app/composables/providers/memory.js

@@ -0,0 +1,110 @@
+import { registerListsProvider } from '../registry';
+import { nanoid } from 'nanoid';
+const lists = new Map();
+const MemoryListsProvider = {
+    async getList(id) {
+        const list = lists.get(id);
+        if (!list)
+            throw new Error(`List ${id} not found`);
+        return list;
+    },
+    async listLists() {
+        return Array.from(lists.values());
+    },
+    async createList(data) {
+        const id = nanoid();
+        const list = {
+            id,
+            title: data.title || 'Untitled List',
+            type: data.type || 'list',
+            items: [],
+            metadata: data.metadata || {},
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString()
+        };
+        lists.set(id, list);
+        return list;
+    },
+    async updateList(id, data) {
+        const list = await this.getList(id);
+        const updated = {
+            ...list,
+            ...data,
+            updatedAt: new Date().toISOString()
+        };
+        lists.set(id, updated);
+        return updated;
+    },
+    async deleteList(id) {
+        lists.delete(id);
+    },
+    async addItem(listId, item) {
+        const list = await this.getList(listId);
+        const newItem = {
+            id: nanoid(),
+            title: item.title || '',
+            description: item.description,
+            completed: item.completed || false,
+            position: list.items.length,
+            parentId: item.parentId,
+            metadata: item.metadata || {},
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString()
+        };
+        list.items.push(newItem);
+        return newItem;
+    },
+    async updateItem(listId, itemId, data) {
+        const list = await this.getList(listId);
+        const item = list.items.find(i => i.id === itemId);
+        if (!item)
+            throw new Error(`Item ${itemId} not found`);
+        Object.assign(item, data, { updatedAt: new Date().toISOString() });
+        return item;
+    },
+    async deleteItem(listId, itemId) {
+        const list = await this.getList(listId);
+        list.items = list.items.filter(i => i.id !== itemId);
+    },
+    async reorderItems(listId, itemIds) {
+        const list = await this.getList(listId);
+        const newOrder = itemIds.map(id => list.items.find(i => i.id === id));
+        list.items = newOrder.map((item, index) => ({
+            ...item,
+            position: index
+        }));
+    },
+    async toggleComplete(listId, itemId, completed = true) {
+        const item = await this.updateItem(listId, itemId, { completed });
+        return item;
+    },
+    async setDueDate(listId, itemId, dueDate) {
+        const item = await this.updateItem(listId, itemId, { metadata: { ...((await this.getList(listId)).items.find(i => i.id === itemId)?.metadata || {}), dueDate } });
+        return item;
+    },
+    async setReminder(listId, itemId, reminder) {
+        const item = await this.updateItem(listId, itemId, { metadata: { ...((await this.getList(listId)).items.find(i => i.id === itemId)?.metadata || {}), reminder } });
+        return item;
+    },
+    async setPriority(listId, itemId, priority) {
+        const item = await this.updateItem(listId, itemId, { metadata: { ...((await this.getList(listId)).items.find(i => i.id === itemId)?.metadata || {}), priority } });
+        return item;
+    },
+    async shareList(listId, userId, role = 'editor') {
+        // memory store: attach collaborators in list.metadata.collaborators
+        const list = await this.getList(listId);
+        const collaborators = list.metadata?.collaborators || [];
+        collaborators.push({ userId, role });
+        list.metadata = { ...(list.metadata || {}), collaborators };
+    },
+    async searchItems(listId, query) {
+        const list = await this.getList(listId);
+        const q = String(query).toLowerCase();
+        return list.items.filter(i => (i.title || '').toLowerCase().includes(q) || (i.description || '').toLowerCase().includes(q));
+    },
+    async archiveList(listId) {
+        const list = await this.getList(listId);
+        list.metadata = { ...(list.metadata || {}), archived: true };
+    }
+};
+registerListsProvider('memory', MemoryListsProvider);

package/dist/lists/app/composables/registry.d.ts

@@ -0,0 +1,4 @@
+import type { ListsProvider } from './types';
+export declare function registerListsProvider(name: string, provider: ListsProvider): void;
+export declare function registerListsProviderRuntime(name: string, provider: ListsProvider): void;
+export declare function getListsProvider(name: string): ListsProvider;

package/dist/lists/app/composables/registry.js

@@ -0,0 +1,14 @@
+const providers = {};
+export function registerListsProvider(name, provider) {
+    providers[name] = provider;
+}
+// Allow runtime registration from other modules (e.g. via core ModuleRegistry adapters)
+export function registerListsProviderRuntime(name, provider) {
+    registerListsProvider(name, provider);
+}
+export function getListsProvider(name) {
+    const provider = providers[name];
+    if (!provider)
+        throw new Error(`Lists provider "${name}" not found`);
+    return provider;
+}

package/dist/lists/app/composables/types.d.ts

@@ -0,0 +1,38 @@
+export interface ListItem {
+    id: string;
+    title: string;
+    description?: string;
+    completed?: boolean;
+    position?: number;
+    parentId?: string;
+    metadata?: Record<string, any>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface List {
+    id: string;
+    title: string;
+    type: 'checklist' | 'kanban' | 'list' | string;
+    items: ListItem[];
+    metadata?: Record<string, any>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface ListsProvider {
+    getList(id: string): Promise<List>;
+    listLists(params?: Record<string, any>): Promise<List[]>;
+    createList(data: Partial<List>): Promise<List>;
+    updateList(id: string, data: Partial<List>): Promise<List>;
+    deleteList(id: string): Promise<void>;
+    addItem(listId: string, item: Partial<ListItem>): Promise<ListItem>;
+    updateItem(listId: string, itemId: string, data: Partial<ListItem>): Promise<ListItem>;
+    deleteItem(listId: string, itemId: string): Promise<void>;
+    reorderItems?(listId: string, itemIds: string[]): Promise<void>;
+    toggleComplete?(listId: string, itemId: string, completed: boolean): Promise<ListItem>;
+    setDueDate?(listId: string, itemId: string, dueDate: string | null): Promise<ListItem>;
+    setReminder?(listId: string, itemId: string, reminder: string | null): Promise<ListItem>;
+    setPriority?(listId: string, itemId: string, priority: number | null): Promise<ListItem>;
+    shareList?(listId: string, userId: string, role?: string): Promise<void>;
+    searchItems?(listId: string, query: string): Promise<ListItem[]>;
+    archiveList?(listId: string): Promise<void>;
+}

package/dist/lists/app/composables/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lists/app/composables/useLists.d.ts

@@ -0,0 +1,11 @@
+export declare function useLists(): {
+    getList: (id: string) => Promise<import("./types").List>;
+    listLists: (params?: Record<string, any>) => Promise<import("./types").List[]>;
+    createList: (data: Partial<import("./types").List>) => Promise<import("./types").List>;
+    updateList: (id: string, data: Partial<import("./types").List>) => Promise<import("./types").List>;
+    deleteList: (id: string) => Promise<void>;
+    addItem: (listId: string, item: Partial<import("./types").ListItem>) => Promise<import("./types").ListItem>;
+    updateItem: (listId: string, itemId: string, data: Partial<import("./types").ListItem>) => Promise<import("./types").ListItem>;
+    deleteItem: (listId: string, itemId: string) => Promise<void>;
+    reorderItems: ((listId: string, itemIds: string[]) => Promise<void>) | undefined;
+};

package/dist/lists/app/composables/useLists.js

@@ -0,0 +1,17 @@
+import { getListsConfig } from './config';
+import { getListsProvider } from './registry';
+export function useLists() {
+    const { provider } = getListsConfig();
+    const lists = getListsProvider(provider);
+    return {
+        getList: lists.getList,
+        listLists: lists.listLists,
+        createList: lists.createList,
+        updateList: lists.updateList,
+        deleteList: lists.deleteList,
+        addItem: lists.addItem,
+        updateItem: lists.updateItem,
+        deleteItem: lists.deleteItem,
+        reorderItems: lists.reorderItems
+    };
+}

package/dist/lists/app/composables/utils/health.d.ts

@@ -0,0 +1,10 @@
+export declare function checkListsProviderHealth(providerName?: string): Promise<{
+    ok: boolean;
+    count: number | null;
+    error?: undefined;
+} | {
+    ok: boolean;
+    error: any;
+    count?: undefined;
+}>;
+export default checkListsProviderHealth;

package/dist/lists/app/composables/utils/health.js

@@ -0,0 +1,15 @@
+import { getListsProvider } from '../registry';
+import { getListsConfig } from '../config';
+export async function checkListsProviderHealth(providerName) {
+    try {
+        const cfg = getListsConfig();
+        const name = providerName || cfg.provider || 'directus';
+        const provider = getListsProvider(name);
+        const lists = await provider.listLists();
+        return { ok: true, count: Array.isArray(lists) ? lists.length : null };
+    }
+    catch (e) {
+        return { ok: false, error: e?.message || String(e) };
+    }
+}
+export default checkListsProviderHealth;