@meeovi/layer-shared 1.1.4 → 1.1.5

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

@@ -0,0 +1,18 @@
+import { MapperNotFoundError } from './errors';
+const registry = new Map();
+export function registerMapper(mapper) {
+    registry.set(mapper.name, mapper);
+}
+export function getMapper(name) {
+    const mapper = registry.get(name);
+    if (!mapper) {
+        throw new MapperNotFoundError(name);
+    }
+    return mapper;
+}
+export function hasMapper(name) {
+    return registry.has(name);
+}
+export function listMappers() {
+    return Array.from(registry.keys());
+}

package/dist/app/composables/mappers/testHarness.d.ts

@@ -0,0 +1,13 @@
+import { MapperDefinition } from './types';
+export interface MapperTestCase<TInput, TOutput> {
+    name: string;
+    input: TInput;
+    expected: TOutput | ((output: TOutput) => void | Promise<void>);
+    snapshot?: boolean;
+}
+export interface MapperTestOptions<TInput, TOutput> {
+    mapper: MapperDefinition<TInput, TOutput>;
+    cases: MapperTestCase<TInput, TOutput>[];
+    async?: boolean;
+}
+export declare function runMapperTests<TInput, TOutput>(options: MapperTestOptions<TInput, TOutput>): Promise<void>;

package/dist/app/composables/mappers/testHarness.js

@@ -0,0 +1,98 @@
+import { MapperError } from './errors';
+export async function runMapperTests(options) {
+    const { mapper, cases } = options;
+    for (const testCase of cases) {
+        const { name, input, expected, snapshot } = testCase;
+        try {
+            const result = await maybeAsync(mapper.map, input);
+            // Snapshot mode (stringified)
+            if (snapshot) {
+                const snap = JSON.stringify(result, null, 2);
+                console.log(`\n📸 Snapshot for "${mapper.name}" → "${name}":\n${snap}\n`);
+            }
+            // Function-based expectation
+            if (isExpectedFunction(expected)) {
+                await expected(result);
+                continue;
+            }
+            // Deep equality check
+            const pass = deepEqual(result, expected);
+            if (!pass) {
+                throw new MapperError(`Mapper "${mapper.name}" test "${name}" failed.\n` +
+                    diffString(expected, result));
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new MapperError(`Mapper "${mapper.name}" test "${name}" threw an error:\n${error.message}`);
+            }
+            throw error;
+        }
+    }
+}
+/* -------------------------------------------------------
+   Helpers
+------------------------------------------------------- */
+async function maybeAsync(fn, input) {
+    return await fn(input);
+}
+function isExpectedFunction(value) {
+    return typeof value === 'function';
+}
+function deepEqual(a, b) {
+    if (Object.is(a, b))
+        return true;
+    if (typeof a !== 'object' ||
+        typeof b !== 'object' ||
+        a === null ||
+        b === null) {
+        return false;
+    }
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length)
+        return false;
+    for (const key of aKeys) {
+        if (!deepEqual(a[key], b[key]))
+            return false;
+    }
+    return true;
+}
+/**
+ * Pretty diff output (no deps)
+ */
+function diffString(expected, received) {
+    const exp = JSON.stringify(expected, null, 2);
+    const rec = JSON.stringify(received, null, 2);
+    return (`\nExpected:\n${indent(exp)}\n\nReceived:\n${indent(rec)}\n` +
+        `\nDiff:\n${indent(generateDiff(exp, rec))}`);
+}
+function indent(str) {
+    return str
+        .split('\n')
+        .map((line) => `  ${line}`)
+        .join('\n');
+}
+/**
+ * Minimal diff generator (line-by-line)
+ */
+function generateDiff(a, b) {
+    const aLines = a.split('\n');
+    const bLines = b.split('\n');
+    const max = Math.max(aLines.length, bLines.length);
+    const diff = [];
+    for (let i = 0; i < max; i++) {
+        const left = aLines[i];
+        const right = bLines[i];
+        if (left === right) {
+            diff.push(`  ${left ?? ''}`);
+        }
+        else {
+            if (left !== undefined)
+                diff.push(`- ${left}`);
+            if (right !== undefined)
+                diff.push(`+ ${right}`);
+        }
+    }
+    return diff.join('\n');
+}

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

