@meeovi/layer-social 1.0.3

package/app/composables/settings/useAccessibilitySettings.js

@@ -0,0 +1,43 @@
+import { ref, watch } from 'vue'
+
+export function useAccessibilitySettings() {
+  const highContrast = ref(false)
+  const fontSize = ref(16)
+
+  // Load settings from localStorage on initialization
+  if (process.client) {
+    const savedSettings = localStorage.getItem('accessibilitySettings')
+    if (savedSettings) {
+      const { highContrast: savedHighContrast, fontSize: savedFontSize } = JSON.parse(savedSettings)
+      highContrast.value = savedHighContrast
+      fontSize.value = savedFontSize
+    }
+  }
+
+  // Watch for changes and save to localStorage
+  watch([highContrast, fontSize], () => {
+    if (process.client) {
+      localStorage.setItem('accessibilitySettings', JSON.stringify({
+        highContrast: highContrast.value,
+        fontSize: fontSize.value
+      }))
+    }
+  }, { deep: true })
+
+  // Apply settings to the document
+  const applySettings = () => {
+    if (process.client) {
+      document.body.style.fontSize = `${fontSize.value}px`
+      document.body.classList.toggle('high-contrast', highContrast.value)
+    }
+  }
+
+  // Call applySettings initially and whenever settings change
+  watch([highContrast, fontSize], applySettings, { immediate: true })
+
+  return {
+    highContrast,
+    fontSize,
+    applySettings
+  }
+}

package/app/composables/shorts/createShort.js

@@ -0,0 +1,33 @@
+// composables/cms/shorts/createSpace.js
+import { createItem } from '@directus/sdk';
+
+export default async function createSpace(shortData) {
+    const { $directus } = useNuxtApp();
+    
+    try {
+        const short = await $directus.request(createItem('shorts', {
+            name: shortData.name,
+            description: shortData.description,
+            status: shortData.status,
+            type: shortData.type,
+            video: shortData.video,
+            video_url: shortData.video_url,
+            age_restriction: shortData.age_restriction,
+            duration: shortData.duration,
+            thumbnailFile: shortData.thumbnailFile,
+            videoFile: shortData.videoFile,
+            creator: shortData.creator,
+            // Match the structure from your GraphQL query
+            departments: {
+                create: [{
+                    departments_id: shortData.departments
+                }]
+            }
+        }));
+        
+        return short;
+    } catch (error) {
+        console.error('Error creating short:', error);
+        throw error;
+    }
+}

package/app/composables/shorts/deleteShort.js

@@ -0,0 +1,15 @@
+// composables/deleteShort.js
+import { deleteItem } from '@directus/sdk';
+
+export default async function deleteShort(shortId) {
+    const { $directus } = useNuxtApp();
+  
+    try {
+      $directus.request(deleteItem('shorts', shortId));
+      console.log('Short deleted successfully');
+    } catch (error) {
+      console.error('Error deleting short:', error);
+      throw error;
+    }
+  }
+  

package/app/composables/shorts/updateShort.js

@@ -0,0 +1,15 @@
+// composables/updateShort.js
+import { updateItem } from '@directus/sdk';
+
+export default async function updateShort(shortId, shortData) {
+    const { $directus } = useNuxtApp();
+  
+    try {
+      const short = await $directus.request(updateItem('shorts', shortId));
+      return short;
+    } catch (error) {
+      console.error('Error updating short:', error);
+      throw error;
+    }
+  }
+  

package/app/composables/social/getActivity.js

@@ -0,0 +1,33 @@
+import { useRuntimeConfig } from 'nuxt/config';
+
+export const getActivity = async () => {
+  const config = useRuntimeConfig();
+  try {
+    const activities = await $fetch(`${config.public.wordpressUrl}/wp-json/buddypress/v1/activity`, {
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${config.public.wordpressToken}`
+      }
+    });
+    return activities;
+  } catch (error) {
+    console.error('Error fetching activities:', error);
+    return [];
+  }
+};
+
+export const getActivityById = async (id) => {
+  const config = useRuntimeConfig();
+  try {
+    const activity = await $fetch(`${config.public.wordpressUrl}/wp-json/buddypress/v1/activity/${id}`, {
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${config.public.wordpressToken}`
+      }
+    });
+    return activity;
+  } catch (error) {
+    console.error('Error fetching activity:', error);
+    return [];
+  }
+};

package/app/composables/social/getGroups.js

