@marvalt/wadapter 2.3.6 → 2.3.9

package/dist/generators.cjs

@@ -0,0 +1,792 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+
+/**
+ * @license GPL-3.0-or-later
+ *
+ * This file is part of the MarVAlt Open SDK.
+ * Copyright (c) 2025 Vibune Pty Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ */
+class WordPressClient {
+    constructor(config) {
+        this.config = config;
+    }
+    async makeRequest(endpoint, params = {}, options = {}) {
+        const baseUrl = this.getBaseUrl();
+        const queryString = new URLSearchParams();
+        Object.entries(params).forEach(([key, value]) => {
+            if (value !== undefined && value !== null) {
+                if (Array.isArray(value)) {
+                    value.forEach(v => queryString.append(key, v.toString()));
+                }
+                else {
+                    queryString.append(key, value.toString());
+                }
+            }
+        });
+        // Construct URL based on auth mode
+        let url;
+        if (this.config.authMode === 'cloudflare_proxy') {
+            // For proxy modes, pass the full REST path including /wp-json as query parameter
+            const fullEndpoint = `/wp-json${endpoint}?${queryString.toString()}`;
+            url = `${baseUrl}?endpoint=${encodeURIComponent(fullEndpoint)}`;
+        }
+        else {
+            // For direct mode, construct the full WordPress API URL
+            url = `${baseUrl}/wp-json${endpoint}?${queryString.toString()}`;
+        }
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        // Add authentication based on mode
+        if (this.config.authMode === 'cloudflare_proxy') ;
+        else {
+            // Direct mode - use basic auth
+            if (this.config.username && this.config.password) {
+                const credentials = btoa(`${this.config.username}:${this.config.password}`);
+                headers.Authorization = `Basic ${credentials}`;
+            }
+        }
+        console.log('🔍 WordPress API Request Debug:', {
+            url,
+            method: options.method || 'GET',
+            authMode: this.config.authMode,
+            headers: Object.keys(headers),
+        });
+        const response = await fetch(url, {
+            method: options.method || 'GET',
+            headers,
+            body: options.body,
+            signal: AbortSignal.timeout(this.config.timeout || 30000),
+            ...options,
+        });
+        if (!response.ok) {
+            console.error('❌ WordPress API Error:', {
+                status: response.status,
+                statusText: response.statusText,
+                url,
+                headers: Object.fromEntries(response.headers.entries()),
+            });
+            throw new Error(`WordPress API request failed: ${response.status} ${response.statusText}`);
+        }
+        const responseText = await response.text();
+        console.log('🔍 WordPress API Response:', {
+            status: response.status,
+            responseLength: responseText.length,
+            responsePreview: responseText.substring(0, 200),
+        });
+        if (!responseText) {
+            // Return empty array for empty responses (common for endpoints with no data)
+            return [];
+        }
+        try {
+            return JSON.parse(responseText);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error('❌ JSON Parse Error:', {
+                error: message,
+                responseText: responseText.substring(0, 500),
+            });
+            throw new Error(`Failed to parse JSON response: ${message}`);
+        }
+    }
+    getBaseUrl() {
+        switch (this.config.authMode) {
+            case 'cloudflare_proxy':
+                return this.config.cloudflareWorkerUrl || '';
+            default:
+                return this.config.apiUrl || '';
+        }
+    }
+    async getPosts(params = {}) {
+        return this.makeRequest('/wp/v2/posts', params);
+    }
+    async getPost(id) {
+        return this.makeRequest(`/wp/v2/posts/${id}`);
+    }
+    async getPages(params = {}) {
+        return this.makeRequest('/wp/v2/pages', params);
+    }
+    async getPage(id) {
+        return this.makeRequest(`/wp/v2/pages/${id}`);
+    }
+    async getMedia(params = {}) {
+        return this.makeRequest('/wp/v2/media', params);
+    }
+    async getMediaItem(id) {
+        return this.makeRequest(`/wp/v2/media/${id}`);
+    }
+    async getCategories(params = {}) {
+        return this.makeRequest('/wp/v2/categories', params);
+    }
+    async getTags(params = {}) {
+        return this.makeRequest('/wp/v2/tags', params);
+    }
+    // Gravity Forms endpoints
+    async getGravityForms() {
+        return this.makeRequest('/gf-api/v1/forms');
+    }
+    async getGravityForm(formId) {
+        return this.makeRequest(`/gf-api/v1/forms/${formId}/config`);
+    }
+    async submitGravityForm(formId, entry) {
+        return this.makeRequest(`/gf-api/v1/forms/${formId}/submit`, {}, {
+            method: 'POST',
+            body: JSON.stringify(entry),
+        });
+    }
+    // Static data endpoints
+    async getStaticDataNonce() {
+        return this.makeRequest('/static-data/v1/nonce');
+    }
+    async getAllData(params = {}) {
+        const [posts, pages, media, categories, tags] = await Promise.all([
+            this.getPosts(params),
+            this.getPages(params),
+            this.getMedia(params),
+            this.getCategories(params),
+            this.getTags(params),
+        ]);
+        return { posts, pages, media, categories, tags };
+    }
+}
+
+let document;
+let offset;
+let output;
+let stack;
+const tokenizer = /<!--\s+(\/)?wp:([a-z][a-z0-9_-]*\/)?([a-z][a-z0-9_-]*)\s+({(?:(?=([^}]+|}+(?=})|(?!}\s+\/?-->)[^])*)\5|[^]*?)}\s+)?(\/)?-->/g;
+function Block(blockName, attrs, innerBlocks, innerHTML, innerContent) {
+  return {
+    blockName,
+    attrs,
+    innerBlocks,
+    innerHTML,
+    innerContent
+  };
+}
+function Freeform(innerHTML) {
+  return Block(null, {}, [], innerHTML, [innerHTML]);
+}
+function Frame(block, tokenStart, tokenLength, prevOffset, leadingHtmlStart) {
+  return {
+    block,
+    tokenStart,
+    tokenLength,
+    prevOffset: prevOffset || tokenStart + tokenLength,
+    leadingHtmlStart
+  };
+}
+const parse = (doc) => {
+  document = doc;
+  offset = 0;
+  output = [];
+  stack = [];
+  tokenizer.lastIndex = 0;
+  do {
+  } while (proceed());
+  return output;
+};
+function proceed() {
+  const stackDepth = stack.length;
+  const next = nextToken();
+  const [tokenType, blockName, attrs, startOffset, tokenLength] = next;
+  const leadingHtmlStart = startOffset > offset ? offset : null;
+  switch (tokenType) {
+    case "no-more-tokens":
+      if (0 === stackDepth) {
+        addFreeform();
+        return false;
+      }
+      if (1 === stackDepth) {
+        addBlockFromStack();
+        return false;
+      }
+      while (0 < stack.length) {
+        addBlockFromStack();
+      }
+      return false;
+    case "void-block":
+      if (0 === stackDepth) {
+        if (null !== leadingHtmlStart) {
+          output.push(
+            Freeform(
+              document.substr(
+                leadingHtmlStart,
+                startOffset - leadingHtmlStart
+              )
+            )
+          );
+        }
+        output.push(Block(blockName, attrs, [], "", []));
+        offset = startOffset + tokenLength;
+        return true;
+      }
+      addInnerBlock(
+        Block(blockName, attrs, [], "", []),
+        startOffset,
+        tokenLength
+      );
+      offset = startOffset + tokenLength;
+      return true;
+    case "block-opener":
+      stack.push(
+        Frame(
+          Block(blockName, attrs, [], "", []),
+          startOffset,
+          tokenLength,
+          startOffset + tokenLength,
+          leadingHtmlStart
+        )
+      );
+      offset = startOffset + tokenLength;
+      return true;
+    case "block-closer":
+      if (0 === stackDepth) {
+        addFreeform();
+        return false;
+      }
+      if (1 === stackDepth) {
+        addBlockFromStack(startOffset);
+        offset = startOffset + tokenLength;
+        return true;
+      }
+      const stackTop = stack.pop();
+      const html = document.substr(
+        stackTop.prevOffset,
+        startOffset - stackTop.prevOffset
+      );
+      stackTop.block.innerHTML += html;
+      stackTop.block.innerContent.push(html);
+      stackTop.prevOffset = startOffset + tokenLength;
+      addInnerBlock(
+        stackTop.block,
+        stackTop.tokenStart,
+        stackTop.tokenLength,
+        startOffset + tokenLength
+      );
+      offset = startOffset + tokenLength;
+      return true;
+    default:
+      addFreeform();
+      return false;
+  }
+}
+function parseJSON(input) {
+  try {
+    return JSON.parse(input);
+  } catch (e) {
+    return null;
+  }
+}
+function nextToken() {
+  const matches = tokenizer.exec(document);
+  if (null === matches) {
+    return ["no-more-tokens", "", null, 0, 0];
+  }
+  const startedAt = matches.index;
+  const [
+    match,
+    closerMatch,
+    namespaceMatch,
+    nameMatch,
+    attrsMatch,
+    ,
+    voidMatch
+  ] = matches;
+  const length = match.length;
+  const isCloser = !!closerMatch;
+  const isVoid = !!voidMatch;
+  const namespace = namespaceMatch || "core/";
+  const name = namespace + nameMatch;
+  const hasAttrs = !!attrsMatch;
+  const attrs = hasAttrs ? parseJSON(attrsMatch) : {};
+  if (isVoid) {
+    return ["void-block", name, attrs, startedAt, length];
+  }
+  if (isCloser) {
+    return ["block-closer", name, null, startedAt, length];
+  }
+  return ["block-opener", name, attrs, startedAt, length];
+}
+function addFreeform(rawLength) {
+  const length = document.length - offset;
+  if (0 === length) {
+    return;
+  }
+  output.push(Freeform(document.substr(offset, length)));
+}
+function addInnerBlock(block, tokenStart, tokenLength, lastOffset) {
+  const parent = stack[stack.length - 1];
+  parent.block.innerBlocks.push(block);
+  const html = document.substr(
+    parent.prevOffset,
+    tokenStart - parent.prevOffset
+  );
+  if (html) {
+    parent.block.innerHTML += html;
+    parent.block.innerContent.push(html);
+  }
+  parent.block.innerContent.push(null);
+  parent.prevOffset = lastOffset ? lastOffset : tokenStart + tokenLength;
+}
+function addBlockFromStack(endOffset) {
+  const { block, leadingHtmlStart, prevOffset, tokenStart } = stack.pop();
+  const html = endOffset ? document.substr(prevOffset, endOffset - prevOffset) : document.substr(prevOffset);
+  if (html) {
+    block.innerHTML += html;
+    block.innerContent.push(html);
+  }
+  if (null !== leadingHtmlStart) {
+    output.push(
+      Freeform(
+        document.substr(
+          leadingHtmlStart,
+          tokenStart - leadingHtmlStart
+        )
+      )
+    );
+  }
+  output.push(block);
+}
+
+/**
+ * @license GPL-3.0-or-later
+ *
+ * This file is part of the MarVAlt Open SDK.
+ * Copyright (c) 2025 Vibune Pty Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ */
+// WordPress Static Data Generator
+class WordPressGenerator {
+    constructor(config) {
+        this.config = config;
+    }
+    async generateStaticData() {
+        const client = new WordPressClient(this.config);
+        console.log('🚀 Starting WordPress static data generation...');
+        const frontendId = this.config.frontendId || 'default-frontend';
+        const frontendName = this.config.frontendName || 'Default Frontend';
+        const postTypes = this.config.postTypes || ['posts', 'pages', 'case_studies', 'projects', 'members', 'testimonial', 'faqs', 'products', 'services', 'events'];
+        // Use 'edit' context only when credentials are provided; otherwise fall back to 'view'
+        const hasBasicAuth = !!(this.config.username && this.config.password);
+        const data = await client.getAllData({
+            per_page: this.config.maxItems || 100,
+            _embed: this.config.includeEmbedded || false,
+            context: hasBasicAuth ? 'edit' : 'view',
+        });
+        // Create the static data structure matching the existing format
+        const staticData = {
+            generated_at: new Date().toISOString(),
+            frontend_id: frontendId,
+            frontend_name: frontendName,
+            config: {
+                frontend_id: frontendId,
+                frontend_name: frontendName,
+                post_types: postTypes.reduce((acc, postType) => {
+                    acc[postType] = {
+                        max_items: this.config.maxItems || 100,
+                        include_embedded: this.config.includeEmbedded || true,
+                        orderby: 'date',
+                        order: 'desc',
+                    };
+                    return acc;
+                }, {}),
+            },
+            // Map the data to the expected structure
+            posts: data.posts,
+            pages: (data.pages || []).map((p) => {
+                let blocks = [];
+                try {
+                    const raw = p?.content?.raw || '';
+                    blocks = raw ? parse(raw) : [];
+                }
+                catch (e) {
+                    console.warn('⚠️ Failed to parse Gutenberg blocks for page', p?.id, e);
+                }
+                return { ...p, blocks };
+            }),
+            media: data.media,
+            categories: data.categories,
+            tags: data.tags,
+        };
+        // Write to file
+        this.writeStaticData(staticData);
+        console.log('✅ WordPress static data generation completed');
+        console.log(`📊 Generated data: ${data.posts.length} posts, ${data.pages.length} pages, ${data.media.length} media items`);
+        return staticData;
+    }
+    writeStaticData(data) {
+        try {
+            const outputPath = path.join(process.cwd(), this.config.outputPath);
+            fs.writeFileSync(outputPath, JSON.stringify(data, null, 2));
+            console.log(`📁 Static data written to: ${outputPath}`);
+        }
+        catch (error) {
+            console.error('❌ Error writing static data:', error);
+            throw error;
+        }
+    }
+    async generatePostsOnly() {
+        const client = new WordPressClient(this.config);
+        return client.getPosts({ per_page: 100 });
+    }
+    async generatePagesOnly() {
+        const client = new WordPressClient(this.config);
+        return client.getPages({ per_page: 100 });
+    }
+    async generateMediaOnly() {
+        const client = new WordPressClient(this.config);
+        return client.getMedia({ per_page: 100 });
+    }
+}
+// Convenience function for easy usage
+async function generateWordPressData(config) {
+    const generator = new WordPressGenerator(config);
+    return generator.generateStaticData();
+}
+
+/**
+ * @license GPL-3.0-or-later
+ *
+ * This file is part of the MarVAlt Open SDK.
+ * Copyright (c) 2025 Vibune Pty Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ */
+class GravityFormsClient {
+    constructor(config) {
+        this.config = config;
+        // Determine mode: direct for generators (Node.js), proxy for browser
+        const hasCredentials = !!(config.username && config.password && config.username.length > 0 && config.password.length > 0);
+        this.useDirectMode = config.authMode === 'direct' && hasCredentials;
+        // Debug logging for Node.js environments (generators)
+        if (typeof process !== 'undefined' && process.env) {
+            console.log('🔍 GravityFormsClient Configuration:', {
+                authMode: config.authMode,
+                hasUsername: !!config.username,
+                hasPassword: !!config.password,
+                hasApiUrl: !!config.apiUrl,
+                useDirectMode: this.useDirectMode,
+            });
+        }
+        // Convention-based: Always use /api/gravity-forms-submit unless explicitly overridden
+        this.proxyEndpoint = config.proxyEndpoint || '/api/gravity-forms-submit';
+    }
+    async makeRequest(endpoint, options = {}) {
+        let url;
+        const headers = {
+            'Content-Type': 'application/json',
+            ...options.headers,
+        };
+        if (this.useDirectMode) {
+            // Direct mode: Call WordPress API directly (for generators/Node.js)
+            url = `${this.config.apiUrl}${endpoint}`;
+            // Add Basic Auth
+            if (this.config.username && this.config.password) {
+                const credentials = btoa(`${this.config.username}:${this.config.password}`);
+                headers['Authorization'] = `Basic ${credentials}`;
+            }
+            // Add CF Access headers if provided
+            if (this.config.cfAccessClientId && this.config.cfAccessClientSecret) {
+                headers['CF-Access-Client-Id'] = this.config.cfAccessClientId;
+                headers['CF-Access-Client-Secret'] = this.config.cfAccessClientSecret;
+            }
+        }
+        else {
+            // Proxy mode: Use Pages Function (for browser)
+            const proxyEndpoint = endpoint.startsWith('/') ? endpoint : `/${endpoint}`;
+            url = `${this.proxyEndpoint}?endpoint=${encodeURIComponent(proxyEndpoint)}`;
+        }
+        const response = await fetch(url, {
+            ...options,
+            headers,
+            signal: AbortSignal.timeout(this.config.timeout || 30000),
+        });
+        if (!response.ok) {
+            throw new Error(`Gravity Forms API request failed: ${response.status} ${response.statusText}`);
+        }
+        const responseText = await response.text();
+        if (!responseText) {
+            return [];
+        }
+        try {
+            return JSON.parse(responseText);
+        }
+        catch (error) {
+            console.error('❌ Gravity Forms JSON Parse Error:', {
+                error: error.message,
+                responseText: responseText.substring(0, 500),
+            });
+            throw new Error(`Failed to parse JSON response: ${error.message}`);
+        }
+    }
+    async getForm(id) {
+        // Always use custom gf-api/v1 endpoint (from custom plugin)
+        const endpoint = `/forms/${id}`;
+        return this.makeRequest(endpoint);
+    }
+    async getForms() {
+        // Always use custom gf-api/v1 endpoint (from custom plugin)
+        const endpoint = '/forms';
+        return this.makeRequest(endpoint);
+    }
+    async getFormConfig(id) {
+        // Always use custom gf-api/v1 endpoint (from custom plugin)
+        const endpoint = `/forms/${id}/config`;
+        return this.makeRequest(endpoint);
+    }
+    async submitForm(formId, submission) {
+        // Always use custom gf-api/v1 submit endpoint (from custom plugin)
+        const endpoint = `/forms/${formId}/submit`;
+        // Merge custom headers (e.g., Turnstile token) with default headers
+        const headers = {
+            'Content-Type': 'application/json',
+            ...(submission.headers || {}),
+        };
+        return this.makeRequest(endpoint, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(submission.field_values),
+        });
+    }
+    async getHealth() {
+        const endpoint = '/health';
+        return this.makeRequest(endpoint);
+    }
+}
+
+/**
+ * @license GPL-3.0-or-later
+ *
+ * This file is part of the MarVAlt Open SDK.
+ * Copyright (c) 2025 Vibune Pty Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ */
+// Gravity Forms Static Data Generator
+class GravityFormsGenerator {
+    constructor(config) {
+        this.config = config;
+    }
+    async generateStaticData() {
+        const client = new GravityFormsClient(this.config);
+        console.log('🚀 Starting Gravity Forms static data generation...');
+        let forms = [];
+        if (this.config.formIds && this.config.formIds.length > 0) {
+            // Generate specific forms
+            for (const formId of this.config.formIds) {
+                try {
+                    const form = await client.getFormConfig(formId);
+                    if (this.config.includeInactive || form.is_active) {
+                        forms.push(form);
+                    }
+                }
+                catch (error) {
+                    console.warn(`⚠️ Could not fetch form ${formId}:`, error);
+                }
+            }
+        }
+        else {
+            // Generate all forms
+            const formsList = await client.getForms();
+            console.log('🔍 Gravity Forms Response:', {
+                formsType: typeof formsList,
+                isArray: Array.isArray(formsList),
+                formsLength: formsList?.length,
+                formsPreview: formsList ? JSON.stringify(formsList).substring(0, 200) : 'null',
+            });
+            let formsMetadata = [];
+            if (Array.isArray(formsList)) {
+                formsMetadata = formsList;
+            }
+            else if (formsList && typeof formsList === 'object' && Array.isArray(formsList.forms)) {
+                formsMetadata = formsList.forms;
+            }
+            else if (formsList) {
+                formsMetadata = [formsList];
+            }
+            if (!this.config.includeInactive) {
+                formsMetadata = formsMetadata.filter(form => form.is_active === '1' || form.is_active === true);
+            }
+            // Fetch full form configuration for each form (schema lives under /config)
+            console.log(`🔄 Fetching full data for ${formsMetadata.length} forms...`);
+            forms = [];
+            for (const formMetadata of formsMetadata) {
+                try {
+                    const formId = Number(formMetadata.id);
+                    const fullForm = await client.getFormConfig(formId);
+                    forms.push(fullForm);
+                    console.log(`✅ Fetched form: ${fullForm.title} (${fullForm.fields?.length || 0} fields)`);
+                }
+                catch (error) {
+                    console.error(`❌ Failed to fetch form ${formMetadata.id} config:`, error);
+                    throw error;
+                }
+            }
+        }
+        const staticData = {
+            generated_at: new Date().toISOString(),
+            total_forms: forms.length,
+            forms,
+        };
+        // Write to file
+        this.writeStaticData(staticData);
+        console.log('✅ Gravity Forms static data generation completed');
+        console.log(`📊 Generated data: ${forms.length} forms`);
+        return staticData;
+    }
+    writeStaticData(data) {
+        try {
+            const outputPath = path.join(process.cwd(), this.config.outputPath);
+            fs.writeFileSync(outputPath, JSON.stringify(data, null, 2));
+            console.log(`📁 Static data written to: ${outputPath}`);
+        }
+        catch (error) {
+            console.error('❌ Error writing static data:', error);
+            throw error;
+        }
+    }
+    async generateFormConfig(formId) {
+        const client = new GravityFormsClient(this.config);
+        return client.getFormConfig(formId);
+    }
+}
+// Convenience function for easy usage
+async function generateGravityFormsData(config) {
+    const generator = new GravityFormsGenerator(config);
+    return generator.generateStaticData();
+}
+
+/**
+ * @license GPL-3.0-or-later
+ *
+ * This file is part of the MarVAlt Open SDK.
+ * Copyright (c) 2025 Vibune Pty Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ */
+class FormProtectionGenerator {
+    constructor(config) {
+        this.config = config;
+    }
+    async generateStaticData() {
+        console.log('🚀 Starting Form Protection static data generation...');
+        const forms = this.config.forms.map(form => ({
+            id: form.id,
+            name: form.name,
+            protectionLevel: form.protectionLevel,
+            emailVerification: this.config.emailVerification,
+            spamProtection: this.config.spamProtection,
+            rateLimiting: this.config.rateLimiting,
+        }));
+        const staticData = {
+            config: {
+                enabled: this.config.enabled,
+                secret: this.config.secret,
+                emailVerification: this.config.emailVerification,
+                spamProtection: this.config.spamProtection,
+                rateLimiting: this.config.rateLimiting,
+                maxSubmissionsPerHour: this.config.maxSubmissionsPerHour,
+                maxSubmissionsPerDay: this.config.maxSubmissionsPerDay,
+            },
+            forms,
+            generatedAt: new Date().toISOString(),
+        };
+        // Write to file
+        this.writeStaticData(staticData);
+        console.log('✅ Form Protection static data generation completed');
+        console.log(`📊 Generated data: ${forms.length} protected forms`);
+        return staticData;
+    }
+    writeStaticData(data) {
+        try {
+            const outputPath = path.join(process.cwd(), this.config.outputPath);
+            fs.writeFileSync(outputPath, JSON.stringify(data, null, 2));
+            console.log(`📁 Static data written to: ${outputPath}`);
+        }
+        catch (error) {
+            console.error('❌ Error writing static data:', error);
+            throw error;
+        }
+    }
+    validateFormProtection(formData) {
+        // Basic validation logic for form protection
+        const errors = [];
+        if (this.config.emailVerification && !formData.email) {
+            errors.push('Email verification is required');
+        }
+        if (this.config.spamProtection) {
+            // Basic spam detection logic
+            if (formData.message && formData.message.length < 10) {
+                errors.push('Message too short');
+            }
+        }
+        return {
+            success: errors.length === 0,
+            protected: this.config.enabled,
+            message: errors.length > 0 ? errors.join(', ') : 'Form is protected',
+            verificationRequired: this.config.emailVerification,
+            spamDetected: errors.length > 0,
+        };
+    }
+}
+// Convenience function for easy usage
+async function generateFormProtectionData(config) {
+    const generator = new FormProtectionGenerator(config);
+    return generator.generateStaticData();
+}
+
+exports.FormProtectionGenerator = FormProtectionGenerator;
+exports.GravityFormsGenerator = GravityFormsGenerator;
+exports.WordPressGenerator = WordPressGenerator;
+exports.generateFormProtectionData = generateFormProtectionData;
+exports.generateGravityFormsData = generateGravityFormsData;
+exports.generateWordPressData = generateWordPressData;
+//# sourceMappingURL=generators.cjs.map