@meeovi/layer-commerce 1.0.13 → 1.1.0

package/app/cart/useCart.ts

@@ -0,0 +1 @@
+export * from '../composables/cart/useCart'

package/app/composables/domain/product.ts

@@ -1,3 +1,5 @@
+import type { Price, ProductVariant } from '../../types/product'
+
 export interface Product {
   id: string
   title: string

package/app/composables/featured-products.ts

@@ -0,0 +1,20 @@
+import { useProducts } from './useProducts/useProducts'
+
+export function useFeaturedProducts() {
+  const { fetchProducts } = useProducts()
+  return {
+    async getFeaturedProducts(options: any = {}) {
+      const items = await fetchProducts()
+      // If fetchProducts returns a ref/computed, attempt to unwrap
+      // and filter by a common `featured` flag if present
+      try {
+        const list = (items as any)?.value ?? items
+        return (Array.isArray(list) ? list.filter((p: any) => p.featured || p.is_featured || p.isFeatured) : []) as any[]
+      } catch (e) {
+        return []
+      }
+    }
+  }
+}
+
+export default useFeaturedProducts

package/app/composables/orders.ts

@@ -0,0 +1,69 @@
+import { getCommerceClient } from '../utils/client'
+
+function clientOrNull() {
+  try {
+    return getCommerceClient()
+  } catch (e) {
+    return null
+  }
+}
+
+export function useOrders() {
+  const client = clientOrNull()
+  return {
+    async getOrders(filters: any = {}) {
+      if (client && typeof client.listOrders === 'function') return client.listOrders(filters)
+      return []
+    },
+    async getOrderById(id: string) {
+      if (client && typeof client.getOrder === 'function') return client.getOrder(id)
+      return null
+    }
+  }
+}
+
+export function useReturns() {
+  const client = clientOrNull()
+  return {
+    async getReturns(opts: any = {}) {
+      if (client && typeof client.listReturns === 'function') return client.listReturns(opts)
+      return []
+    },
+    async createReturn(data: any) {
+      if (client && typeof client.createReturn === 'function') return client.createReturn(data)
+      return null
+    }
+  }
+}
+
+export function useTransactions() {
+  const client = clientOrNull()
+  return {
+    async getTransactions(opts: any = {}) {
+      if (client && typeof client.listTransactions === 'function') return client.listTransactions(opts)
+      return []
+    }
+  }
+}
+
+export function useInvoices() {
+  const client = clientOrNull()
+  return {
+    async getInvoices(opts: any = {}) {
+      if (client && typeof client.listInvoices === 'function') return client.listInvoices(opts)
+      return []
+    }
+  }
+}
+
+export function useCreditMemos() {
+  const client = clientOrNull()
+  return {
+    async getCreditMemos(opts: any = {}) {
+      if (client && typeof client.listCreditMemos === 'function') return client.listCreditMemos(opts)
+      return []
+    }
+  }
+}
+
+export default useOrders

package/app/composables/products.ts

@@ -0,0 +1,30 @@
+import { useProducts as _useProducts } from './useProducts/useProducts'
+
+export function useProducts() {
+	const core = _useProducts()
+	return {
+		// map older names used in stores to the implementation
+		getProducts: async (opts?: any) => {
+			const res = await core.fetchProducts()
+			const maybe = (res as any)?.value ?? res
+			return maybe || []
+		},
+		getProductById: async (id: string) => {
+			const res = await core.fetchProducts()
+			const maybe = (res as any)?.value ?? res
+			return (Array.isArray(maybe) ? maybe.find((p: any) => p.id === id || p.sku === id) || null : null)
+		},
+		getProductsByCategory: async (categoryId: string, opts?: any) => {
+			const res = await core.fetchProducts()
+			const maybe = (res as any)?.value ?? res
+			return Array.isArray(maybe) ? maybe.filter((p: any) => p.category_id === categoryId || p.category === categoryId) : []
+		},
+		searchProducts: async (query: string, opts?: any) => {
+			const res = await core.fetchProducts()
+			const maybe = (res as any)?.value ?? res
+			return Array.isArray(maybe) ? maybe.filter((p: any) => (p.name || p.title || '').toLowerCase().includes((query || '').toLowerCase())) : []
+		}
+	}
+}
+
+export default useProducts

package/app/composables/useAuth.ts

@@ -0,0 +1,43 @@
+import { ref } from 'vue'
+
+export function useAuth() {
+  const token = ref<string | null>(process.env.MAGENTO_TOKEN || null)
+  const refreshInProgress = ref(false)
+
+  function isTokenExpired() {
+    // Best-effort check: token may be JWT
+    if (!token.value) return true
+    try {
+      const parts = token.value.split('.')
+      if (parts.length !== 3) return false
+      const payload = JSON.parse(atob(parts[1]))
+      const exp = payload.exp as number | undefined
+      if (!exp) return false
+      return Date.now() / 1000 > exp - 30
+    } catch {
+      return false
+    }
+  }
+
+  async function refreshAccessToken() {
+    if (refreshInProgress.value) return
+    refreshInProgress.value = true
+    try {
+      const resp = await fetch(`${process.env.MAGENTO_API_URL}/auth/refresh`, { method: 'POST', credentials: 'include' })
+      if (resp.ok) {
+        const data = await resp.json()
+        token.value = data.token || token.value
+      }
+    } finally {
+      refreshInProgress.value = false
+    }
+  }
+
+  function logout() {
+    token.value = null
+  }
+
+  return { token, isTokenExpired, refreshAccessToken, logout }
+}
+
+export default useAuth

package/app/composables/useCache.ts

@@ -0,0 +1,38 @@
+export function useCache() {
+  const store = new Map<string, any>()
+
+  function setCacheItem(key: string, value: any) {
+    try {
+      store.set(key, value)
+      if (typeof window !== 'undefined' && window.localStorage) {
+        localStorage.setItem(key, JSON.stringify(value))
+      }
+    } catch (e) {
+      // ignore storage failures
+    }
+  }
+
+  function getCacheItem<T = any>(key: string): T | null {
+    if (store.has(key)) return store.get(key)
+    try {
+      if (typeof window !== 'undefined' && window.localStorage) {
+        const raw = localStorage.getItem(key)
+        if (raw) {
+          const parsed = JSON.parse(raw)
+          store.set(key, parsed)
+          return parsed as T
+        }
+      }
+    } catch {}
+    return null
+  }
+
+  function removeCacheItem(key: string) {
+    store.delete(key)
+    try { if (typeof window !== 'undefined' && window.localStorage) localStorage.removeItem(key) } catch {}
+  }
+
+  return { setCacheItem, getCacheItem, removeCacheItem }
+}
+
+export default useCache

package/app/composables/useInventory.ts

@@ -0,0 +1,21 @@
+export function useInventory() {
+  async function checkInventory(sku: string, qty: number) {
+    try {
+      const url = `${process.env.MAGENTO_API_URL}/inventory/${encodeURIComponent(sku)}`
+      const res = await fetch(url)
+      if (!res.ok) return false
+      const data = await res.json()
+      // Expecting an object { available: number }
+      const available = (data?.available ?? data?.qty ?? 0) as number
+      return available >= qty
+    } catch (e) {
+      // If inventory service is unavailable, fail-safe to false
+      console.error('Inventory check failed', e)
+      return false
+    }
+  }
+
+  return { checkInventory }
+}
+
+export default useInventory

package/app/composables/useLoading.ts

@@ -0,0 +1,21 @@
+import { ref } from 'vue'
+
+export function useLoading() {
+  const active = ref<Record<string, boolean>>({})
+
+  function startLoading(key = 'default') {
+    active.value[key] = true
+  }
+
+  function stopLoading(key = 'default') {
+    delete active.value[key]
+  }
+
+  function isLoading(key = 'default') {
+    return Boolean(active.value[key])
+  }
+
+  return { startLoading, stopLoading, isLoading, active }
+}
+
+export default useLoading

package/app/composables/useNotification.ts

@@ -0,0 +1,21 @@
+import { ref } from 'vue'
+
+export type NotificationPayload = { type: 'success'|'error'|'info'|'warning'; message: string }
+
+const notifications = ref<NotificationPayload[]>([])
+
+export function useNotification() {
+  function show(payload: NotificationPayload) {
+    notifications.value.push(payload)
+    // For production-grade UX integrate with a toast library here.
+    // Using console as fallback to keep runtime deterministic.
+    if (payload.type === 'error') console.error(payload.message)
+    else console.log(payload.type.toUpperCase(), payload.message)
+  }
+
+  function clear() { notifications.value = [] }
+
+  return { notifications, show, clear }
+}
+
+export default useNotification

package/app/composables/useTax.ts

@@ -0,0 +1,17 @@
+export function useTax() {
+  async function calculateTax(quoteId: string) {
+    try {
+      const url = `${process.env.MAGENTO_API_URL}/tax/calculate?quoteId=${encodeURIComponent(quoteId)}`
+      const res = await fetch(url)
+      if (!res.ok) throw new Error('Tax calculation failed')
+      return res.json()
+    } catch (e) {
+      console.error('Tax calculation error', e)
+      throw e
+    }
+  }
+
+  return { calculateTax }
+}
+
+export default useTax

package/app/modules/vue-head/composables/useHead.ts

@@ -1,3 +1,22 @@
-export default function useHead(_: any = {}) {
-  return {}
+export default function useHead(meta: { title?: string; description?: string; titleTemplate?: (titleChunk: any) => string } = {}) {
+  if (typeof document !== 'undefined') {
+    if (meta.title) {
+      const resolvedTitle = typeof meta.title === 'function' ? (meta.title as any)() : meta.title
+      document.title = resolvedTitle
+    }
+    if (meta.description) {
+      let desc = document.querySelector('meta[name="description"]')
+      if (!desc) {
+        desc = document.createElement('meta')
+        desc.setAttribute('name', 'description')
+        document.head.appendChild(desc)
+      }
+      desc.setAttribute('content', meta.description)
+    }
+  }
+  return {
+    set(metaUpdate: { title?: string; description?: string; titleTemplate?: (titleChunk: any) => string }) {
+      return useHead(metaUpdate)
+    }
+  }
 }

package/app/pages/departments/[...slug].vue

@@ -232,9 +232,7 @@
 </template>
 
 <script setup>
-    import shorts from '#social/app/components/related/short.vue'
-    import spaces from '#social/app/components/related/space.vue'
-    import productCard from '#commerce/app/components/catalog/product/productCard.vue'
+        import productCard from '#commerce/app/components/catalog/product/productCard.vue'
     import travel from '@/components/categories/travel.vue'
     import deals from '@/components/categories/deals.vue'
     import timeComponent from '@/components/categories/time/time.vue'

package/app/pages/departments/category/[...slug].vue

@@ -77,7 +77,7 @@
     import stations from '~/components/categories/stations.vue'
     import eats from '~/components/categories/eats.vue'
     import restaurants from '~/components/categories/restaurants.vue'
-    import productCard from '#commerce/app/components/catalog/product/productCard.vue'
+    import productCard from '~/components/catalog/product/productCard.vue'
 
     const route = useRoute()
     const {

package/app/services/magento.ts

@@ -0,0 +1,49 @@
+export class MagentoService {
+  baseUrl: string
+  constructor(baseUrl?: string) {
+    this.baseUrl = baseUrl || (process.env.MAGENTO_API_URL as string) || ''
+  }
+
+  private headers(token?: string) {
+    const h: Record<string,string> = { 'Content-Type': 'application/json' }
+    if (token) h['Authorization'] = `Bearer ${token}`
+    return h
+  }
+
+  async fetchJSON(path: string, opts: RequestInit = {}, token?: string) {
+    const url = path.startsWith('http') ? path : `${this.baseUrl.replace(/\/$/, '')}/${path.replace(/^\//, '')}`
+    const res = await fetch(url, { ...opts, headers: { ...(opts.headers as any || {}), ...this.headers(token) } })
+    if (!res.ok) {
+      const text = await res.text().catch(()=>'')
+      const err = new Error(`Magento API error ${res.status}: ${text}`)
+      throw err
+    }
+    return res.json()
+  }
+
+  async getProduct(sku: string) {
+    return this.fetchJSON(`/products/${encodeURIComponent(sku)}`)
+  }
+
+  async createGuestCart() {
+    return this.fetchJSON('/guest-carts', { method: 'POST' })
+  }
+
+  async createCustomerCart(token: string) {
+    return this.fetchJSON('/carts/mine', { method: 'POST' }, token)
+  }
+
+  async addItemToCart(token: string, item: any) {
+    return this.fetchJSON('/carts/mine/items', { method: 'POST', body: JSON.stringify({ cartItem: item }) }, token)
+  }
+
+  async getCartTotals(token: string) {
+    return this.fetchJSON('/carts/mine/totals', {}, token)
+  }
+
+  async clearCart(token: string) {
+    return this.fetchJSON('/carts/mine/clear', { method: 'POST' }, token)
+  }
+}
+
+export default MagentoService

package/app/{composables/stores → stores}/cartStore.ts

@@ -1,6 +1,22 @@
 // stores/cartStore.ts
 import { defineStore } from 'pinia'
 import { MagentoService } from '~/services/magento'
+import { useAuth } from '~/composables/useAuth'
+import { useInventory } from '~/composables/useInventory'
+import { useTax } from '~/composables/useTax'
+import { useLoading } from '~/composables/useLoading'
+import { useNotification } from '~/composables/useNotification'
+import { useCache } from '~/composables/useCache'
+import { errorHandler } from '~/utils/errorHandler'
+
+class CartError extends Error {
+  code: string
+  constructor(message: string, code: string) {
+    super(message)
+    this.code = code
+    this.name = 'CartError'
+  }
+}
 
 interface MagentoProduct {
   sku: string

package/app/{composables/stores → stores}/products.ts

@@ -1,5 +1,9 @@
 // stores/products.ts - Pinia store for product management
 import type { Product } from '~/app/types'
+import { defineStore } from 'pinia'
+import { ref, computed, readonly } from 'vue'
+import { useProducts } from '~/app/composables/products'
+import { useFeaturedProducts } from '~/app/composables/featured-products'
 
 export const useProductsStore = defineStore('products', () => {
   const products = ref<Product[]>([])

package/app/types/checkout.d.ts

@@ -0,0 +1,6 @@
+export interface CheckoutState {
+  shippingAddress: string | null
+  paymentMethod: string | null
+  orderId: string
+  isLoading: boolean
+}

package/app/types/checkout.ts

@@ -0,0 +1,6 @@
+export interface CheckoutState {
+  shippingAddress: string | null
+  paymentMethod: string | null
+  orderId: string
+  isLoading: boolean
+}

package/app/types/imports.d.ts

@@ -0,0 +1,28 @@
+declare module '#imports' {
+  export function useRuntimeConfig(): any
+  export function useNuxtApp(): any
+  export function useAppConfig(): any
+  export function useOrders(): any
+  export function useReturns(): any
+  export function useTransactions(): any
+  export function useInvoices(): any
+  export function useCreditMemos(): any
+}
+
+declare module 'nuxt/app' {
+  export function useAppConfig(): any
+  export function useAsyncData<T = any>(keyOrHandler: string | null | (() => Promise<T> | T), handler?: (...args: any[]) => Promise<T> | T): Promise<{ data: { value: T }, error: { value: any } }>
+  export function useState<T = any>(key: string, init?: T | (() => T)): { value: T }
+}
+
+// Provide globals for files that call Nuxt auto-imports without module import
+declare function useNuxtApp(): any
+declare function useRuntimeConfig(): any
+declare function useAppConfig(): any
+
+// Order-related auto-imports used without explicit imports in stores
+declare function useOrders(): any
+declare function useReturns(): any
+declare function useTransactions(): any
+declare function useInvoices(): any
+declare function useCreditMemos(): any

package/app/{composables/types → types}/index.ts

@@ -1,3 +1,8 @@
+export * from '~/types/checkout'
+export * from '~/types/product'
+export * from '~/types/review'
+export * from '~/types/storeInPickUp'
+export * from '~/types/wishlist'
 // types/index.ts - Main type definitions for commerce layer
 
 // Re-export Order types
@@ -33,6 +38,7 @@ export interface Product {
   price?: number;
   regularPrice?: number;
   salePrice?: number;
+  sale_price?: number;
   attributes?: Array<{ name: string; value: string }>;
   variations?: ProductVariant[];
 }

package/app/types/nuxt-imports.d.ts

@@ -0,0 +1,5 @@
+declare module '#imports' {
+  import { Ref } from 'vue'
+  export function useNuxtApp(): any
+  export function useAsyncData<T = any>(key?: string | symbol, handler?: () => Promise<T> | T): { data: Ref<T | undefined> }
+}

package/app/types/product-state.ts

@@ -0,0 +1,8 @@
+import type { SimpleProduct } from './product'
+
+export interface ProductState {
+  products: SimpleProduct[]
+  selectedProduct: SimpleProduct | null
+  isLoading: boolean
+  error?: string | null
+}

package/app/types/product.d.ts

@@ -0,0 +1,5 @@
+export interface Price { amount: number; currency: string }
+
+export interface ProductVariant { id: string; sku: string; price: Price; attributes?: Record<string, any> }
+
+export interface Product { id: string; sku: string; name: string; variants?: ProductVariant[]; price?: Price }

package/app/types/product.ts

@@ -0,0 +1,22 @@
+export interface Price {
+  value: number
+  currency: string
+}
+
+export interface ProductVariant {
+  id: string
+  sku?: string
+  price?: Price
+  attributes?: Record<string, any>
+}
+
+export interface SimpleProduct {
+  id: string
+  title?: string
+  description?: string
+  images?: string[]
+  price?: Price
+  variants?: ProductVariant[]
+}
+export * from './index'
+export type { ProductState } from './product-state'

package/app/types/review-state.ts

@@ -0,0 +1,7 @@
+import type { Review } from './review'
+
+export interface ReviewState {
+  reviews: Review[]
+  isLoading: boolean
+  error?: string | null
+}

package/app/types/review.d.ts

@@ -0,0 +1 @@
+export interface Review { id: string; productId: string; rating: number; comment?: string; author?: string }

package/app/types/review.ts

@@ -0,0 +1,2 @@
+export interface Review { id: string; productId: string; rating: number; comment?: string; author?: string }
+export type { ReviewState } from './review-state'

package/app/types/storeInPickUp.d.ts

@@ -0,0 +1 @@
+export interface StoreInPickUp { id: string; name: string; address: string; phone?: string }

package/app/types/storeInPickUp.ts

@@ -0,0 +1,2 @@
+export interface StoreInPickUp { id: string; name: string; address: string; phone?: string }
+export type { StorePickupState } from './storePickup-state'

package/app/types/storePickup-state.ts

@@ -0,0 +1,5 @@
+export interface StorePickupState {
+  selectedStoreId: string | null
+  stores: any[]
+  error?: string | null
+}

package/app/types/vue-globals.d.ts

@@ -0,0 +1,9 @@
+// Minimal ambient declarations for Vue/Pinia globals used in the commerce layer
+declare function ref<T = any>(value?: T): any
+declare function computed<T = any>(fn: () => T): any
+declare function readonly<T = any>(v: T): T
+declare function reactive<T = any>(v: T): T
+declare function watchEffect(fn: () => void): void
+
+// Pinia-ish defineStore (layers may call defineStore during build time)
+declare function defineStore(id: string, setup: any): any

package/app/types/wishlist-state.ts

@@ -0,0 +1,5 @@
+export interface WishlistState {
+  items: any[]
+  isLoading: boolean
+  error?: string | null
+}

package/app/types/wishlist.d.ts

@@ -0,0 +1 @@
+export interface WishlistItem { id: string; productSku: string; addedAt: string }

package/app/types/wishlist.ts

@@ -0,0 +1,2 @@
+export interface WishlistItem { id: string; productSku: string; addedAt: string }
+export type { WishlistState } from './wishlist-state'

package/app/utils/errorHandler.ts

@@ -0,0 +1,16 @@
+export const errorHandler = {
+  handle(err: unknown) {
+    // Structured handling: log and optionally rethrow
+    try {
+      if (err instanceof Error) {
+        console.error(`[Commerce][Error] ${err.name}: ${err.message}`)
+      } else {
+        console.error('[Commerce][Error]', err)
+      }
+    } catch (e) {
+      console.error('Error while handling error', e)
+    }
+  }
+}
+
+export default errorHandler

package/graphql/queries-mutations_subscriptions/types/ProductCompare.type.ts

@@ -0,0 +1,20 @@
+export interface ComparableAttribute { key: string; value: string }
+
+export interface ComparableItem { id: string; sku?: string; name?: string }
+
+export interface ComparableProduct {
+  id: string
+  sku?: string
+  name?: string
+  attributes?: ComparableAttribute[]
+}
+
+export interface CompareList {
+  attributes?: ComparableAttribute[]
+  products?: ComparableProduct[]
+  items?: ComparableItem[]
+}
+
+export type ProductCompare = ComparableProduct
+
+export default ProductCompare

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meeovi/layer-commerce",
-  "version": "1.0.13",
+  "version": "1.1.0",
   "description": "Commerce Layer for the Alternate Framework",
   "keywords": [
     "commerce",
@@ -24,14 +24,13 @@
   "dependencies": {
     "@better-auth/stripe": "^1.4.15",
     "@meeovi/adapter-magento": "^1.0.2",
-    "@meeovi/api": "^1.0.1",
-    "@meeovi/core": "^1.0.1",
     "@meeovi/layer-social": "^1.0.4",
     "@meeovi/sdk": "^1.0.2",
-    "@meeovi/types": "file:../shared/types",
+    "@meeovi/core": "^1.0.4",
     "@polar-sh/better-auth": "^1.6.4",
     "@polar-sh/sdk": "^0.42.2",
-    "@storefront-ui/nuxt": "^3.1.1"
+    "@storefront-ui/nuxt": "^3.1.1",
+    "lodash-es": "^4.17.23"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.11",

package/tsconfig.json

@@ -1,5 +1,10 @@
 {
   "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "~/*": ["app/*", "./*"],
+      "@/*": ["app/*", "./*"]
+    },
     "declaration": true,
     "emitDeclarationOnly": false,
     "outDir": "dist",

package/app/composables/types/product.ts

@@ -1,14 +0,0 @@
-export interface Product {
-  id: string;
-  name: string;
-  price: number;
-  image?: string;
-  description?: string;
-  sku: string;
-}
-
-export interface ProductState {
-  products: Product[];
-  selectedProduct?: Product | null;
-  isLoading: boolean;
-}

package/app/composables/useContent/index.ts

@@ -1 +0,0 @@
-export * from './useContent';

package/app/composables/useContent/types.ts

@@ -1,44 +0,0 @@
-import type { Ref } from 'vue';
-import type { Maybe } from '../_types';
-import type { HeadingProps } from '~/components/Heading/types';
-import type { ProductSliderProps } from '~/components/ProductSlider/types';
-import type { CategoryCardProps } from '~/components/ui/CategoryCard/types';
-import type { DisplayProps } from '~/components/ui/Display/types';
-import type { HeroProps } from '~/components/ui/Hero/types';
-
-type EntryFields<TFields> = Array<{
-  fields: TFields;
-}>;
-
-type WithComponentField<TProps, TComponent> = TProps & {
-  component: TComponent;
-};
-
-export type DynamicContentFields =
-  | WithComponentField<HeroProps, 'Hero'>
-  | WithComponentField<CategoryCardProps, 'Card'>
-  | WithComponentField<HeadingProps, 'Heading'>
-  | WithComponentField<DisplayProps, 'Display'>
-  | WithComponentField<ProductSliderProps, 'ProductSlider'>;
-
-export interface ContentDynamicPage {
-  component: 'Page';
-  content: EntryFields<DynamicContentFields>;
-  name: string;
-  url: string;
-}
-
-export interface UseContentState {
-  data: Maybe<EntryFields<ContentDynamicPage>>;
-  loading: boolean;
-}
-
-export type GetContent = () => Promise<Ref<Maybe<EntryFields<ContentDynamicPage>>>>;
-
-export interface UseContent {
-  data: Readonly<Ref<UseContentState['data']>>;
-  loading: Readonly<Ref<boolean>>;
-  getContent: GetContent;
-}
-
-export type UseContentReturn = (url: string) => UseContent;

package/app/composables/useContent/useContent.ts

@@ -1,45 +0,0 @@
-import { toRefs } from '@vueuse/shared';
-import type { UseContentReturn, UseContentState, GetContent } from './types';
-import { getCommerceClient } from '../../utils/client';
-import { useAsyncData, useState } from 'nuxt/app';
-import { useHandleError } from '../useHandleError';
-
-/**
- * @description Composable for managing content from CMS.
- * @param url Parameter of the content to fetch.
- * @returns {@link UseContent}
- * @example
- * const { data, loading, getContent } = useContent<ContentFieldsType>('url');
- */
-export const useContent: UseContentReturn = (url) => {
-  const state = useState<UseContentState>(`content-${url}`, () => ({
-    data: null,
-    loading: false,
-  }));
-
-  /**
-   * @description Function for fetching the content.
-   * @example
-   * getContent();
-   */
-  const getContent: GetContent = async () => {
-    state.value.loading = true;
-    try {
-      const client = getCommerceClient();
-      const result = await useAsyncData(() => client.listProducts?.());
-      const { data, error } = result as unknown as { data: Awaited<ReturnType<GetContent>>; error: any };
-      useHandleError(error?.value ?? error);
-      state.value.data = data.value;
-      return data;
-    } catch (error) {
-      throw new Error(error as string);
-    } finally {
-      state.value.loading = false;
-    }
-  };
-
-  return {
-    getContent,
-    ...toRefs(state.value),
-  };
-};

package/app/types/shims-imports.d.ts

@@ -1,13 +0,0 @@
-declare module '#imports' {
-  export function useRuntimeConfig(): any;
-  export function useState<T = any>(key: string, init?: T): any;
-  export function useFetch(...args: any[]): any;
-  export function defineNuxtPlugin(fn: any): any;
-  export const navigateTo: any;
-  export const useRouter: any;
-  export const useNuxtApp: any;
-  export const useRequestEvent: any;
-  export const useCookie: any;
-  export const useHeaders: any;
-  export const useQuery: any;
-}

package/global.d.ts

@@ -1,149 +0,0 @@
-declare module '#imports' {
-  // Minimal shims for Nuxt auto-imports used in script-setup
-  export const useHead: any
-  export const useNuxtApp: any
-  export const useAsyncData: any
-  export const useState: any
-  export const useFetch: any
-}
-
-declare module '*.vue' {
-  import { DefineComponent } from 'vue'
-  const component: DefineComponent<{}, {}, any>
-  export default component
-}
-
-// Broad runtime shims to help isolated tsc runs in this monorepo
-declare module 'pinia' {
-  export function defineStore(id: any, setup?: any): any
-  export function createPinia(): any
-  const pinia: any
-  export default pinia
-}
-
-declare module 'lodash-es' {
-  const _default: any
-  export default _default
-  export const groupBy: any
-  export const uniqBy: any
-}
-
-declare module '~/*'
-declare module '@/*'
-
-declare const defineStore: any
-declare function ref<T = any>(v?: T): any
-declare function computed<T = any>(fn: any): any
-declare function readonly<T = any>(v: T): T
-declare const reactive: any
-declare const watch: any
-declare const onMounted: any
-declare const onBeforeMount: any
-declare const onUnmounted: any
-
-// Nuxt auto-imports (already partially declared under #imports)
-declare const useNuxtApp: any
-declare const useHead: any
-declare const useAsyncData: any
-declare const useState: any
-declare const useFetch: any
-
-// Test globals (vitest/jest)
-declare function describe(...args: any[]): any
-declare function it(...args: any[]): any
-declare function beforeEach(...args: any[]): any
-declare function afterEach(...args: any[]): any
-declare const expect: any
-declare const vi: any
-
-// Common composable globals used across the layer (fallbacks for isolated tsc)
-declare const useAuth: any
-declare const useLoading: any
-declare const useInventory: any
-declare const useCache: any
-declare const useNotification: any
-declare const useOrders: any
-declare const useReturns: any
-declare const useTransactions: any
-declare const useInvoices: any
-declare const useCreditMemos: any
-declare const useProducts: any
-declare const useFeaturedProducts: any
-declare const useTax: any
-
-// Common error / service placeholders
-declare const errorHandler: any
-declare const CartError: any
-type MagentoService = any
-
-// Domain types used in many composables
-type Price = any
-type ProductVariant = any
-type Order = any
-type Return = any
-type Transaction = any
-type Invoice = any
-type CreditMemo = any
-type OrderFilters = any
-type ComparableAttribute = any
-type ComparableProduct = any
-type ComparableItem = any
-type CompareList = any
-
-// Store / state aliases
-type CheckoutState = any
-type ProductState = any
-type ReviewState = any
-type StorePickupState = any
-type WishlistState = any
-
-// Provide permissive module declarations for local app type modules
-declare module '~/app/types' {
-  export type Product = any
-  export type Price = any
-  export type HeroProps = any
-  export type CategoryCardProps = any
-  export type HeadingProps = any
-  export type DisplayProps = any
-  export type ProductSliderProps = any
-  export type Cart = any
-  export type Maybe<T = any> = T | null | undefined
-}
-
-// Export order-related types used by stores
-declare module '~/app/types' {
-  export type Order = any
-  export type Return = any
-  export type Transaction = any
-  export type Invoice = any
-  export type CreditMemo = any
-  export type OrderFilters = any
-}
-
-// Component-level type shims
-declare module '~/components/Heading/types' {
-  export type HeadingProps = any
-}
-declare module '~/components/ProductSlider/types' {
-  export type ProductSliderProps = any
-}
-declare module '~/components/ui/CategoryCard/types' {
-  export type CategoryCardProps = any
-}
-declare module '~/components/ui/Display/types' {
-  export type DisplayProps = any
-}
-declare module '~/components/ui/Hero/types' {
-  export type HeroProps = any
-}
-
-// Local alias modules used by stores
-declare module '@/types/product' {
-  export type Product = any
-  export type ProductState = any
-}
-declare module '@/types/review' {
-  export type Review = any
-  export type ReviewState = any
-}
-

package/index.js

@@ -1,3 +0,0 @@
-// Runtime-safe package root for @meeovi/layer-commerce
-export const __isLayer = true;
-export default {};