@@ -0,0 +1,33 @@
+import { useRuntimeConfig } from 'nuxt/config';
+
+export const getGroups = async () => {
+  const config = useRuntimeConfig();
+  try {
+    const groups = await $fetch(`${config.public.wordpressUrl}/wp-json/buddypress/v1/groups`, {
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${config.public.wordpressToken}`
+      }
+    });
+    return groups;
+  } catch (error) {
+    console.error('Error fetching groups:', error);
+    return [];
+  }
+};
+
+export const getGroupById = async (id) => {
+  const config = useRuntimeConfig();
+  try {
+    const group = await $fetch(`${config.public.wordpressUrl}/wp-json/buddypress/v1/groups/${id}`, {
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${config.public.wordpressToken}`
+      }
+    });
+    return group;
+  } catch (error) {
+    console.error('Error fetching group:', error);
+    return [];
+  }
+};

package/app/composables/spaces/createSpace.js

@@ -0,0 +1,29 @@
+// composables/cms/spaces/createSpace.js
+import { createItem } from '@directus/sdk';
+
+export default async function createSpace(spaceData) {
+    const { $directus } = useNuxtApp();
+    
+    try {
+        const space = await $directus.request(createItem('spaces', {
+            name: spaceData.name,
+            description: spaceData.description,
+            status: spaceData.status,
+            type: spaceData.type,
+            coverFile: spaceData.coverFile,
+            avatarFile: spaceData.avatarFile,
+            creator: spaceData.creator,
+            // Match the structure from your GraphQL query
+            departments: {
+                create: [{
+                    departments_id: spaceData.departments
+                }]
+            }
+        }));
+        
+        return space;
+    } catch (error) {
+        console.error('Error creating space:', error);
+        throw error;
+    }
+}

package/app/composables/spaces/deleteSpace.js

@@ -0,0 +1,15 @@
+// composables/deleteSpace.js
+import { deleteItem } from '@directus/sdk';
+
+export default async function deleteSpace(spaceId) {
+    const { $directus } = useNuxtApp();
+  
+    try {
+      $directus.request(deleteItem('spaces', spaceId));
+      console.log('Space deleted successfully');
+    } catch (error) {
+      console.error('Error deleting space:', error);
+      throw error;
+    }
+  }
+  

package/app/composables/spaces/updateSpace.js

@@ -0,0 +1,15 @@
+// composables/updatePost.js
+import { updateItem } from '@directus/sdk';
+
+export default async function updatePost(spaceId, spaceData) {
+    const { $directus } = useNuxtApp();
+  
+    try {
+      const space = await $directus.request(updateItem('spaces', spaceId));
+      return space;
+    } catch (error) {
+      console.error('Error updating space:', error);
+      throw error;
+    }
+  }
+  

package/app/composables/spaces/useSpaceRegistry.ts

@@ -0,0 +1,49 @@
+// composables/useSpaceRegistry.ts
+type ReadItemsFn = (collection: string, options?: { fields?: string[]; filter?: Record<string, any> }) => Promise<Array<Record<string, any>>>
+
+/**
+ * Pure fetcher: builds the registry using a provided Nuxt app instance.
+ * Use this when you are outside of a Vue setup function (for example in a page
+ * async loader where you already have access to `useNuxtApp()` or in a plugin).
+ */
+export async function fetchSpaceRegistry(nuxtApp: { $readItems?: ReadItemsFn }) {
+  if (!nuxtApp || typeof nuxtApp.$readItems !== 'function') {
+    throw new Error('fetchSpaceRegistry requires a Nuxt app instance with `$readItems`')
+  }
+
+  const { $readItems } = nuxtApp
+
+  const spaces = await $readItems('space_type', {
+    fields: ['slug', 'component_path', 'layout_name'],
+    filter: { enabled: { _eq: true } }
+  })
+
+  const registry: Record<string, {
+    layout: string
+    component: () => Promise<any>
+  }> = {}
+
+  for (const space of spaces) {
+    registry[space.slug] = {
+      layout: space.layout_name,
+      component: () => import(/* @vite-ignore */ space.component_path)
+    }
+  }
+
+  return registry
+}
+
+/**
+ * Composable wrapper: convenience function for use inside Vue `setup()`.
+ * If you call this outside of a setup/plugin/middleware you MUST pass a
+ * Nuxt app instance explicitly to avoid the "called outside" error.
+ */
+export const useSpaceRegistry = async (nuxtApp?: { $readItems?: ReadItemsFn }) => {
+  const nuxt = nuxtApp ?? (typeof useNuxtApp === 'function' ? useNuxtApp() : undefined)
+
+  if (!nuxt) {
+    throw new Error('useSpaceRegistry must be called inside a Vue setup() or you must pass a Nuxt app instance as the first argument')
+  }
+
+  return fetchSpaceRegistry(nuxt as { $readItems?: ReadItemsFn })
+}

package/app/composables/stations/createStation.js

