.bg-matrix-dark {
  background: linear-gradient(0deg, rgba(13, 13, 15, 1) 0%, rgba(13, 13, 15, 0.95) 5%, rgba(13, 13, 15, 0.8) 15%, rgba(17, 17, 17, 0.1) 30%, rgba(17, 17, 17, 0.1) 70%, rgba(13, 13, 15, 0.8) 85%, rgba(13, 13, 15, 0.95) 95%, rgba(13, 13, 15, 1) 100%),
    linear-gradient(
      90deg,
      transparent 0%,
      rgba(17, 17, 17, 0.6) 40%,
      rgba(17, 17, 17, 0.6) 60%,
      transparent 100%
    ), url(https://pub-f048362b915448c9b012a2e03c189024.r2.dev/matrix-bg-dark.svg);
  background-size: cover;
  background-position: center center;
}

img[alt="US"] {
  display: none !important;
}

div.relative.w-4.h-4.rounded-full:has(img[alt="US"]) {
  display: none !important;
}

.bg-matrix-light {
  background: linear-gradient(
      0deg,
      #f0f0f0 0%,
      rgba(240, 240, 240, 0.6) 30%,
      rgba(240, 240, 240, 0.6) 70%,
      #f0f0f0 100%
    ),
    linear-gradient(
      90deg,
      transparent 0%,
      rgba(240, 240, 240, 0.6) 40%,
      rgba(240, 240, 240, 0.6) 60%,
      transparent 100%
    ), url(https://pub-f048362b915448c9b012a2e03c189024.r2.dev/matrix-bg-light.svg);
  background-size: cover;
  background-position: center center;
}

.bg-gradient-dark {
  background: linear-gradient(
      90deg,
      rgba(17, 17, 17, 0) 0%,
      rgba(17, 17, 17, 0.75) 50%,
      rgba(17, 17, 17, 0) 100%
    ),
    linear-gradient(180deg, #111 0%, rgba(17, 17, 17, 0) 40%, rgba(17, 17, 17, 0) 60%, #111 100%),
    linear-gradient(270deg, rgba(11, 106, 249, 0.25) 0%, rgba(29, 146, 255, 0.3) 100%);
}

.bg-gradient-light {
  background: linear-gradient(180deg, #f0f0f0 0%, rgba(255, 255, 255, 0) 49.83%, #f0f0f0 100%),
    linear-gradient(
      90deg,
      #d2e4ff 0%,
      rgba(210, 228, 255, 0.5) 25.3%,
      rgba(255, 255, 255, 0) 49.83%,
      rgba(210, 228, 255, 0.5) 75.47%,
      #d2e4ff 100%
    );
} 

#!/usr/bin/env node

const fs = require('fs');
const path = require('path');
const glob = require('glob');

// Constants for security schemas
const API_KEY_AUTH = {
  type: "apiKey",
  in: "header",
  description: "Project access key for authenticating requests",
  name: "X-Access-Key"
};

const BEARER_AUTH = {
  type: "http",
  scheme: "bearer",
  bearerFormat: "JWT",
  description: "JWT token for authenticating requests"
};

// API key for public endpoints
const PUBLIC_API_KEY = "AQAAAAAAAEGvyZiWA9FMslYeG_yayXaHnSI";

// Bearer token for secret endpoints

/**
 * Update the security schemas in a JSON file based on the tags of each individual path.
 * @param {string} filePath - Path to the JSON file
 * @returns {boolean} - True if the file was updated successfully, false otherwise
 */
function updateJsonFile(filePath) {
  try {
    // Read the JSON file
    const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
    
    // Check if the file has the components section
    if (!data.components) {
      data.components = {};
    }
    
    // Check if the file has the securitySchemes section
    if (!data.components.securitySchemes) {
      data.components.securitySchemes = {};
    }
    
    // Set up both security schemes
    data.components.securitySchemes = {
      "ApiKeyAuth": {
        ...API_KEY_AUTH,
        "description": `Public project access key for authenticating requests obtained on Sequence Builder. Example Test Key: ${PUBLIC_API_KEY}`
      },
      "BearerAuth": {
        ...BEARER_AUTH,
        "description": `Secret JWT token for authenticating requests obtained from Sequence Builder - should not be exposed publicly.`
      }
    };
    
    // Remove global security if it exists
    if (data.security) {
      delete data.security;
    }
    
    // If there's no paths section, nothing to do
    if (!data.paths) {
      console.log(`No paths found in file: ${filePath}`);
      return true;
    }
    
    let publicCount = 0;
    let secretCount = 0;
    
    // Update each path
    for (const pathUrl in data.paths) {
      const pathObj = data.paths[pathUrl];
      
      // Check each method (GET, POST, etc.)
      for (const method in pathObj) {
        const endpoint = pathObj[method];
        
        // Skip if this isn't an operation (e.g., parameters at path level)
        if (typeof endpoint !== 'object' || !endpoint) {
          continue;
        }
        
        // Determine if the endpoint is public or secret based on tags
        let isPublic = true; // Default to public
        
        if (endpoint.tags && endpoint.tags.length > 0) {
          if (endpoint.tags.includes('secret')) {
            isPublic = false;
          } else if (endpoint.tags.includes('public')) {
            isPublic = true;
          }
        }
        
        // Set the security for this endpoint
        if (isPublic) {
          endpoint.security = [{ "ApiKeyAuth": ["AQAAAAAAAEGvyZiWA9FMslYeG_yayXaHnSI"] }];
          publicCount++;
        } else {
          endpoint.security = [{ "BearerAuth": [] }];
          secretCount++;
        }
      }
    }
    
    // Write the updated data back to the file
    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
    
    console.log(`Updated file ${filePath}: ${publicCount} public endpoints, ${secretCount} secret endpoints`);
    
    return true;
  } catch (error) {
    console.error(`Error updating ${filePath}: ${error.message}`);
    return false;
  }
}

/**
 * Main function to find and update all JSON files in the api-references directory.
 */
function main() {
  // Get the root directory of the project (parent of scripts directory)
  const rootDir = path.resolve(__dirname, '..');
  
  // Path to the api-references directory
  const apiReferencesDir = path.join(rootDir, 'api-references');
  
  console.log(`Searching for JSON files in: ${apiReferencesDir}`);
  
  // Find all JSON files in the api-references directory and its subdirectories
  const jsonFiles = glob.sync(path.join(apiReferencesDir, '**', '*.json'));
  
  console.log(`Found ${jsonFiles.length} JSON files`);
  
  // Count of updated files
  let updatedCount = 0;
  
  // Update each JSON file
  for (const filePath of jsonFiles) {
    if (updateJsonFile(filePath)) {
      updatedCount++;
    }
  }
  
  console.log(`\nUpdated ${updatedCount} out of ${jsonFiles.length} JSON files.`);
}

// Run the main function
main(); 

// Databeat integration
(function() {
  // Initialize databeat global object
  window.databeat = window.databeat || null;
  
  console.log('Databeat: Initializing tracker...');
  
  // Load Databeat script from local file instead of CDN
  const s = document.createElement('script');
  s.src = '/snippets/dist/databeat-tracker.umd.js';
  s.async = true;
  s.onload = function() {
    console.log('Databeat: Script loaded successfully');
    console.log('Available global objects:', Object.keys(window).filter(key => key.includes('ata')));
    initDatabeat();
  };
  s.onerror = function(error) {
    console.error('Databeat: Failed to load script', error);
  };
  document.head.appendChild(s);
  
  // Initialize Databeat
  function initDatabeat() {
    // Based on the UMD file, it's likely exposed as DatabeatTracker instead of Databeat
    const DatabeatConstructor = window.DatabeatTracker || window.Databeat;
    
    if (!DatabeatConstructor) {
      console.error('Databeat: Constructor is not defined after loading script');
      console.log('Available global objects:', Object.keys(window).filter(key => key.includes('ata')));
      return;
    }
    
    console.log('Databeat: Creating instance...');
    
    // Create databeat instance
    try {
      // Access the Databeat property from the DatabeatTracker object
      // Looking at the UMD file, it exports the Databeat constructor
      const Constructor = DatabeatConstructor.Databeat || DatabeatConstructor;
      
      window.databeat = new Constructor(
        'https://databeat.sequence.app',
        'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhcHAiOiJzZXEtZG9jcyIsImV4cCI6MjA1ODk3NTQyMn0.loEnIIuIzhCsNQJxLteK7ynTlHXbVR7siKx1j5G7ojY',
        { flushInterval: 1000, defaultEnabled: true }
      );
      console.log('Databeat: Instance created successfully');
    } catch (error) {
      console.error('Databeat: Error creating instance', error);
      return;
    }
    
    // Track initial pageview
    trackPageview();
    
    // Listen for browser back/forward navigation
    window.addEventListener('popstate', () => setTimeout(trackPageview, 300));
    
    // Override History API methods to track programmatic navigation
    const originalPushState = history.pushState;
    const originalReplaceState = history.replaceState;
    
    history.pushState = function() {
      originalPushState.apply(this, arguments);
      setTimeout(trackPageview, 300); // Delay to ensure DOM is updated
    };
    
    history.replaceState = function() {
      originalReplaceState.apply(this, arguments);
      setTimeout(trackPageview, 300); // Delay to ensure DOM is updated
    };
    
    // Also track on hash changes for SPAs that use hash-based routing
    window.addEventListener('hashchange', () => setTimeout(trackPageview, 300));
  }
  
  // Helper function to track pageviews
  function trackPageview() {
    if (!window.databeat) {
      console.error('Databeat: Failed to track pageview - databeat not initialized');
      return;
    }
    window.databeat.track({
      event: 'VIEW',
      source: location.pathname,
      props: { title: document.title, url: location.href, referrer: document.referrer }
    });
  }
})(); 


const { execSync } = require("child_process");
const fs = require("fs");
const path = require("path");

const LOCALES_DIR = "."; // Root directory to start search
const EXCLUDE_DIR = path.resolve(LOCALES_DIR, "node_modules"); // Absolute path to node_modules

function formatJsonFile(filePath) {
  try {
    console.log(`Formatting ${filePath}...`);

    // Read the file
    const content = fs.readFileSync(filePath, "utf-8");

    // Parse and reformat the JSON
    // Ensure content is not empty before parsing
    if (content.trim() === "") {
      console.warn(`✓ Skipping empty file: ${filePath}`);
      return true; // Treat empty files as success (nothing to format)
    }

    const parsedJson = JSON.parse(content);
    
    // Sort keys - handle non-object JSON (e.g., arrays, primitives)
    let formattedContent;
    if (typeof parsedJson === 'object' && parsedJson !== null && !Array.isArray(parsedJson)) {
      // Sort keys only for non-null, non-array objects
      const sortedKeys = Object.keys(parsedJson).sort();
      const sortedJson = {};
      sortedKeys.forEach(key => {
        sortedJson[key] = parsedJson[key];
      });
      formattedContent = JSON.stringify(sortedJson, null, 2);
    } else {
      // For arrays or primitives, just stringify with indentation
      formattedContent = JSON.stringify(parsedJson, null, 2);
    }


    // Write the formatted content back to the file
    // Add newline at the end for POSIX compatibility
    fs.writeFileSync(filePath, formattedContent + "\n", "utf-8");

    console.log(`✓ Formatted ${filePath}`);
    return true;
  } catch (error) {
    // Provide more context on parsing errors
    console.error(`✗ Failed to format ${filePath}: ${error.name} - ${error.message}`);
    return false;
  }
}

function formatAllLocalesFiles() {
  try {
    // Find all JSON files recursively starting from LOCALES_DIR
    const command = `find ${LOCALES_DIR} -type f -name "*.json"`;
    console.log(`Running command: ${command}`);
    const output = execSync(command).toString().trim();
    const allFiles = output.split("\n").filter(Boolean);

    // Filter out files within the node_modules directory
    const filesToFormat = allFiles.filter((filePath) => {
      const absoluteFilePath = path.resolve(filePath);
      // Check if the file path starts with the node_modules path
      return !absoluteFilePath.startsWith(EXCLUDE_DIR + path.sep) && // Exclude files *inside* node_modules
             absoluteFilePath !== EXCLUDE_DIR; // Exclude node_modules itself if it were a file somehow
    });

    console.log(`Found ${allFiles.length} total JSON files.`);
    console.log(`Excluded ${allFiles.length - filesToFormat.length} files within node_modules.`);
    console.log("Files to format:", filesToFormat);

    if (filesToFormat.length === 0) {
      return []; // Return empty array if no files left after filtering
    }

    return filesToFormat.map(formatJsonFile);
  } catch (error) {
    // Handle errors from the 'find' command itself
    console.error("Error finding JSON files:", error.message);
    if (error.stderr) {
       console.error("Find command stderr:", error.stderr.toString());
    }
    return [];
  }
}

function main() {
  const results = formatAllLocalesFiles(); // results is now an array of booleans (true for success, false for failure)

  if (results.length === 0) {
    console.log("No relevant JSON files found or processed. Nothing to format.");
    // Decide if this should be an error or not; exiting 0 is fine if it's expected
    process.exit(0);
  }

  // Count failures
  const failedCount = results.filter((success) => !success).length;

  if (failedCount > 0) {
    console.error(`\nFormatting complete, but failed for ${failedCount} file(s). See logs above.`);
    process.exit(1);
  }

  console.log("\nAll relevant JSON files formatted successfully!");
}

main();

const { execSync } = require('child_process');
const fs = require('fs').promises;
const path = require('path');

// ==================================================================================================
// 🔧 REQUIRED CONFIGURATION – USERS MUST MODIFY THESE VALUES TO CONFIGURE THEIR TRANSLATION PATHS 🔧
// ==================================================================================================

// Path to your original language files (e.g., English source content)
const ORIGIN_LANGUAGE_DIR = path.resolve('.'); 

// Path where translated files will be saved (Base directory)
const TRANSLATION_OUTPUT_DIR = path.resolve('.');

// List of files or directories to exclude from processing
const EXCLUDED_FILES = ['package.json', 'package-lock.json', 'node_modules'];

// ============================================================
// MODIFY BELOW THIS LINE FOR CUSTOM GITHUB ACTIONS
// ============================================================

(async () => {
    // Dynamically import the ESM-only module
    const sdkModule = await import('@frenglish/sdk');
    const FrenglishSDK = sdkModule.FrenglishSDK;
    if (!FrenglishSDK) throw new Error('FrenglishSDK not found in module exports.');

    // Retrieve the API key from environment variable
    const FRENGLISH_API_KEY = process.env.FRENGLISH_API_KEY;
    if (!FRENGLISH_API_KEY) {
        console.error('Error: FRENGLISH_API_KEY environment variable not set.');
        process.exit(1);
    }
    const frenglish = FrenglishSDK(FRENGLISH_API_KEY);

    async function getDefaultBranch() {
        try {
            const response = await fetch(`https://api.github.com/repos/${process.env.GITHUB_REPOSITORY}`, {
                headers: {
                    'Authorization': `token ${process.env.GITHUB_TOKEN}`,
                    'Accept': 'application/vnd.github.v3+json'
                }
            });
            const data = await response.json();
            return data.default_branch;
        } catch (error) {
            console.log('Error getting default branch:', error.message);
            return 'main';
        }
    }

    async function isSupportedFile(filePath) {
        try {
            // Ensure the file is within the intended source directory structure for relative path logic
            const relativeToOrigin = path.relative(ORIGIN_LANGUAGE_DIR, path.resolve(filePath));
            if (relativeToOrigin.startsWith('..') || relativeToOrigin === '') {
                 return false;
            }

            // Check against general excluded files/paths
            if (EXCLUDED_FILES.some(excluded => filePath.includes(excluded))) {
                console.log(`File ${filePath} is explicitly excluded.`);
                return false;
            }

            // Get the configuration to check origin language
            const config = await frenglish.getDefaultConfiguration();
            const languageCodes = await frenglish.getSupportedLanguages();
            const originLanguage = config.originLanguage.toLowerCase();

            // Check if the file is in a translated language directory
            const pathParts = filePath.split(path.sep);
            const languageDirIndex = pathParts.findIndex(part => 
                part.toLowerCase() === originLanguage || 
                languageCodes.some(lang => lang.toLowerCase() === part.toLowerCase())
            );

            // If the file is in a language directory and it's not the origin language, exclude it
            if (languageDirIndex !== -1 && pathParts[languageDirIndex].toLowerCase() !== originLanguage) {
                console.log(`File ${filePath} is in a translated language directory. Excluding.`);
                return false;
            }

            // Check extension against Frenglish supported types
            const supportedFileTypes = await frenglish.getSupportedFileTypes();
            const validFileTypes = supportedFileTypes.filter(type => type && type.length > 0);
            const ext = path.extname(filePath).toLowerCase().replace('.', '');

            const isSupported = ext && validFileTypes.includes(ext);
            return isSupported;

        } catch (error) {
            console.error(`Error checking file support for ${filePath}:`, error.message);
            return false;
        }
    }

    async function getChangedFiles() {
        try {
            const currentBranch = process.env.GITHUB_HEAD_REF || process.env.GITHUB_REF?.replace('refs/heads/', '');
            console.log('Current branch:', currentBranch);

            // First fetch all remote branches
            execSync('git fetch --prune origin');
            
            // Get the parent branch using git rev-parse
            let parentBranch;
            try {
                // Get all remote branches
                const remoteBranches = execSync('git branch -r').toString()
                    .split('\n')
                    .map(b => b.trim())
                    .filter(b => b && !b.includes(currentBranch))
                    .map(b => b.replace('origin/', ''));

                console.log('Available remote branches:', remoteBranches);

                // Try to find the parent branch by looking at the merge base with each remote branch
                for (const branch of remoteBranches) {
                    try {
                        const mergeBase = execSync(`git merge-base HEAD origin/${branch}`).toString().trim();
                        if (mergeBase) {
                            parentBranch = branch;
                            break;
                        }
                    } catch (e) {
                        // Skip this branch if merge-base fails
                        continue;
                    }
                }

                if (!parentBranch) {
                    // If we still can't find a parent, try to get it from the pull request
                    if (process.env.GITHUB_BASE_REF) {
                        parentBranch = process.env.GITHUB_BASE_REF;
                    } else {
                        // Last resort: try to get the default branch
                        const defaultBranch = await getDefaultBranch();
                        parentBranch = defaultBranch;
                    }
                }
            } catch (error) {
                console.log('Could not determine parent branch, trying GITHUB_BASE_REF:', error.message);
                // Try to get the base ref from GitHub environment
                if (process.env.GITHUB_BASE_REF) {
                    parentBranch = process.env.GITHUB_BASE_REF;
                } else {
                    // Last resort: try to get the default branch
                    const defaultBranch = await getDefaultBranch();
                    parentBranch = defaultBranch;
                }
            }
            
            console.log('Parent branch:', parentBranch);

            // Fetch both branches
            execSync(`git fetch origin ${parentBranch}:refs/remotes/origin/${parentBranch}`);
            execSync(`git fetch origin ${currentBranch}:refs/remotes/origin/${currentBranch}`);
            
            console.log(`Getting changed files between ${parentBranch} and ${currentBranch}...`);
            const output = execSync(`git diff --diff-filter=ACM --name-only origin/${parentBranch}...origin/${currentBranch}`).toString().trim();
            const changedFiles = output.split('\n');
            const supportedFiles = [];
            for (const file of changedFiles) {
                const isSupported = await isSupportedFile(file);
                if (isSupported) {
                    supportedFiles.push(file);
                }
            }
            console.log('Files sent for translation:', supportedFiles);
            return supportedFiles;
        } catch (error) {
            console.log('Error getting changed files:', error.message);
            return [];
        }
    }

    async function translateAndWriteFiles() {
        try {
            const config = await frenglish.getDefaultConfiguration();
            const originLanguage = config.originLanguage.toLowerCase();
            const filesToTranslate = await getChangedFiles();

            if (!filesToTranslate || filesToTranslate.length === 0) {
                console.log('No supported files found in the diff within the origin language directory to translate.');
                return; // Exit gracefully if no files need translation
            }

            // Prepare content for translation
            const fileContents = await Promise.all(filesToTranslate.map(async (file) => {
                try {
                    const content = await fs.readFile(file, 'utf-8');
                    // Use path relative to ORIGIN_LANGUAGE_DIR as the fileId
                    const fileId = path.relative(ORIGIN_LANGUAGE_DIR, file);
                    return { fileId: fileId, content: content };
                } catch (readError) {
                    console.error(`Error reading file ${file}:`, readError.message);
                    return null;
                }
            }));

            // Filter out any nulls from read errors
            const validFileContents = fileContents.filter(fc => fc !== null);
            if (validFileContents.length === 0) {
                console.log('No valid file contents could be read for translation.');
                return;
            }

            const filenames = validFileContents.map(file => file.fileId);
            const contents = validFileContents.map(file => file.content);

            console.log(`Initiating translation for ${filenames.length} files:`, filenames);
            const translation = await frenglish.translate(contents, false, filenames);
            console.log(`Translation requested with ID: ${translation.translationId}`);

            // Process translated content
            for (const languageData of translation.content) {
                const language = languageData.language;
                // Skip writing files for the origin language if they are returned
                if (language === originLanguage) {
                    console.log(`Skipping write for origin language: ${language}`);
                    continue;
                }

                const languageOutputDir = path.join(TRANSLATION_OUTPUT_DIR, language);
                try {
                    await fs.mkdir(languageOutputDir, { recursive: true });
                } catch (mkdirError) {
                    console.error(`Error creating directory ${languageOutputDir}:`, mkdirError.message);
                    continue; // Skip this language if directory creation fails
                }

                for (const translatedFile of languageData.files) {
                    // Construct the full path for the translated file
                    const translatedFilePath = path.join(languageOutputDir, translatedFile.fileId);

                    // Ensure the subdirectory for the file exists (e.g., for nested structures)
                    try {
                        await fs.mkdir(path.dirname(translatedFilePath), { recursive: true });
                    } catch (mkdirError) {
                        console.error(`Error creating subdirectory ${path.dirname(translatedFilePath)}:`, mkdirError.message);
                        continue; // Skip this file if subdirectory creation fails
                    }
                    
                    // Write the file content if not empty
                    if (translatedFile.content && translatedFile.content.length > 0) {
                        try {
                            await fs.writeFile(translatedFilePath, translatedFile.content, 'utf8');
                            console.log(`Translated file written: ${translatedFilePath}`);
                        } catch (writeError) {
                            console.error(`Error writing translated file ${translatedFilePath}:`, writeError.message);
                        }
                    } else {
                        console.warn(`Empty content for translated file: ${translatedFile.fileId} in language ${language}. Skipping write.`);
                    }
                }
            }

            console.log("Translation file writing complete. Git operations will be handled by the workflow.");

        } catch (error) {
            console.error('Error during translation and file writing process:', error);
            if (error.response && error.response.data) {
                console.error('Frenglish API Error Details:', error.response.data);
            }
            process.exit(1);
        }
    }

    // Run the modified translation process
    translateAndWriteFiles();
})();

The on-ramp feature allows developers to integrate the Embedded Wallet with Web SDK, enabling users to easily purchase fiat currency using a credit or debit card through a simplified react component.

Web SDK

Game Engine SDKs

Other SDKs

On-ramp