storefront-layouts-staging 1.0.0-staging.0

package/dist/lib/services/analytics.service.js

@@ -0,0 +1,382 @@
+import { api } from '../api.js';
+function getCurrentApiBaseUrl() {
+    return api.defaults.baseURL || `${process.env.NEXT_PUBLIC_API_URL || 'http://localhost:4002'}/api`;
+}
+const FLUSH_INTERVAL_MS = parseInt(process.env.NEXT_PUBLIC_ANALYTICS_FLUSH_MS || '4000', 10);
+const MAX_BATCH_SIZE = parseInt(process.env.NEXT_PUBLIC_ANALYTICS_MAX_BATCH || '20', 10);
+const USE_BATCH = process.env.NEXT_PUBLIC_ANALYTICS_USE_BATCH !== 'false';
+const DEDUP_WINDOW_MS = 1000;
+const FAILED_BATCH_STORAGE_KEY = 'analytics_failed_batches';
+const MAX_FAILED_BATCHES = 5;
+const MAX_FAILED_EVENTS = 50;
+const COMMERCE_DEBOUNCE_MS = 400;
+/**
+ * Analytics service — buffers events and sends batched requests to reduce API load.
+ */
+class AnalyticsService {
+    constructor() {
+        this.sessionId = null;
+        this.pendingBuffer = [];
+        this.flushTimer = null;
+        this.isFlushing = false;
+        this.recentDedupKeys = new Map();
+        this.commerceDebounceTimers = new Map();
+        this.unloadListenersAttached = false;
+    }
+    getSessionId() {
+        if (typeof window === 'undefined') {
+            return `server-${Date.now()}`;
+        }
+        if (!this.sessionId) {
+            const stored = localStorage.getItem('analytics_session_id');
+            if (stored) {
+                this.sessionId = stored;
+            }
+            else {
+                this.sessionId = `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+                localStorage.setItem('analytics_session_id', this.sessionId);
+            }
+        }
+        return this.sessionId;
+    }
+    detectDeviceType() {
+        if (typeof window === 'undefined') {
+            return null;
+        }
+        const width = window.innerWidth;
+        const ua = navigator.userAgent.toLowerCase();
+        if (/tablet|ipad|playbook|silk/i.test(ua)) {
+            return 'tablet';
+        }
+        if (width < 768 ||
+            /mobile|iphone|ipod|android|blackberry|opera|mini|windows\s+phone|palm|iemobile/i.test(ua)) {
+            return 'mobile';
+        }
+        return 'desktop';
+    }
+    getUTMParams() {
+        if (typeof window === 'undefined') {
+            return {};
+        }
+        const params = new URLSearchParams(window.location.search);
+        return {
+            utmSource: params.get('utm_source') || undefined,
+            utmMedium: params.get('utm_medium') || undefined,
+            utmCampaign: params.get('utm_campaign') || undefined,
+            utmTerm: params.get('utm_term') || undefined,
+            utmContent: params.get('utm_content') || undefined,
+        };
+    }
+    getReferrer() {
+        if (typeof window === 'undefined') {
+            return null;
+        }
+        return document.referrer || null;
+    }
+    /**
+     * Skip auto page_view when a dedicated view event is emitted on the same route.
+     */
+    shouldSkipAutoPageView(pathname) {
+        const segments = pathname.split('/').filter(Boolean);
+        if (segments.length < 2)
+            return false;
+        const last = segments[segments.length - 1];
+        const prev = segments[segments.length - 2]?.toLowerCase();
+        const viewSegmentPrefixes = [
+            'product',
+            'products',
+            'category',
+            'categories',
+            'menu',
+            'item',
+            'service',
+            'services',
+            'book',
+            'booking',
+        ];
+        if (viewSegmentPrefixes.includes(prev) && last && last !== prev) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Track an event (buffered by default; use immediate for conversions).
+     */
+    async trackEvent(params) {
+        if (params.immediate || params.eventType === 'checkout_complete') {
+            await this.flushBuffer();
+            return this.sendEvents([params]);
+        }
+        if (!USE_BATCH) {
+            return this.sendEvents([params]);
+        }
+        this.enqueue(params);
+        return Promise.resolve();
+    }
+    /**
+     * Debounced tracking for high-frequency commerce actions.
+     */
+    trackCommerceEvent(params, debounceKey) {
+        if (params.immediate || params.eventType === 'checkout_complete') {
+            void this.trackEvent(params);
+            return;
+        }
+        const existing = this.commerceDebounceTimers.get(debounceKey);
+        if (existing) {
+            clearTimeout(existing.timer);
+            const mergedMetadata = {
+                ...existing.params.metadata,
+                ...params.metadata,
+                quantity: params.metadata?.quantity ??
+                    existing.params.metadata?.quantity,
+            };
+            params = { ...params, metadata: mergedMetadata };
+        }
+        const timer = setTimeout(() => {
+            this.commerceDebounceTimers.delete(debounceKey);
+            void this.trackEvent(params);
+        }, COMMERCE_DEBOUNCE_MS);
+        this.commerceDebounceTimers.set(debounceKey, { timer, params });
+    }
+    enqueue(params) {
+        this.attachUnloadListeners();
+        if (this.isDuplicate(params)) {
+            return;
+        }
+        this.coalesceBuffer(params);
+        this.pendingBuffer.push({ params, timestamp: Date.now() });
+        if (this.pendingBuffer.length >= MAX_BATCH_SIZE) {
+            void this.flushBuffer();
+            return;
+        }
+        this.scheduleFlush();
+    }
+    isDuplicate(params) {
+        const key = this.getDedupKey(params);
+        const now = Date.now();
+        const last = this.recentDedupKeys.get(key);
+        if (last && now - last < DEDUP_WINDOW_MS) {
+            return true;
+        }
+        this.recentDedupKeys.set(key, now);
+        if (this.recentDedupKeys.size > 100) {
+            for (const [k, ts] of this.recentDedupKeys) {
+                if (now - ts > DEDUP_WINDOW_MS) {
+                    this.recentDedupKeys.delete(k);
+                }
+            }
+        }
+        return false;
+    }
+    getDedupKey(params) {
+        const meta = params.metadata || {};
+        return [
+            params.eventType,
+            params.storeId,
+            meta.path,
+            meta.productId,
+            meta.categoryId,
+        ]
+            .filter(Boolean)
+            .join(':');
+    }
+    coalesceBuffer(incoming) {
+        if (incoming.eventType === 'product_view' ||
+            incoming.eventType === 'category_view') {
+            this.pendingBuffer = this.pendingBuffer.filter((e) => e.params.eventType !== 'page_view');
+        }
+    }
+    scheduleFlush() {
+        if (this.flushTimer)
+            return;
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            void this.flushBuffer();
+        }, FLUSH_INTERVAL_MS);
+    }
+    async flushBuffer() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        if (this.isFlushing || this.pendingBuffer.length === 0) {
+            return;
+        }
+        this.isFlushing = true;
+        const batch = this.pendingBuffer.splice(0, MAX_BATCH_SIZE);
+        const paramsList = batch.map((b) => b.params);
+        try {
+            await this.sendEvents(paramsList);
+            await this.retryFailedBatches();
+        }
+        catch (error) {
+            console.warn('Analytics batch flush failed, re-queuing:', error);
+            this.pendingBuffer.unshift(...batch);
+            this.persistFailedBatch(paramsList);
+        }
+        finally {
+            this.isFlushing = false;
+            if (this.pendingBuffer.length > 0) {
+                this.scheduleFlush();
+            }
+        }
+    }
+    async sendEvents(paramsList) {
+        if (paramsList.length === 0)
+            return;
+        const sessionId = this.getSessionId();
+        const utmParams = this.getUTMParams();
+        const storeId = paramsList[0].storeId;
+        const userId = paramsList[0].userId ?? null;
+        const events = paramsList.map((params) => ({
+            eventType: params.eventType,
+            metadata: {
+                ...params.metadata,
+                ...utmParams,
+            },
+            clientTimestamp: new Date().toISOString(),
+        }));
+        const queryParams = new URLSearchParams();
+        if (utmParams.utmSource)
+            queryParams.set('utm_source', utmParams.utmSource);
+        if (utmParams.utmMedium)
+            queryParams.set('utm_medium', utmParams.utmMedium);
+        if (utmParams.utmCampaign)
+            queryParams.set('utm_campaign', utmParams.utmCampaign);
+        if (utmParams.utmTerm)
+            queryParams.set('utm_term', utmParams.utmTerm);
+        if (utmParams.utmContent)
+            queryParams.set('utm_content', utmParams.utmContent);
+        const query = queryParams.toString();
+        const batchPath = `/analytics/track-batch${query ? `?${query}` : ''}`;
+        const singlePath = `/analytics/track${query ? `?${query}` : ''}`;
+        if (USE_BATCH && paramsList.length > 1) {
+            await api.post(batchPath, { storeId, sessionId, userId, events });
+            return;
+        }
+        if (USE_BATCH && paramsList.length === 1) {
+            await api.post(batchPath, { storeId, sessionId, userId, events });
+            return;
+        }
+        for (const params of paramsList) {
+            const eventData = {
+                storeId: params.storeId,
+                eventType: params.eventType,
+                sessionId,
+                userId: params.userId || null,
+                metadata: {
+                    ...params.metadata,
+                    ...utmParams,
+                },
+            };
+            await api.post(singlePath, eventData);
+        }
+    }
+    attachUnloadListeners() {
+        if (typeof window === 'undefined' || this.unloadListenersAttached) {
+            return;
+        }
+        this.unloadListenersAttached = true;
+        const flushOnHide = () => {
+            if (document.visibilityState === 'hidden') {
+                void this.flushWithBeacon();
+            }
+        };
+        window.addEventListener('visibilitychange', flushOnHide);
+        window.addEventListener('pagehide', () => void this.flushWithBeacon());
+    }
+    async flushWithBeacon() {
+        if (this.pendingBuffer.length === 0)
+            return;
+        const batch = this.pendingBuffer.splice(0, MAX_BATCH_SIZE);
+        const paramsList = batch.map((b) => b.params);
+        const payload = this.buildBatchPayload(paramsList);
+        if (!payload)
+            return;
+        const utmParams = this.getUTMParams();
+        const queryParams = new URLSearchParams();
+        if (utmParams.utmSource)
+            queryParams.set('utm_source', utmParams.utmSource);
+        if (utmParams.utmMedium)
+            queryParams.set('utm_medium', utmParams.utmMedium);
+        if (utmParams.utmCampaign)
+            queryParams.set('utm_campaign', utmParams.utmCampaign);
+        const query = queryParams.toString();
+        const url = `${getCurrentApiBaseUrl()}/analytics/track-batch${query ? `?${query}` : ''}`;
+        try {
+            if (typeof navigator !== 'undefined' && navigator.sendBeacon) {
+                const sent = navigator.sendBeacon(url, new Blob([JSON.stringify(payload)], { type: 'application/json' }));
+                if (sent)
+                    return;
+            }
+            await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload),
+                keepalive: true,
+            });
+        }
+        catch {
+            this.pendingBuffer.unshift(...batch);
+            this.persistFailedBatch(paramsList);
+        }
+    }
+    buildBatchPayload(paramsList) {
+        if (paramsList.length === 0)
+            return null;
+        const utmParams = this.getUTMParams();
+        return {
+            storeId: paramsList[0].storeId,
+            sessionId: this.getSessionId(),
+            userId: paramsList[0].userId ?? null,
+            events: paramsList.map((params) => ({
+                eventType: params.eventType,
+                metadata: { ...params.metadata, ...utmParams },
+                clientTimestamp: new Date().toISOString(),
+            })),
+        };
+    }
+    persistFailedBatch(paramsList) {
+        if (typeof window === 'undefined')
+            return;
+        try {
+            const stored = JSON.parse(localStorage.getItem(FAILED_BATCH_STORAGE_KEY) || '[]');
+            stored.push(paramsList);
+            while (stored.length > MAX_FAILED_BATCHES) {
+                stored.shift();
+            }
+            const trimmed = stored.map((batch) => batch.slice(-MAX_FAILED_EVENTS));
+            localStorage.setItem(FAILED_BATCH_STORAGE_KEY, JSON.stringify(trimmed));
+        }
+        catch {
+            // ignore storage errors
+        }
+    }
+    async retryFailedBatches() {
+        if (typeof window === 'undefined')
+            return;
+        try {
+            const raw = localStorage.getItem(FAILED_BATCH_STORAGE_KEY);
+            if (!raw)
+                return;
+            const stored = JSON.parse(raw);
+            if (!stored.length)
+                return;
+            localStorage.removeItem(FAILED_BATCH_STORAGE_KEY);
+            for (const batch of stored) {
+                await this.sendEvents(batch);
+            }
+        }
+        catch (error) {
+            console.warn('Analytics failed-batch retry error:', error);
+        }
+    }
+    clearSession() {
+        if (typeof window !== 'undefined') {
+            void this.flushBuffer();
+            localStorage.removeItem('analytics_session_id');
+            this.sessionId = null;
+        }
+    }
+}
+export const analyticsService = new AnalyticsService();

package/dist/lib/services/auth.service.d.ts

@@ -0,0 +1,63 @@
+export interface User {
+    id: string;
+    email: string;
+    firstName: string;
+    lastName: string;
+    phone?: string;
+    avatar?: string;
+    role?: string;
+    userType?: string;
+}
+export interface LoginResponse {
+    token: string;
+    refreshToken: string;
+    user: User;
+}
+export interface RegisterDto {
+    email: string;
+    password: string;
+    firstName: string;
+    lastName: string;
+    phone?: string;
+    userType?: 'user' | 'merchant' | 'customer';
+    businessName?: string;
+    contactName?: string;
+}
+export declare const authService: {
+    /**
+     * Register a new user
+     */
+    register(data: RegisterDto): Promise<LoginResponse>;
+    /**
+     * Login user
+     */
+    login(email: string, password: string, userType?: "user" | "merchant" | "customer"): Promise<LoginResponse>;
+    /**
+     * Get current user
+     */
+    getCurrentUser(): Promise<User>;
+    /**
+     * Refresh access token
+     */
+    refreshToken(refreshToken: string): Promise<{
+        token: string;
+        refreshToken: string;
+    }>;
+    /**
+     * Request password reset
+     */
+    forgotPassword(email: string): Promise<void>;
+    /**
+     * Reset password with token (legacy) or OTP (new)
+     */
+    resetPassword(tokenOrEmail: string, password: string, otp?: string): Promise<void>;
+    /**
+     * Verify email with OTP
+     */
+    verifyEmail(email: string, otp: string): Promise<void>;
+    /**
+     * Resend OTP
+     */
+    resendOtp(email: string): Promise<void>;
+};
+//# sourceMappingURL=auth.service.d.ts.map

package/dist/lib/services/auth.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.service.d.ts","sourceRoot":"","sources":["../../../src/lib/services/auth.service.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,IAAI;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,IAAI,CAAC;CACZ;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,CAAC;IAC5C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,WAAW;IACtB;;OAEG;mBACkB,WAAW,GAAG,OAAO,CAAC,aAAa,CAAC;IAQzD;;OAEG;iBACgB,MAAM,YAAY,MAAM,aAAY,MAAM,GAAG,UAAU,GAAG,UAAU,GAAgB,OAAO,CAAC,aAAa,CAAC;IAY7H;;OAEG;sBACqB,OAAO,CAAC,IAAI,CAAC;IASrC;;OAEG;+BAC8B,MAAM,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;IAW1F;;OAEG;0BACyB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOlD;;OAEG;gCAC+B,MAAM,YAAY,MAAM,QAAQ,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBxF;;OAEG;uBACsB,MAAM,OAAO,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAO5D;;OAEG;qBACoB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAM9C,CAAC"}

package/dist/lib/services/auth.service.js

@@ -0,0 +1,101 @@
+import { api } from '../api.js';
+export const authService = {
+    /**
+     * Register a new user
+     */
+    async register(data) {
+        const response = await api.post('/auth/register', data);
+        if (response.data.status === 'success') {
+            return response.data.data;
+        }
+        throw new Error(response.data.message || 'Registration failed');
+    },
+    /**
+     * Login user
+     */
+    async login(email, password, userType = 'customer') {
+        const response = await api.post('/auth/login', {
+            email,
+            password,
+            userType,
+        });
+        if (response.data.status === 'success') {
+            return response.data.data;
+        }
+        throw new Error(response.data.message || 'Login failed');
+    },
+    /**
+     * Get current user
+     */
+    async getCurrentUser() {
+        const response = await api.get('/auth/me');
+        if (response.data.status === 'success') {
+            // Backend returns { user: {...} } structure
+            return response.data.data.user;
+        }
+        throw new Error(response.data.message || 'Failed to get current user');
+    },
+    /**
+     * Refresh access token
+     */
+    async refreshToken(refreshToken) {
+        const response = await api.post('/auth/refresh', { refreshToken });
+        if (response.data.status === 'success') {
+            return response.data.data;
+        }
+        throw new Error(response.data.message || 'Token refresh failed');
+    },
+    /**
+     * Request password reset
+     */
+    async forgotPassword(email) {
+        const response = await api.post('/auth/forgot-password', { email });
+        if (response.data.status !== 'success') {
+            throw new Error(response.data.message || 'Failed to send password reset email');
+        }
+    },
+    /**
+     * Reset password with token (legacy) or OTP (new)
+     */
+    async resetPassword(tokenOrEmail, password, otp) {
+        // If OTP is provided, use new OTP-based flow
+        if (otp) {
+            const response = await api.post('/auth/reset-password', {
+                email: tokenOrEmail,
+                otp,
+                password
+            });
+            if (response.data.status !== 'success') {
+                throw new Error(response.data.message || 'Failed to reset password');
+            }
+        }
+        else {
+            // Legacy token-based flow
+            const response = await api.post('/auth/reset-password', {
+                token: tokenOrEmail,
+                password
+            });
+            if (response.data.status !== 'success') {
+                throw new Error(response.data.message || 'Failed to reset password');
+            }
+        }
+    },
+    /**
+     * Verify email with OTP
+     */
+    async verifyEmail(email, otp) {
+        const response = await api.post('/auth/verify-email', { email, otp });
+        if (response.data.status !== 'success') {
+            throw new Error(response.data.message || 'Email verification failed');
+        }
+    },
+    /**
+     * Resend OTP
+     */
+    async resendOtp(email) {
+        const response = await api.post('/auth/resend-otp', { email });
+        if (response.data.status !== 'success') {
+            throw new Error(response.data.message || 'Failed to resend OTP');
+        }
+    },
+};

package/dist/lib/services/booking.service.d.ts

@@ -0,0 +1,53 @@
+export interface Booking {
+    id: string;
+    serviceId: string;
+    storeId: string;
+    bookingDate: string;
+    startTime: string;
+    endTime: string;
+    price: number;
+    status: string;
+    customerInfo?: any;
+    customerNotes?: string;
+}
+export interface CreateBookingDto {
+    serviceId: string;
+    storeId: string;
+    bookingDate: string;
+    startTime: string;
+    endTime: string;
+    price: number;
+    customerInfo: {
+        name: string;
+        email: string;
+        phone: string;
+    };
+    customerNotes?: string;
+    customerId?: string;
+}
+export declare const bookingService: {
+    /**
+     * Create a booking (guest or authenticated)
+     */
+    createBooking(data: CreateBookingDto): Promise<Booking>;
+    /**
+     * Get customer bookings (requires authentication)
+     */
+    getBookings(): Promise<Booking[]>;
+    /**
+     * Get booking by ID (requires authentication)
+     */
+    getBookingById(id: string): Promise<Booking>;
+    /**
+     * Update booking (requires authentication)
+     */
+    updateBooking(id: string, data: {
+        notes?: string;
+        customerNotes?: string;
+    }): Promise<Booking>;
+    /**
+     * Cancel booking (requires authentication)
+     */
+    cancelBooking(id: string): Promise<void>;
+};
+//# sourceMappingURL=booking.service.d.ts.map

package/dist/lib/services/booking.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"booking.service.d.ts","sourceRoot":"","sources":["../../../src/lib/services/booking.service.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,GAAG,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,cAAc;IACzB;;OAEG;wBACuB,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC;IAQ7D;;OAEG;mBACkB,OAAO,CAAC,OAAO,EAAE,CAAC;IAQvC;;OAEG;uBACsB,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAQlD;;OAEG;sBACqB,MAAM,QAAQ;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IAQnG;;OAEG;sBACqB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAM/C,CAAC"}

package/dist/lib/services/booking.service.js

@@ -0,0 +1,52 @@
+import { api } from '../api.js';
+export const bookingService = {
+    /**
+     * Create a booking (guest or authenticated)
+     */
+    async createBooking(data) {
+        const response = await api.post('/bookings', data);
+        if (response.data.status === 'success') {
+            return response.data.data;
+        }
+        throw new Error(response.data.message || 'Failed to create booking');
+    },
+    /**
+     * Get customer bookings (requires authentication)
+     */
+    async getBookings() {
+        const response = await api.get('/bookings');
+        if (response.data.status === 'success') {
+            return response.data.data;
+        }
+        throw new Error(response.data.message || 'Failed to fetch bookings');
+    },
+    /**
+     * Get booking by ID (requires authentication)
+     */
+    async getBookingById(id) {
+        const response = await api.get(`/bookings/${id}`);
+        if (response.data.status === 'success') {
+            return response.data.data;
+        }
+        throw new Error(response.data.message || 'Failed to fetch booking');
+    },
+    /**
+     * Update booking (requires authentication)
+     */
+    async updateBooking(id, data) {
+        const response = await api.put(`/bookings/${id}`, data);
+        if (response.data.status === 'success') {
+            return response.data.data;
+        }
+        throw new Error(response.data.message || 'Failed to update booking');
+    },
+    /**
+     * Cancel booking (requires authentication)
+     */
+    async cancelBooking(id) {
+        const response = await api.delete(`/bookings/${id}`);
+        if (response.data.status !== 'success') {
+            throw new Error(response.data.message || 'Failed to cancel booking');
+        }
+    },
+};

package/dist/lib/services/category.service.d.ts

@@ -0,0 +1,21 @@
+export interface Category {
+    id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    image?: string;
+    storeId: string;
+    parentId?: string;
+    isActive?: boolean;
+}
+export declare const categoryService: {
+    /**
+     * Get all categories for a store
+     */
+    getCategories(storeId: string): Promise<Category[]>;
+    /**
+     * Get category by slug
+     */
+    getCategoryBySlug(slug: string, storeId: string): Promise<Category>;
+};
+//# sourceMappingURL=category.service.d.ts.map

package/dist/lib/services/category.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"category.service.d.ts","sourceRoot":"","sources":["../../../src/lib/services/category.service.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,eAAO,MAAM,eAAe;IAC1B;;OAEG;2BAC0B,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;IAuBzD;;OAEG;4BAC2B,MAAM,WAAW,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;CAS1E,CAAC"}