@flowuent-org/diagramming-core 1.0.8 → 1.1.0

package/dist/out-tsc/packages/diagrams/src/lib/services/GoogleSheetsService.js

@@ -0,0 +1,740 @@
+// Browser-compatible Google Sheets service
+// Note: This is a simplified version for browser environments
+// For production use, consider using a backend API to handle Google Sheets operations
+import { __awaiter } from "tslib";
+import * as XLSX from 'xlsx';
+import { saveAs } from 'file-saver';
+// Mock Google Sheets API for browser environment
+const mockGoogleSheetsAPI = {
+    spreadsheets: {
+        values: {
+            update: (params) => __awaiter(void 0, void 0, void 0, function* () {
+                var _a, _b;
+                // Simulate API call delay
+                yield new Promise((resolve) => setTimeout(resolve, 1000));
+                return {
+                    data: {
+                        updatedRows: params.requestBody.values.length,
+                        updatedColumns: ((_a = params.requestBody.values[0]) === null || _a === void 0 ? void 0 : _a.length) || 0,
+                        updatedCells: params.requestBody.values.length *
+                            (((_b = params.requestBody.values[0]) === null || _b === void 0 ? void 0 : _b.length) || 0),
+                    },
+                };
+            }),
+            get: (params) => __awaiter(void 0, void 0, void 0, function* () {
+                yield new Promise((resolve) => setTimeout(resolve, 500));
+                return {
+                    data: {
+                        values: [],
+                    },
+                };
+            }),
+            clear: (params) => __awaiter(void 0, void 0, void 0, function* () {
+                yield new Promise((resolve) => setTimeout(resolve, 500));
+                return {
+                    data: {
+                        clearedRange: params.range,
+                    },
+                };
+            }),
+        },
+    },
+};
+export class GoogleSheetsService {
+    constructor() {
+        this.sheets = null;
+        this.auth = null;
+        this.accessToken = null;
+        this.gisLoaded = false;
+        this.hasRequestedConsent = false;
+        this.requestedScopes = new Set();
+        // Detect if we're in a browser environment
+        this.isBrowserEnvironment = typeof window !== 'undefined';
+    }
+    /**
+     * Initialize Google Sheets API with authentication
+     * Note: In browser environment, this uses a mock API for demonstration
+     */
+    initialize(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                if (this.isBrowserEnvironment) {
+                    // If OAuth credentials are provided, initialize Google Identity Services
+                    if (((_a = config.credentials) === null || _a === void 0 ? void 0 : _a.type) === 'oauth' &&
+                        (config.credentials.clientEmail ||
+                            config.credentials.oauthToken ||
+                            config.credentials.clientId)) {
+                        // Prefer OAuth clientId flow (GIS)
+                        if (config.credentials.clientId) {
+                            yield this.ensureGisLoaded();
+                            yield this.requestAccessToken(config.credentials.clientId, config.credentials.scopes || [
+                                'https://www.googleapis.com/auth/spreadsheets',
+                            ]);
+                            this.sheets = 'rest';
+                            this.auth = {
+                                type: 'oauth',
+                                clientId: config.credentials.clientId,
+                                scopes: config.credentials.scopes || [
+                                    'https://www.googleapis.com/auth/spreadsheets',
+                                ],
+                            };
+                            return;
+                        }
+                        // Fallback: if oauthToken is provided directly (e.g., injected), use it
+                        if (config.credentials.oauthToken) {
+                            this.accessToken = config.credentials.oauthToken;
+                            this.sheets = 'rest';
+                            this.auth = {
+                                type: 'oauth',
+                                clientId: config.credentials.clientId,
+                                scopes: config.credentials.scopes || [
+                                    'https://www.googleapis.com/auth/spreadsheets',
+                                ],
+                            };
+                            return;
+                        }
+                    }
+                    // Browser environment without OAuth clientId – use mock API
+                    console.log('Browser environment detected - using mock Google Sheets API');
+                    this.sheets = mockGoogleSheetsAPI;
+                    this.auth = { type: ((_b = config.credentials) === null || _b === void 0 ? void 0 : _b.type) || 'mock' };
+                    return;
+                }
+                // Node.js environment - would use real Google APIs
+                // This would require server-side implementation
+                throw new Error('Real Google Sheets API integration requires server-side implementation');
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                throw new Error(`Failed to initialize Google Sheets API: ${errorMessage}`);
+            }
+        });
+    }
+    /**
+     * Ensure Google Identity Services script is loaded
+     */
+    ensureGisLoaded() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isBrowserEnvironment)
+                return;
+            if (this.gisLoaded)
+                return;
+            yield new Promise((resolve, reject) => {
+                const existing = document.querySelector('script[src="https://accounts.google.com/gsi/client"]');
+                if (existing) {
+                    this.gisLoaded = true;
+                    resolve();
+                    return;
+                }
+                const script = document.createElement('script');
+                script.src = 'https://accounts.google.com/gsi/client';
+                script.async = true;
+                script.defer = true;
+                script.onload = () => {
+                    this.gisLoaded = true;
+                    resolve();
+                };
+                script.onerror = () => reject(new Error('Failed to load GIS script'));
+                document.head.appendChild(script);
+            });
+        });
+    }
+    /**
+     * Request an OAuth access token using GIS token client
+     */
+    requestAccessToken(clientId_1, scopes_1) {
+        return __awaiter(this, arguments, void 0, function* (clientId, scopes, forceConsent = false) {
+            if (!this.isBrowserEnvironment) {
+                throw new Error('OAuth is only available in browser environment');
+            }
+            yield this.ensureGisLoaded();
+            const token = yield new Promise((resolve, reject) => {
+                try {
+                    // @ts-ignore - google global injected by GIS
+                    const tokenClient = google.accounts.oauth2.initTokenClient({
+                        client_id: clientId,
+                        scope: scopes.join(' '),
+                        callback: (response) => {
+                            // Handle both success and error shapes
+                            if (response && response.access_token) {
+                                this.hasRequestedConsent = true;
+                                // Track that we've requested these scopes
+                                scopes.forEach((s) => this.requestedScopes.add(s));
+                                resolve(response.access_token);
+                                return;
+                            }
+                            const err = (response === null || response === void 0 ? void 0 : response.error) || 'unknown_error';
+                            const desc = (response === null || response === void 0 ? void 0 : response.error_description) || 'No description';
+                            reject(new Error(`OAuth token error: ${err} - ${desc}`));
+                        },
+                    });
+                    // First-time call must show consent; subsequent calls can be silent
+                    tokenClient.requestAccessToken({
+                        prompt: forceConsent
+                            ? 'consent'
+                            : this.hasRequestedConsent
+                                ? ''
+                                : 'consent',
+                    });
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+            this.accessToken = token;
+            // Persist clientId and union of scopes in auth cache for later scope upgrades
+            if (this.auth && typeof this.auth === 'object') {
+                this.auth.clientId = clientId;
+                const union = Array.from(new Set([...(this.auth.scopes || []), ...scopes]));
+                this.auth.scopes = union;
+            }
+            return token;
+        });
+    }
+    /**
+     * Ensure the active token includes the given scopes. If not, request a new token with the union.
+     */
+    ensureScopes(requiredScopes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isBrowserEnvironment)
+                return;
+            if (!requiredScopes || requiredScopes.length === 0)
+                return;
+            // If we don't have OAuth client flow, nothing to do
+            const clientId = this.pendingClientId || undefined;
+            // We infer clientId from last initialize call by reading from DOM script params is not reliable.
+            // Instead, try to reuse the last known clientId from token creation by caching it in auth.
+            const authClientId = (this.auth && this.auth.clientId) || undefined;
+            const effectiveClientId = authClientId || clientId;
+            if (!effectiveClientId)
+                return;
+            const missing = requiredScopes.filter((s) => !this.requestedScopes.has(s));
+            if (missing.length === 0)
+                return;
+            const union = Array.from(new Set([...Array.from(this.requestedScopes), ...requiredScopes]));
+            yield this.requestAccessToken(effectiveClientId, union, true);
+            if (this.auth && typeof this.auth === 'object') {
+                this.auth.scopes = union;
+            }
+        });
+    }
+    /**
+     * Build a minimal RFC 2822 MIME message (plain text) and return base64url string.
+     */
+    buildMimeMessage(params) {
+        const headers = [];
+        if (params.from)
+            headers.push(`From: ${params.from}`);
+        headers.push(`To: ${params.to.join(', ')}`);
+        if (params.subject)
+            headers.push(`Subject: ${params.subject}`);
+        headers.push('MIME-Version: 1.0');
+        headers.push('Content-Type: text/plain; charset=UTF-8');
+        const lines = [...headers, '', params.body || ''];
+        const raw = lines.join('\r\n');
+        return this.encodeBase64Url(raw);
+    }
+    /**
+     * Encode string to base64url (RFC 4648 §5), as required by Gmail API.
+     */
+    encodeBase64Url(input) {
+        // btoa works with Latin1; for UTF-8 we need to encode first
+        const utf8 = unescape(encodeURIComponent(input));
+        const b64 = btoa(utf8);
+        return b64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+    }
+    /**
+     * Attempt to send an email via Gmail API using the current OAuth token.
+     */
+    sendViaGmailApi(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requiredScope = 'https://www.googleapis.com/auth/gmail.send';
+            yield this.ensureScopes([requiredScope]);
+            if (!this.accessToken) {
+                throw new Error('Not authenticated to Google APIs');
+            }
+            const bodyParts = [];
+            if (params.message)
+                bodyParts.push(params.message);
+            if (params.spreadsheetUrl)
+                bodyParts.push(`Spreadsheet: ${params.spreadsheetUrl}`);
+            const body = bodyParts.join('\n\n');
+            const raw = this.buildMimeMessage({
+                from: params.from,
+                to: params.to,
+                subject: params.subject || 'Automation Output',
+                body,
+            });
+            const res = yield fetch('https://gmail.googleapis.com/gmail/v1/users/me/messages/send', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.accessToken}`,
+                },
+                body: JSON.stringify({ raw }),
+            });
+            if (!res.ok) {
+                const text = yield res.text();
+                throw new Error(`Gmail send error ${res.status}: ${res.statusText} - ${text}`);
+            }
+            return true;
+        });
+    }
+    /**
+     * Helper: call Google Sheets REST API using fetch
+     */
+    apiFetch(path_1) {
+        return __awaiter(this, arguments, void 0, function* (path, options = {}) {
+            if (!this.accessToken) {
+                throw new Error('Not authenticated to Google APIs');
+            }
+            const base = 'https://sheets.googleapis.com/v4';
+            const url = new URL(base + path);
+            if (options.params) {
+                Object.entries(options.params).forEach(([k, v]) => url.searchParams.set(k, v));
+            }
+            const res = yield fetch(url.toString(), {
+                method: options.method || 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.accessToken}`,
+                },
+                body: options.body ? JSON.stringify(options.body) : undefined,
+            });
+            if (!res.ok) {
+                const text = yield res.text();
+                throw new Error(`Google API error ${res.status}: ${res.statusText} - ${text}`);
+            }
+            return res.json();
+        });
+    }
+    /**
+     * Send email via Gmail API if authorized; fallback to mailto for simple cases
+     */
+    sendEmail(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // If we have OAuth token, try Gmail API (request scope on-demand)
+            const hasOauth = ((_a = this.auth) === null || _a === void 0 ? void 0 : _a.type) === 'oauth' && this.accessToken;
+            if (hasOauth) {
+                try {
+                    const sent = yield this.sendViaGmailApi({
+                        from: params.from,
+                        to: params.to,
+                        subject: params.subject,
+                        message: params.message,
+                        spreadsheetUrl: params.spreadsheetUrl,
+                    });
+                    if (sent)
+                        return true;
+                }
+                catch (e) {
+                    // Fall through to UI-based flow if API send fails (e.g., insufficient permissions)
+                    console.warn('Gmail API send failed, falling back to UI:', e.message || e);
+                }
+            }
+            // Prefer: open Gmail compose in a new tab (more reliable than OS mailto handler)
+            if (this.isBrowserEnvironment && !params.disableUiFallback) {
+                const to = encodeURIComponent(params.to.join(','));
+                const subject = encodeURIComponent(params.subject || 'Automation Output');
+                const bodyParts = [];
+                if (params.message)
+                    bodyParts.push(params.message);
+                if (params.spreadsheetUrl)
+                    bodyParts.push(`Spreadsheet: ${params.spreadsheetUrl}`);
+                const body = encodeURIComponent(bodyParts.join('\n\n'));
+                // Try Gmail compose
+                const gmailUrl = `https://mail.google.com/mail/?view=cm&fs=1&to=${to}&su=${subject}&body=${body}`;
+                const win = window.open(gmailUrl, '_blank', 'noopener,noreferrer');
+                if (win) {
+                    return true;
+                }
+                // Fallback: OS handler via mailto
+                // Note: attachments are not supported via mailto; advise using Gmail scope for API send
+                const a = document.createElement('a');
+                a.href = `mailto:${to}?subject=${subject}&body=${body}`;
+                a.style.display = 'none';
+                document.body.appendChild(a);
+                a.click();
+                document.body.removeChild(a);
+                return true;
+            }
+            return false;
+        });
+    }
+    /**
+     * Export data to Google Sheets
+     * Note: In browser environment, this simulates the export process
+     */
+    exportToSheets(data_1, config_1, dataMapping_1) {
+        return __awaiter(this, arguments, void 0, function* (data, config, dataMapping, options = {}) {
+            var _a;
+            if (!this.sheets) {
+                throw new Error('Google Sheets API not initialized');
+            }
+            try {
+                // Prepare data for export
+                const mappedData = this.mapDataToColumns(data, dataMapping);
+                const includeHeaders = options.includeHeaders !== false;
+                // If using real OAuth flow, call REST API; otherwise, use mock behavior
+                const usingRest = ((_a = this.auth) === null || _a === void 0 ? void 0 : _a.type) === 'oauth' &&
+                    this.accessToken &&
+                    this.sheets === 'rest';
+                // Ensure spreadsheet exists when using REST
+                let spreadsheetId = config.spreadsheetId;
+                if (usingRest && !spreadsheetId) {
+                    const created = yield this.apiFetch('/spreadsheets', {
+                        method: 'POST',
+                        body: {
+                            properties: { title: options.fileName || 'Automation Export' },
+                            sheets: [
+                                {
+                                    properties: { title: config.sheetName || 'Sheet1' },
+                                },
+                            ],
+                        },
+                    });
+                    spreadsheetId = created.spreadsheetId;
+                    config.spreadsheetId = spreadsheetId;
+                }
+                // Ensure sheet exists
+                if (usingRest && spreadsheetId && config.sheetName) {
+                    const meta = yield this.apiFetch(`/spreadsheets/${spreadsheetId}`, {
+                        params: { fields: 'sheets.properties.title' },
+                    });
+                    const hasSheet = (meta.sheets || []).some((s) => s.properties && s.properties.title === config.sheetName);
+                    if (!hasSheet) {
+                        yield this.apiFetch(`/spreadsheets/${spreadsheetId}:batchUpdate`, {
+                            method: 'POST',
+                            body: {
+                                requests: [
+                                    {
+                                        addSheet: { properties: { title: config.sheetName } },
+                                    },
+                                ],
+                            },
+                        });
+                    }
+                }
+                // Clear sheet if requested
+                if (dataMapping.clearSheet) {
+                    yield this.clearSheet(config);
+                }
+                // Prepare range for writing (account for header row if included)
+                const totalRows = mappedData.length + (includeHeaders ? 1 : 0);
+                const range = this.prepareRange(config, dataMapping, totalRows);
+                // Prepare values array
+                const values = this.prepareValues(mappedData, dataMapping, includeHeaders);
+                if (usingRest) {
+                    yield this.apiFetch(`/spreadsheets/${config.spreadsheetId}/values/${encodeURIComponent(range)}`, {
+                        method: 'PUT',
+                        params: { valueInputOption: 'RAW' },
+                        body: { values },
+                    });
+                }
+                else {
+                    // Mock behavior
+                    yield this.sheets.spreadsheets.values.update({
+                        spreadsheetId: config.spreadsheetId,
+                        range: range,
+                        valueInputOption: 'RAW',
+                        requestBody: { values },
+                    });
+                }
+                // Get spreadsheet URL
+                const spreadsheetUrl = `https://docs.google.com/spreadsheets/d/${config.spreadsheetId}`;
+                // Send email if recipients provided
+                let emailSent = false;
+                if (options.emailRecipients && options.emailRecipients.length > 0) {
+                    emailSent = yield this.sendEmailNotification(options.emailRecipients, spreadsheetUrl, options.fileName || 'Google Sheets Export');
+                }
+                return {
+                    spreadsheetId: config.spreadsheetId,
+                    sheetName: config.sheetName,
+                    range: range,
+                    rowsAdded: mappedData.length,
+                    columnsMapped: dataMapping.headers.length,
+                    data: mappedData,
+                    exportTime: new Date().toISOString(),
+                    success: true,
+                    spreadsheetUrl,
+                    emailSent,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                throw new Error(`Failed to export to Google Sheets: ${errorMessage}`);
+            }
+        });
+    }
+    /**
+     * Export data to Excel file and download
+     */
+    exportToExcel(data_1, dataMapping_1) {
+        return __awaiter(this, arguments, void 0, function* (data, dataMapping, options = {}) {
+            try {
+                // Prepare data for export
+                const mappedData = this.mapDataToColumns(data, dataMapping);
+                // Create workbook
+                const wb = XLSX.utils.book_new();
+                // Prepare worksheet data
+                const wsData = this.prepareExcelData(mappedData, dataMapping, options.includeHeaders !== false);
+                // Create worksheet
+                const ws = XLSX.utils.aoa_to_sheet(wsData);
+                // Add worksheet to workbook
+                XLSX.utils.book_append_sheet(wb, ws, 'Sheet1');
+                // Generate file name
+                const fileName = options.fileName ||
+                    `export_${new Date().toISOString().split('T')[0]}.xlsx`;
+                // Save file
+                const excelBuffer = XLSX.write(wb, { bookType: 'xlsx', type: 'array' });
+                const blob = new Blob([excelBuffer], {
+                    type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+                });
+                saveAs(blob, fileName);
+                // Send email if recipients provided
+                let emailSent = false;
+                if (options.emailRecipients && options.emailRecipients.length > 0) {
+                    emailSent = yield this.sendEmailWithAttachment(options.emailRecipients, blob, fileName);
+                }
+                return {
+                    spreadsheetId: '',
+                    sheetName: 'Sheet1',
+                    range: '',
+                    rowsAdded: mappedData.length,
+                    columnsMapped: dataMapping.headers.length,
+                    data: mappedData,
+                    exportTime: new Date().toISOString(),
+                    success: true,
+                    downloadUrl: URL.createObjectURL(blob),
+                    emailSent,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                throw new Error(`Failed to export to Excel: ${errorMessage}`);
+            }
+        });
+    }
+    /**
+     * Map data according to column configuration
+     */
+    mapDataToColumns(data, dataMapping) {
+        return data.map((item) => {
+            const row = {};
+            dataMapping.headers.forEach((header) => {
+                const value = this.getNestedValue(item, header.sourceField);
+                row[header.column] = this.formatValueForSheets(value, header.dataType);
+            });
+            return row;
+        });
+    }
+    /**
+     * Get nested value from object using dot notation
+     */
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, key) => current === null || current === void 0 ? void 0 : current[key], obj);
+    }
+    /**
+     * Format value according to data type
+     */
+    formatValueForSheets(value, dataType) {
+        if (value === null || value === undefined) {
+            return '';
+        }
+        switch (dataType) {
+            case 'number':
+                return typeof value === 'number' ? value : parseFloat(value) || 0;
+            case 'date':
+                return value instanceof Date
+                    ? value.toISOString().split('T')[0]
+                    : value;
+            case 'boolean':
+                return Boolean(value);
+            case 'string':
+            default:
+                return String(value);
+        }
+    }
+    /**
+     * Prepare range for writing data
+     */
+    prepareRange(config, dataMapping, rowCount) {
+        var _a, _b;
+        const startColumn = ((_a = dataMapping.headers[0]) === null || _a === void 0 ? void 0 : _a.column) || 'A';
+        const endColumn = ((_b = dataMapping.headers[dataMapping.headers.length - 1]) === null || _b === void 0 ? void 0 : _b.column) || 'Z';
+        const startRow = dataMapping.clearSheet ? 1 : 1; // Simplified for browser
+        const endRow = startRow + rowCount - 1;
+        return `${config.sheetName}!${startColumn}${startRow}:${endColumn}${endRow}`;
+    }
+    /**
+     * Clear sheet content
+     */
+    clearSheet(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!this.sheets)
+                return;
+            try {
+                const usingRest = ((_a = this.auth) === null || _a === void 0 ? void 0 : _a.type) === 'oauth' &&
+                    this.accessToken &&
+                    this.sheets === 'rest';
+                const range = `${config.sheetName}!A:Z`;
+                if (usingRest) {
+                    yield this.apiFetch(`/spreadsheets/${config.spreadsheetId}/values/${encodeURIComponent(range)}:clear`, { method: 'POST' });
+                }
+                else {
+                    yield this.sheets.spreadsheets.values.clear({
+                        spreadsheetId: config.spreadsheetId,
+                        range,
+                    });
+                }
+            }
+            catch (error) {
+                console.warn('Failed to clear sheet:', error.message || error);
+            }
+        });
+    }
+    /**
+     * Prepare values array for Google Sheets API
+     */
+    prepareValues(mappedData, dataMapping, includeHeaders) {
+        const values = [];
+        // Add headers if requested
+        if (includeHeaders && dataMapping.headers.length > 0) {
+            const headers = dataMapping.headers.map((h) => h.column);
+            values.push(headers);
+        }
+        // Add data rows
+        mappedData.forEach((row) => {
+            const rowValues = dataMapping.headers.map((header) => row[header.column] || '');
+            values.push(rowValues);
+        });
+        return values;
+    }
+    /**
+     * Prepare data for Excel export
+     */
+    prepareExcelData(mappedData, dataMapping, includeHeaders) {
+        const data = [];
+        // Add headers if requested
+        if (includeHeaders && dataMapping.headers.length > 0) {
+            const headers = dataMapping.headers.map((h) => h.column);
+            data.push(headers);
+        }
+        // Add data rows
+        mappedData.forEach((row) => {
+            const rowValues = dataMapping.headers.map((header) => row[header.column] || '');
+            data.push(rowValues);
+        });
+        return data;
+    }
+    /**
+     * Send email notification with spreadsheet link
+     */
+    sendEmailNotification(recipients, spreadsheetUrl, fileName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // In browser environment, we'll simulate email sending
+                console.log(`📧 Email notification would be sent to: ${recipients.join(', ')}`);
+                console.log(`📊 Spreadsheet URL: ${spreadsheetUrl}`);
+                console.log(`📁 File: ${fileName}`);
+                // Show a browser notification or alert
+                if (this.isBrowserEnvironment && 'Notification' in window) {
+                    if (Notification.permission === 'granted') {
+                        new Notification('Google Sheets Export', {
+                            body: `Data exported successfully! Sent to ${recipients.length} recipient(s).`,
+                            icon: '/favicon.ico',
+                        });
+                    }
+                }
+                return true;
+            }
+            catch (error) {
+                console.error('Failed to send email notification:', error);
+                return false;
+            }
+        });
+    }
+    /**
+     * Send email with Excel attachment
+     */
+    sendEmailWithAttachment(recipients, fileBlob, fileName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // In browser environment, we'll simulate email sending
+                console.log(`📧 Email with attachment would be sent to: ${recipients.join(', ')}`);
+                console.log(`📎 Attachment: ${fileName}`);
+                console.log(`📊 File size: ${(fileBlob.size / 1024).toFixed(2)} KB`);
+                // Show a browser notification
+                if (this.isBrowserEnvironment && 'Notification' in window) {
+                    if (Notification.permission === 'granted') {
+                        new Notification('Excel Export', {
+                            body: `Excel file "${fileName}" exported successfully! Sent to ${recipients.length} recipient(s).`,
+                            icon: '/favicon.ico',
+                        });
+                    }
+                }
+                return true;
+            }
+            catch (error) {
+                console.error('Failed to send email with attachment:', error);
+                return false;
+            }
+        });
+    }
+    /**
+     * Validate configuration
+     */
+    validateConfig(config) {
+        var _a;
+        const errors = [];
+        if (!config.spreadsheetId) {
+            // Allow creating a new spreadsheet when using OAuth clientId
+            if (!(((_a = config.credentials) === null || _a === void 0 ? void 0 : _a.type) === 'oauth' && config.credentials.clientId)) {
+                errors.push('Spreadsheet ID is required (or provide OAuth clientId to create a new one)');
+            }
+        }
+        if (!config.sheetName) {
+            errors.push('Sheet name is required');
+        }
+        if (!config.credentials) {
+            errors.push('Credentials are required');
+        }
+        else {
+            if (config.credentials.type === 'service-account') {
+                if (!config.credentials.serviceAccountKey &&
+                    !config.credentials.clientEmail) {
+                    errors.push('Service account key or client email is required');
+                }
+                if (!config.credentials.serviceAccountKey &&
+                    !config.credentials.privateKey) {
+                    errors.push('Service account key or private key is required');
+                }
+            }
+            else if (config.credentials.type === 'api-key') {
+                if (!config.credentials.apiKey) {
+                    errors.push('API key is required');
+                }
+            }
+            else if (config.credentials.type === 'oauth') {
+                // Accept either a provided token or clientId for GIS
+                if (!config.credentials.oauthToken && !config.credentials.clientId) {
+                    errors.push('OAuth clientId or oauthToken is required');
+                }
+                if (config.credentials.clientId && !config.credentials.scopes) {
+                    // Provide default scope if not present
+                    config.credentials.scopes = [
+                        'https://www.googleapis.com/auth/spreadsheets',
+                    ];
+                }
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+}
+//# sourceMappingURL=GoogleSheetsService.js.map