@marvalt/wadapter 2.3.6 → 2.3.9

package/dist/index.js

@@ -1,8 +1,6 @@
 'use strict';
 
 var require$$0 = require('react');
-var fs = require('fs');
-var path = require('path');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 /**
@@ -268,18 +266,47 @@ function transformWordPressMediaItems(media) {
 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 matches the Mautic pattern for consistency
         this.proxyEndpoint = config.proxyEndpoint || '/api/gravity-forms-submit';
     }
     async makeRequest(endpoint, options = {}) {
-        // Always use proxy endpoint (convention-based, like Mautic)
-        const proxyEndpoint = endpoint.startsWith('/') ? endpoint : `/${endpoint}`;
-        const url = `${this.proxyEndpoint}?endpoint=${encodeURIComponent(proxyEndpoint)}`;
+        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,
@@ -2164,507 +2191,6 @@ function getFormById(id) {
     return (gravityFormsStaticData?.forms ?? []).find(f => String(f.id) === key);
 }
 
-let document$1;
-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$1 = 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$1.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$1.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$1);
-  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$1.length - offset;
-  if (0 === length) {
-    return;
-  }
-  output.push(Freeform(document$1.substr(offset, length)));
-}
-function addInnerBlock(block, tokenStart, tokenLength, lastOffset) {
-  const parent = stack[stack.length - 1];
-  parent.block.innerBlocks.push(block);
-  const html = document$1.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$1.substr(prevOffset, endOffset - prevOffset) : document$1.substr(prevOffset);
-  if (html) {
-    block.innerHTML += html;
-    block.innerContent.push(html);
-  }
-  if (null !== leadingHtmlStart) {
-    output.push(
-      Freeform(
-        document$1.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.
- */
-// 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();
-}
-
 /**
  * @license GPL-3.0-or-later
  *
@@ -2838,21 +2364,15 @@ function validateFormData(formData, rules) {
     return { isValid, errors };
 }
 
-exports.FormProtectionGenerator = FormProtectionGenerator;
 exports.GravityForm = GravityForm;
 exports.GravityFormsClient = GravityFormsClient;
-exports.GravityFormsGenerator = GravityFormsGenerator;
 exports.GravityFormsProvider = GravityFormsProvider;
 exports.WordPressClient = WordPressClient;
 exports.WordPressContent = WordPressContent;
-exports.WordPressGenerator = WordPressGenerator;
 exports.WordPressProvider = WordPressProvider;
 exports.createFormProtectionConfig = createFormProtectionConfig;
 exports.createGravityFormsConfig = createGravityFormsConfig;
 exports.createWordPressConfig = createWordPressConfig;
-exports.generateFormProtectionData = generateFormProtectionData;
-exports.generateGravityFormsData = generateGravityFormsData;
-exports.generateWordPressData = generateWordPressData;
 exports.getActiveForms = getActiveForms;
 exports.getFormById = getFormById;
 exports.getPublishedForms = getPublishedForms;