@@ -0,0 +1,5 @@
+export type MapperFn<TInput, TOutput> = (input: TInput) => TOutput;
+export interface MapperDefinition<TInput, TOutput> {
+    name: string;
+    map: MapperFn<TInput, TOutput>;
+}

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

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

package/dist/app/composables/mappers/zodMapper.d.ts

@@ -0,0 +1,9 @@
+import type { ZodSchema } from 'zod';
+import type { MapperDefinition, MapperFn } from './types';
+export interface ZodMapperOptions<TInput, TOutput> {
+    name: string;
+    inputSchema: ZodSchema<TInput>;
+    outputSchema: ZodSchema<TOutput>;
+    map: MapperFn<TInput, TOutput>;
+}
+export declare function createZodMapper<TInput, TOutput>(options: ZodMapperOptions<TInput, TOutput>): MapperDefinition<TInput, TOutput>;

package/dist/app/composables/mappers/zodMapper.js

@@ -0,0 +1,17 @@
+import { createMapper } from './createMapper';
+import { MapperError } from './errors';
+export function createZodMapper(options) {
+    const { name, inputSchema, outputSchema, map } = options;
+    return createMapper(name, (rawInput) => {
+        const parsedInput = inputSchema.safeParse(rawInput);
+        if (!parsedInput.success) {
+            throw new MapperError(`Mapper "${name}" input validation failed: ${parsedInput.error.message}`);
+        }
+        const output = map(parsedInput.data);
+        const parsedOutput = outputSchema.safeParse(output);
+        if (!parsedOutput.success) {
+            throw new MapperError(`Mapper "${name}" output validation failed: ${parsedOutput.error.message}`);
+        }
+        return parsedOutput.data;
+    });
+}

package/dist/app/composables/media/useFile.d.ts

@@ -0,0 +1,2 @@
+import type { FilePlugin } from '../../types/index.d';
+export declare function useFile(): FilePlugin;

package/dist/app/composables/media/useFile.js

@@ -0,0 +1,4 @@
+export function useFile() {
+    const { $file } = useNuxtApp();
+    return $file;
+}

package/dist/app/composables/media/useMediaCenter.d.ts

@@ -0,0 +1,29 @@
+export declare function useMediaCenter(): {
+    allMedia: import("vue").Ref<any[], any[]>;
+    audioMedia: import("vue").ComputedRef<any[]>;
+    videoMedia: import("vue").ComputedRef<any[]>;
+    imageMedia: import("vue").ComputedRef<any[]>;
+    textMedia: import("vue").ComputedRef<any[]>;
+    documentMedia: import("vue").ComputedRef<any[]>;
+    folders: import("vue").Ref<any[], any[]>;
+    currentFolder: import("vue").Ref<string | null, string | null>;
+    sharedWithMe: import("vue").Ref<any[], any[]>;
+    searchResults: import("vue").Ref<any[], any[]>;
+    smartAlbums: import("vue").Ref<any[], any[]>;
+    isInitialLoading: import("vue").Ref<boolean, boolean>;
+    isLoadingMore: import("vue").Ref<boolean, boolean>;
+    hasMore: import("vue").Ref<boolean, boolean>;
+    fetchNextPage: () => Promise<void>;
+    uploadFiles: (files: File[], onProgress?: (info: {
+        index: number;
+        total: number;
+        status: "starting" | "done" | "error";
+        name?: string;
+    }) => void) => Promise<any[]>;
+    fetchFolders: () => Promise<void>;
+    createFolder: (name: string, parent?: string | null) => Promise<void>;
+    filterByFolder: (folderId: string | null) => void;
+    reorderFolders: (updated: any[]) => Promise<void>;
+    fetchSharedWithMe: () => Promise<void>;
+    searchMedia: (query: string) => Promise<void>;
+};

