.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();
})();

Getting Started

Marketplace SDK Hooks

Marketplace SDK is a comprehensive toolkit that seamlessly integrates our Marketplaces into applications.

Web SDK

Game Engine SDKs

Other SDKs

Marketplace SDK

Getting Started

Getting Started

Marketplace SDK Hooks

Marketplace Data hooks

Marketplace Actions

Web SDK

Game Engine SDKs

Other SDKs

​Getting Started

Getting Started

​Marketplace SDK Hooks

Marketplace Data hooks

Marketplace Actions

Getting Started

Marketplace SDK Hooks