@@ -0,0 +1,33 @@
+// composables/createStation.js
+import { createItem } from '@directus/sdk';
+
+export default async function createStation(stationData) {
+    const route = useRoute();
+
+    const id = route.params.id;
+    const { $directus } = useNuxtApp();
+  
+    try {
+      const station = await $directus.request(createItem('radios', [
+        {
+          name: stationData.name,
+          description: stationData.description,
+          status: stationData.status,
+          type: stationData.type,
+          image: stationData.image,
+          media: stationData.media,
+          video: stationData.video,
+          document: stationData.document,
+          color: stationData.color,
+          coverFile: null,
+          avatarFile: null,
+          creator: stationData.creator,
+        }
+      ]));
+      return station;
+    } catch (error) {
+      console.error('Error creating station:', error);
+      throw error;
+    }
+  }
+  

package/app/composables/stations/deleteStation.js

@@ -0,0 +1,15 @@
+// composables/deleteStation.js
+import { deleteItem } from '@directus/sdk';
+
+export default async function deleteStation(stationId) {
+    const { $directus } = useNuxtApp();
+  
+    try {
+      $directus.request(deleteItem('radios', stationId));
+      console.log('Station deleted successfully');
+    } catch (error) {
+      console.error('Error deleting station:', error);
+      throw error;
+    }
+  }
+  

package/app/composables/stations/updateStation.js

@@ -0,0 +1,15 @@
+// composables/updateStation.js
+import { updateItem } from '@directus/sdk';
+
+export default async function updateStation(stationId, stationData) {
+    const { $directus } = useNuxtApp();
+  
+    try {
+      const station = await $directus.request(updateItem('radios', stationId));
+      return station;
+    } catch (error) {
+      console.error('Error updating station:', error);
+      throw error;
+    }
+  }
+  

package/app/composables/swr.ts

@@ -0,0 +1,22 @@
+import { getSocialCache } from './cache'
+
+const refreshQueue = new Map<string, Promise<any>>()
+
+export function scheduleBackgroundRefresh(
+  key: string,
+  fn: () => Promise<any>,
+  ttlMs: number
+) {
+  if (refreshQueue.has(key)) return
+
+  const promise = fn()
+    .then((fresh) => {
+      const cache = getSocialCache()
+      cache.set(key, fresh, ttlMs)
+    })
+    .finally(() => {
+      refreshQueue.delete(key)
+    })
+
+  refreshQueue.set(key, promise)
+}

package/app/composables/types/BlueSkyTypes.ts

@@ -0,0 +1,108 @@
+export type Thread = {
+    thread: ThreadViewPost;
+};
+
+export type ThreadViewPost = {
+    $type: string;
+    post: Post;
+    replies: ThreadViewPost[];
+};
+export type DisplayThread = {
+    isReply: boolean;
+    post: Post;
+    replies: DisplayThread[];
+}
+
+export type Post = {
+    uri: string;
+    cid: string;
+    author: Author;
+    record: Record;
+    embed?: EmbedView;
+    replyCount: number;
+    repostCount: number;
+    likeCount: number;
+    quoteCount: number;
+    indexedAt: string;
+    labels: Label[];
+};
+
+export type Author = {
+    did: string;
+    handle: string;
+    displayName: string;
+    avatar?: string;
+    labels: Label[];
+    createdAt: string;
+};
+
+export type Record = {
+    $type: string;
+    createdAt: string;
+    embed?: EmbedImages;
+    facets?: Facet[];
+    text: string;
+    langs?: string[];
+    reply?: Reply;
+};
+
+export type EmbedImages = {
+    $type: string;
+    images: Image[];
+};
+
+export type EmbedView = {
+    $type: string;
+    images: ImageView[];
+};
+
+export type Image = {
+    alt: string;
+    image: Blob;
+};
+
+export type ImageView = {
+    thumb: string;
+    fullsize: string;
+    alt: string;
+};
+
+export type Blob = {
+    $type: string;
+    ref: Link;
+    mimeType: string;
+    size: number;
+};
+
+export type Link = {
+    $link: string;
+};
+
+export type Facet = {
+    $type?: string;
+    features: Feature[];
+    index: Index;
+};
+
+export type Feature = {
+    $type: string;
+    uri?: string;
+    did?: string;
+};
+
+export type Index = {
+    byteStart: number;
+    byteEnd: number;
+};
+
+export type Reply = {
+    parent: ReplyReference;
+    root: ReplyReference;
+};
+
+export type ReplyReference = {
+    cid: string;
+    uri: string;
+};
+
+export type Label = {};

package/app/composables/types.ts