package/dist/app/composables/media/useMediaCenter.js

@@ -0,0 +1,321 @@
+import { ref, computed, unref } from 'vue';
+import { useNuxtApp } from '#imports';
+import useDirectusRequest from '../useDirectusRequest';
+import { useAuth } from '~/composables/globals/useAuth';
+export function useMediaCenter() {
+    // Prefer a BetterAuth `useAuth()` composable when available (provided by the auth layer).
+    // Fallback to null if not present so the rest of the composable degrades gracefully.
+    // `useAuth()` typically exposes `user` and `session` refs and a `fetchSession()` method.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const auth = globalThis.$useAuth ?? (typeof useAuth !== 'undefined' ? useAuth() : null);
+    const user = computed(() => {
+        if (!auth)
+            return null;
+        // If auth exposes `user` ref directly
+        if (typeof auth.user !== 'undefined')
+            return unref(auth.user) || null;
+        // If auth exposes `session` ref containing `{ user }`
+        if (typeof auth.session !== 'undefined')
+            return unref(auth.session)?.user || null;
+        return null;
+    });
+    const userId = computed(() => user.value?.id || null);
+    const { $directus, $readItems, $createItem, $uploadFiles, } = useNuxtApp();
+    // CORE MEDIA STATE
+    const allMedia = ref([]);
+    const isInitialLoading = ref(true);
+    const isLoadingMore = ref(false);
+    const hasMore = ref(true);
+    const limit = 24;
+    const offset = ref(0);
+    // FOLDERS
+    const folders = ref([]);
+    const currentFolder = ref(null);
+    // SHARED & SEARCH
+    const sharedWithMe = ref([]);
+    const searchResults = ref([]);
+    // SMART ALBUMS
+    const smartAlbums = ref([]);
+    /* ---------- MIME HELPERS ---------- */
+    const mime = (i) => i?.directus_files_id?.type || '';
+    const isAudio = (i) => mime(i).startsWith('audio');
+    const isVideo = (i) => mime(i).startsWith('video');
+    const isImage = (i) => mime(i).startsWith('image');
+    const isText = (i) => mime(i).startsWith('text');
+    const isDoc = (i) => [
+        'application/pdf',
+        'application/msword',
+        'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        'application/vnd.ms-excel',
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    ].includes(mime(i));
+    /* ---------- FILTERED LISTS ---------- */
+    const filteredMedia = computed(() => {
+        if (!currentFolder.value)
+            return allMedia.value;
+        return allMedia.value.filter(m => m.folder === currentFolder.value);
+    });
+    const audioMedia = computed(() => filteredMedia.value.filter(isAudio));
+    const videoMedia = computed(() => filteredMedia.value.filter(isVideo));
+    const imageMedia = computed(() => filteredMedia.value.filter(isImage));
+    const textMedia = computed(() => filteredMedia.value.filter(isText));
+    const documentMedia = computed(() => filteredMedia.value.filter(isDoc));
+    /* ---------- RESET PAGINATION ---------- */
+    function resetPagination() {
+        allMedia.value = [];
+        offset.value = 0;
+        hasMore.value = true;
+    }
+    /* ---------- FETCH USER MEDIA (PAGINATED) ---------- */
+    async function fetchNextPage() {
+        if (!userId.value) {
+            isInitialLoading.value = false;
+            return;
+        }
+        if (!hasMore.value)
+            return;
+        isLoadingMore.value = true;
+        const filter = { user: { _eq: userId.value } };
+        if (currentFolder.value) {
+            filter.folder = { _eq: currentFolder.value };
+        }
+        try {
+            const items = await $readItems('media', {
+                fields: [
+                    '*',
+                    { directus_files_id: ['id', 'type', 'filename_download', 'title'] },
+                ],
+                filter,
+                sort: ['-date_created'],
+                limit,
+                offset: offset.value,
+            });
+            if (!items.length) {
+                hasMore.value = false;
+            }
+            else {
+                allMedia.value.push(...items);
+                offset.value += items.length;
+                if (items.length < limit)
+                    hasMore.value = false;
+            }
+        }
+        finally {
+            isLoadingMore.value = false;
+            isInitialLoading.value = false;
+        }
+    }
+    /* ---------- UPLOAD FILES ---------- */
+    /**
+     * Upload files to Directus and create `media` entries.
+     * Uploads are performed one-by-one so callers can track progress.
+     *
+     * @param files - array of File objects
+     * @param onProgress - optional callback called with { index, total, status, name }
+     */
+    async function uploadFiles(files, onProgress) {
+        if (!userId.value) {
+            // Try to fetch session once in case the auth state wasn't loaded yet
+            try {
+                if (auth && typeof auth.fetchSession === 'function')
+                    await auth.fetchSession();
+                else if (auth && typeof auth.fetch === 'function')
+                    await auth.fetch();
+            }
+            catch (_) { }
+            if (!userId.value) {
+                try {
+                    const nuxt = useNuxtApp();
+                    const toast = nuxt?.$toast;
+                    if (toast && typeof toast.error === 'function')
+                        toast.error('You must be signed in to upload files');
+                }
+                catch (_) { }
+                throw new Error('User not authenticated');
+            }
+        }
+        const { request } = useDirectusRequest();
+        const newItems = [];
+        for (let i = 0; i < files.length; i++) {
+            const file = files[i];
+            if (!file) {
+                onProgress && onProgress({ index: i, total: files.length, status: 'error' });
+                continue;
+            }
+            try {
+                onProgress && onProgress({ index: i, total: files.length, status: 'starting', name: file.name });
+                const formData = new FormData();
+                formData.append('file', file);
+                const resp = await request($uploadFiles(formData));
+                const uploaded = Array.isArray(resp) ? resp : (resp ? [resp] : []);
+                for (const up of uploaded) {
+                    const mediaItem = await $createItem('media', {
+                        user: userId.value,
+                        directus_files_id: up.id,
+                        title: up.filename_download || up.title || up.id,
+                        folder: currentFolder.value || null,
+                    });
+                    newItems.push({ ...mediaItem, directus_files_id: up });
+                }
+                onProgress && onProgress({ index: i, total: files.length, status: 'done', name: file.name });
+            }
+            catch (e) {
+                onProgress && onProgress({ index: i, total: files.length, status: 'error', name: file.name });
+                try {
+                    const nuxt = useNuxtApp();
+                    const toast = nuxt?.$toast;
+                    if (toast && typeof toast.error === 'function')
+                        toast.error(`Upload failed: ${file.name}`);
+                }
+                catch (_) { }
+                console.error('uploadFiles failed for file', file.name, e);
+            }
+        }
+        if (newItems.length) {
+            // add newly created items to the beginning of allMedia
+            allMedia.value.unshift(...newItems);
+            try {
+                const nuxt = useNuxtApp();
+                const toast = nuxt?.$toast;
+                if (toast && typeof toast.success === 'function')
+                    toast.success(`Uploaded ${newItems.length} file${newItems.length === 1 ? '' : 's'}`);
+            }
+            catch (_) { }
+        }
+        return newItems;
+    }
+    /* ---------- FOLDERS ---------- */
+    async function fetchFolders() {
+        if (!userId.value)
+            return;
+        folders.value = await $readItems('folders', {
+            filter: { user: { _eq: userId.value } },
+            sort: ['sort', 'name'],
+        });
+    }
+    async function createFolder(name, parent = null) {
+        await $createItem('folders', {
+            name,
+            user: userId.value,
+            parent_folder: parent,
+        });
+        await fetchFolders();
+    }
+    function filterByFolder(folderId) {
+        currentFolder.value = folderId;
+        resetPagination();
+        fetchNextPage();
+    }
+    async function reorderFolders(updated) {
+        // You can persist a "sort" field here if you add it to folders.
+        // Example (pseudo-batched):
+        //
+        // for (let index = 0; index < updated.length; index++) {
+        //   const folder = updated[index]
+        //   await $directus.request(
+        //     $updateItem('folders', folder.id, { sort: index })
+        //   )
+        // }
+        //
+        // For now, we just update local state:
+        folders.value = [...updated];
+    }
+    /* ---------- SHARED WITH ME ---------- */
+    async function fetchSharedWithMe() {
+        if (!userId.value)
+            return;
+        sharedWithMe.value = await $readItems('media', {
+            fields: [
+                '*',
+                { directus_files_id: ['id', 'type', 'filename_download', 'title'] },
+            ],
+            filter: { shared_with: { _contains: userId.value } },
+            sort: ['-date_created'],
+        });
+    }
+    /* ---------- SEARCH ---------- */
+    async function searchMedia(query) {
+        if (!query) {
+            searchResults.value = [];
+            return;
+        }
+        searchResults.value = await $readItems('media', {
+            fields: [
+                '*',
+                { directus_files_id: ['id', 'type', 'filename_download', 'title'] },
+            ],
+            filter: {
+                _or: [
+                    { title: { _icontains: query } },
+                    { tags: { _icontains: query } },
+                    {
+                        directus_files_id: {
+                            title: { _icontains: query },
+                        },
+                    },
+                ],
+            },
+            sort: ['-date_created'],
+        });
+    }
+    /* ---------- SMART ALBUMS ---------- */
+    const smartAlbumsComputed = computed(() => {
+        const albums = [];
+        const now = new Date();
+        const todayKey = now.toISOString().slice(0, 10);
+        const buckets = {};
+        for (const item of allMedia.value) {
+            const dateKey = (item.date_created || '').slice(0, 10) || 'unknown';
+            const typeBucket = isImage(item)
+                ? 'Images'
+                : isVideo(item)
+                    ? 'Videos'
+                    : isAudio(item)
+                        ? 'Audio'
+                        : 'Other';
+            const key = dateKey === todayKey
+                ? `Today / ${typeBucket}`
+                : `${dateKey} / ${typeBucket}`;
+            if (!buckets[key])
+                buckets[key] = [];
+            buckets[key].push(item);
+        }
+        for (const key of Object.keys(buckets)) {
+            albums.push({
+                id: key,
+                label: key,
+                items: buckets[key],
+            });
+        }
+        return albums;
+    });
+    smartAlbums.value = smartAlbumsComputed.value;
+    /* ---------- RETURN API ---------- */
+    return {
+        // state
+        allMedia,
+        audioMedia,
+        videoMedia,
+        imageMedia,
+        textMedia,
+        documentMedia,
+        folders,
+        currentFolder,
+        sharedWithMe,
+        searchResults,
+        smartAlbums,
+        // flags
+        isInitialLoading,
+        isLoadingMore,
+        hasMore,
+        // actions
+        fetchNextPage,
+        uploadFiles,
+        fetchFolders,
+        createFolder,
+        filterByFolder,
+        reorderFolders,
+        fetchSharedWithMe,
+        searchMedia,
+    };
+}

