@meeovi/layer-lists 1.0.2 → 1.0.3

package/dist/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/app/composables/providers/directus.d.ts

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

package/dist/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/app/composables/providers/memory.d.ts

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

package/dist/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/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/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/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/app/composables/types.js

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

package/dist/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/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/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/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;

package/dist/app/composables/utils/transforms.d.ts

@@ -0,0 +1,13 @@
+import type { List, ListItem } from '../types';
+/**
+ * Normalize a raw provider list into Meeovi's List shape.
+ */
+export declare function transformList(raw: any): List;
+/**
+ * Normalize a raw provider item into Meeovi's ListItem shape.
+ */
+export declare function transformItem(raw: any): ListItem;
+/**
+ * Normalize arrays safely.
+ */
+export declare function transformListArray(raw: any[]): List[];

package/dist/app/composables/utils/transforms.js

@@ -0,0 +1,38 @@
+/**
+ * Normalize a raw provider list into Meeovi's List shape.
+ */
+export function transformList(raw) {
+    return {
+        id: raw.id,
+        title: raw.title ?? raw.name ?? 'Untitled',
+        type: raw.type ?? 'list',
+        items: Array.isArray(raw.items)
+            ? raw.items.map(transformItem)
+            : [],
+        metadata: raw.metadata ?? {},
+        createdAt: raw.createdAt ?? raw.created_at ?? null,
+        updatedAt: raw.updatedAt ?? raw.updated_at ?? null
+    };
+}
+/**
+ * Normalize a raw provider item into Meeovi's ListItem shape.
+ */
+export function transformItem(raw) {
+    return {
+        id: raw.id,
+        title: raw.title ?? raw.name ?? '',
+        description: raw.description ?? raw.body ?? '',
+        completed: raw.completed ?? raw.done ?? false,
+        position: raw.position ?? raw.order ?? 0,
+        parentId: raw.parentId ?? raw.parent_id ?? null,
+        metadata: raw.metadata ?? {},
+        createdAt: raw.createdAt ?? raw.created_at ?? null,
+        updatedAt: raw.updatedAt ?? raw.updated_at ?? null
+    };
+}
+/**
+ * Normalize arrays safely.
+ */
+export function transformListArray(raw) {
+    return raw.map(transformList);
+}

package/dist/app/composables/utils/validation.d.ts

@@ -0,0 +1,3 @@
+import type { List, ListItem } from '../types';
+export declare function validateListInput(data: Partial<List>): void;
+export declare function validateItemInput(data: Partial<ListItem>): void;

package/dist/app/composables/utils/validation.js

@@ -0,0 +1,16 @@
+export function validateListInput(data) {
+    if (!data.title || typeof data.title !== 'string') {
+        throw new Error('List title is required and must be a string');
+    }
+    if (data.type && typeof data.type !== 'string') {
+        throw new Error('List type must be a string');
+    }
+}
+export function validateItemInput(data) {
+    if (!data.title || typeof data.title !== 'string') {
+        throw new Error('Item title is required and must be a string');
+    }
+    if (data.completed !== undefined && typeof data.completed !== 'boolean') {
+        throw new Error('Item completed must be a boolean');
+    }
+}

package/dist/layers/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/layers/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/layers/lists/app/composables/globals/useDirectusForm.d.ts

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

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

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

package/dist/layers/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;