@@ -0,0 +1,28 @@
+export interface SocialProfile {
+  id: string
+  username: string
+  displayName?: string
+  avatarUrl?: string
+  url?: string
+  [key: string]: any
+}
+
+export interface SocialPost {
+  id: string
+  content: string
+  createdAt: string
+  author: SocialProfile
+  url?: string
+  [key: string]: any
+}
+
+export interface SocialActivity extends SocialPost {
+  provider: string
+  source?: string
+}
+
+export interface SocialProvider {
+  getProfile(handle: string): Promise<SocialProfile>
+  listPosts(handle: string, options?: Record<string, any>): Promise<SocialPost[]>
+  createPost?(content: string, options?: Record<string, any>): Promise<SocialPost>
+}

package/app/composables/useSocial.ts

@@ -0,0 +1,25 @@
+import { getSocialConfig } from './config'
+import { getSocialProvider } from './registry'
+import type { SocialActivity } from './types'
+
+export function useSocial() {
+  const { provider } = getSocialConfig()
+  const socialProvider = getSocialProvider(provider)
+
+  async function getActivityFeed(handle: string, options?: Record<string, any>): Promise<SocialActivity[]> {
+    const posts = await socialProvider.listPosts(handle, options)
+
+    return posts.map((post) => ({
+      ...post,
+      provider,
+      source: provider
+    }))
+  }
+
+  return {
+    getProfile: socialProvider.getProfile,
+    listPosts: socialProvider.listPosts,
+    createPost: socialProvider.createPost,
+    getActivityFeed
+  }
+}

package/app/composables/utils.ts

@@ -0,0 +1,99 @@
+// utils.ts
+
+import { RateLimitError, SocialError } from './errors'
+import { getSocialCache } from './cache'
+import { withRetry } from './retry'
+import { scheduleBackgroundRefresh } from './swr'
+import { checkRateLimit } from './rateLimit'
+import {
+  recordRequest,
+  recordSuccess,
+  recordFailure,
+  recordCacheHit,
+  recordCacheMiss
+} from './metrics'
+
+export interface RequestOptions {
+  cacheKey?: string
+  ttlMs?: number
+  retry?: boolean
+  swr?: boolean
+}
+
+/**
+ * Core wrapper for all provider requests.
+ * Handles:
+ * - caching
+ * - SWR background refresh
+ * - retry/backoff
+ * - provider-specific rate limits
+ * - unified error handling
+ * - analytics hooks
+ */
+export async function wrapSocialRequest<T>(
+  provider: string,
+  fn: () => Promise<T>,
+  opts: RequestOptions = {}
+): Promise<T> {
+  const cache = getSocialCache()
+
+  // Track request attempt
+  recordRequest(provider)
+
+  // Provider-specific rate limit enforcement
+  checkRateLimit(provider)
+
+  // 1. Cache check
+  if (opts.cacheKey) {
+    const cached = cache.get<T>(opts.cacheKey)
+
+    if (cached) {
+      recordCacheHit(provider)
+
+      // SWR: return cached immediately, refresh in background
+      if (opts.swr && opts.ttlMs) {
+        scheduleBackgroundRefresh(opts.cacheKey, fn, opts.ttlMs)
+      }
+
+      return cached
+    }
+
+    recordCacheMiss(provider)
+  }
+
+  // 2. Execute request (with optional retry/backoff)
+  let result: T
+
+  try {
+    result = await (opts.retry ? withRetry(fn) : fn())
+    recordSuccess(provider)
+  } catch (err: any) {
+    recordFailure(provider)
+
+    const status = err?.status || err?.response?.status
+    const retryAfterHeader = err?.response?.headers?.['retry-after']
+    const retryAfter = retryAfterHeader ? Number(retryAfterHeader) : undefined
+
+    if (status === 429) {
+      throw new RateLimitError(
+        `Rate limit exceeded for provider "${provider}"`,
+        provider,
+        retryAfter,
+        err
+      )
+    }
+
+    throw new SocialError(
+      `Social provider "${provider}" request failed`,
+      provider,
+      err
+    )
+  }
+
+  // 3. Cache fresh result
+  if (opts.cacheKey && opts.ttlMs) {
+    cache.set(opts.cacheKey, result, opts.ttlMs)
+  }
+
+  return result
+}

package/app/layouts/spaces-audio.vue

@@ -0,0 +1,9 @@
+<template>
+    <div>
+
+    </div>
+</template>
+
+<script setup>
+
+</script>

package/app/layouts/spaces-dating.vue

@@ -0,0 +1,9 @@
+<template>
+    <div>
+
+    </div>
+</template>
+
+<script setup>
+
+</script>

package/app/layouts/spaces-forum.vue

@@ -0,0 +1,9 @@
+<template>
+    <div>
+
+    </div>
+</template>
+
+<script setup>
+
+</script>

package/app/layouts/spaces-video.vue

@@ -0,0 +1,9 @@
+<template>
+    <div>
+
+    </div>
+</template>
+
+<script setup>
+
+</script>