package/dist/app/composables/media/useVideojs.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Composable wrapper for the shared `videojs` Nuxt plugin.
+ * Provides access to the provided `videojs` instance and registration helpers.
+ */
+export default function useVideojs(): {
+    videojs: any;
+    registerVideojsPlugin: any;
+    registerVideojsPlugins: any;
+    createPlayer: (el: Element | string | null, options?: any, ready?: (this: any) => void) => any;
+    disposePlayer: (player: any) => void;
+};

package/dist/app/composables/media/useVideojs.js

@@ -0,0 +1,42 @@
+import { useNuxtApp } from '#imports';
+/**
+ * Composable wrapper for the shared `videojs` Nuxt plugin.
+ * Provides access to the provided `videojs` instance and registration helpers.
+ */
+export default function useVideojs() {
+    const nuxtApp = useNuxtApp();
+    // Provided by layers/shared-app/app/plugins/videojs.client.js
+    const videojs = nuxtApp.$videojs || null;
+    const registerVideojsPlugin = nuxtApp.$registerVideojsPlugin || ((name, plugin) => { });
+    const registerVideojsPlugins = nuxtApp.$registerVideojsPlugins || ((defs) => { });
+    function createPlayer(el, options, ready) {
+        if (!videojs) {
+            // fallback: try to import dynamically (client-side only)
+            // but avoid bundling here; return null instead
+            return null;
+        }
+        try {
+            return videojs(el, options, ready);
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.warn('[useVideojs] createPlayer failed', e);
+            return null;
+        }
+    }
+    function disposePlayer(player) {
+        try {
+            player && typeof player.dispose === 'function' && player.dispose();
+        }
+        catch (e) {
+            // ignore
+        }
+    }
+    return {
+        videojs,
+        registerVideojsPlugin,
+        registerVideojsPlugins,
+        createPlayer,
+        disposePlayer,
+    };
+}

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

@@ -0,0 +1,3 @@
+import { ContentProvider } from "./types";
+export declare function registerContentProvider(name: string, provider: ContentProvider): void;
+export declare function getContentProvider(name: string): ContentProvider;

package/dist/app/composables/registry.js

@@ -0,0 +1,10 @@
+const providers = {};
+export function registerContentProvider(name, provider) {
+    providers[name] = provider;
+}
+export function getContentProvider(name) {
+    const provider = providers[name];
+    if (!provider)
+        throw new Error(`Content provider "${name}" not found`);
+    return provider;
+}

package/dist/app/composables/schema/commerce/attributes.d.ts

@@ -0,0 +1,7 @@
+export interface MeeoviAttribute {
+    id: number;
+    default_label?: string | null;
+    isPublic?: boolean | null;
+    options?: Record<string, unknown> | null;
+    attribute_code?: string | null;
+}

package/dist/app/composables/schema/commerce/attributes.js

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

package/dist/app/composables/schema/commerce/blocks.d.ts

@@ -0,0 +1,6 @@
+export interface MeeoviBlock {
+    id: string;
+    type: string;
+    content: string | null;
+    metadata?: Record<string, unknown>;
+}

package/dist/app/composables/schema/commerce/blocks.js

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

package/dist/app/composables/schema/commerce/bundleProduts.d.ts

@@ -0,0 +1,10 @@
+import { MeeoviProduct } from './product';
+export interface MeeoviBundleProduct {
+    id: string;
+    title: string;
+    items: MeeoviProduct[];
+    price: number;
+    currency: string;
+    stock: number | null;
+    metadata?: Record<string, unknown>;
+}

package/dist/app/composables/schema/commerce/bundleProduts.js

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

package/dist/app/composables/schema/commerce/cart.d.ts

@@ -0,0 +1,29 @@
+export interface MeeoviCartItem {
+    id: number;
+    quantity?: number | null;
+    metadata?: Record<string, unknown> | null;
+    products?: string | null;
+    cart?: number | null;
+    product_id?: string | null;
+    price?: number | null;
+    total?: number | null;
+    variant_id?: string | null;
+    variant?: string | null;
+}
+export interface MeeoviCart {
+    id: number;
+    date_created?: string | null;
+    user_updated?: string | null;
+    date_updated?: string | null;
+    session_id?: string | null;
+    total_price?: number | null;
+    user?: string | null;
+    status?: string | null;
+    subtotal?: number | null;
+    tax_amount?: number | null;
+    shipping_amount?: number | null;
+    discount_amount?: number | null;
+    total?: number | null;
+    currency?: string | null;
+    coupon_code?: string | null;
+}

package/dist/app/composables/schema/commerce/cart.js

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