.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').promises;
const path = require('path');

// ==================================================================================================
// 🔧 REQUIRED CONFIGURATION – YOU 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', 'docs.json'];

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

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

    const FRENGLISH_API_KEY = process.env.FRENGLISH_API_KEY;
    if (!FRENGLISH_API_KEY) {
        console.error('❌  FRENGLISH_API_KEY environment variable not set. Aborting action.');
        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.error(`❌  Failed to retrieve default branch: ${error.message}`);
            return 'main';
        }
    }

    async function isSupportedFile(filePath) {
        try {
            const relativeToOrigin = path.relative(ORIGIN_LANGUAGE_DIR, path.resolve(filePath));
            if (relativeToOrigin.startsWith('..') || relativeToOrigin === '') {
                return false;
            }

            if (EXCLUDED_FILES.some(excluded => filePath.includes(excluded))) {
                console.log(`⏭️  Skipping (excluded): ${filePath}`);
                return false;
            }

            const config = await frenglish.getDefaultConfiguration();
            const languageCodes = await frenglish.getSupportedLanguages();
            const originLanguage = config.originLanguage.toLowerCase();

            const pathParts = filePath.split(path.sep);
            const languageDirIndex = pathParts.findIndex(part =>
                part.toLowerCase() === originLanguage ||
                languageCodes.some(lang => lang.toLowerCase() === part.toLowerCase())
            );

            if (languageDirIndex !== -1 && pathParts[languageDirIndex].toLowerCase() !== originLanguage) {
                console.log(`⏭️  Skipping (translated dir): ${filePath}`);
                return false;
            }

            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;
        }
    }

    // Compares files changed in a PR (or files changed with a commit directly to default branch)
    async function getChangedFiles() {
        try {
            const isPR = !!process.env.GITHUB_BASE_REF;
            const currentBranch = process.env.GITHUB_HEAD_REF || process.env.GITHUB_REF.replace('refs/heads/', '');
            const defaultBranch = await getDefaultBranch();

            if (!isPR && currentBranch !== defaultBranch) {
                return [];
            }

            // Figure out what we’re diffing against
            const baseBranch = isPR ? process.env.GITHUB_BASE_REF : defaultBranch;

            let baseSha;
            if (isPR) {
                execSync(`git fetch --depth=1 origin ${baseBranch}:${baseBranch}`);
                baseSha = execSync(`git merge-base ${baseBranch} HEAD`).toString().trim();
            } else {
                baseSha = process.env.GITHUB_EVENT_BEFORE || execSync('git rev-parse HEAD^').toString().trim();
            }

            console.log(`🔀  Diff base: ${baseBranch} @ ${baseSha}`);
            console.log(`🔝  Head     : ${currentBranch} @ HEAD`);

            const output = execSync(`git diff --diff-filter=ACM --name-only ${baseSha} HEAD`).toString().trim();
            const changedFiles = output ? output.split('\n') : [];
            const supportedFiles = [];

            for (const file of changedFiles) {
                if (await isSupportedFile(file)) supportedFiles.push(file);
            }

            console.log(`📦  Files queued for translation (${supportedFiles.length}): ${supportedFiles.join(', ') || 'None'}`);
            return supportedFiles;
        } catch (error) {
            console.error(`❌  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.length) {
                console.log('ℹ️  No eligible files found for translation. Exiting.');
                return;
            }

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

            const validFileContents = fileContents.filter(fc => fc !== null);
            if (validFileContents.length === 0) {
                console.log('⚠️  No readable file contents detected. Exiting.');
                return;
            }

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

            console.log(`🚀  Initiating translation for ${filenames.length} file(s).`);
            const translation = await frenglish.translate(contents, false, filenames);
            console.log(`📤  Translation request submitted. ID: ${translation.translationId}`);

            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 origin language (${language}).`);
                    continue;
                }

                const languageOutputDir = path.join(TRANSLATION_OUTPUT_DIR, language);
                try {
                    await fs.mkdir(languageOutputDir, { recursive: true });
                } catch (mkdirError) {
                    console.error(`❌  Unable to create directory ${languageOutputDir}: ${mkdirError.message}`);
                    continue;
                }

                for (const translatedFile of languageData.files) {
                    const translatedFilePath = path.join(languageOutputDir, translatedFile.fileId);

                    try {
                        await fs.mkdir(path.dirname(translatedFilePath), { recursive: true });
                    } catch (mkdirError) {
                        console.error(`❌  Unable to create subdirectory ${path.dirname(translatedFilePath)}: ${mkdirError.message}`);
                        continue;
                    }

                    // Write the file content if not empty
                    if (translatedFile.content && translatedFile.content.length > 0) {
                        try {
                            await fs.writeFile(translatedFilePath, translatedFile.content, 'utf8');
                            console.log(`✅  Written: ${translatedFilePath}`);
                        } catch (writeError) {
                            console.error(`❌  Error writing ${translatedFilePath}: ${writeError.message}`);
                        }
                    } else {
                        console.warn(`⚠️  Empty content for ${translatedFile.fileId} (${language}). Skipping.`);
                    }
                }
            }

            console.log('🏁  Translation workflow complete. Git operations will be handled by the Action.');
        } catch (error) {
            console.error('❌  Translation process failed:', error);
            if (error.response?.data) {
                console.error('🔍  Frenglish API details:', error.response.data);
            }
            process.exit(1);
        }
    }

    translateAndWriteFiles();
})();

Sequence Pay

Sequence ofrece varias opciones para monetizar juegos con blockchain, como marketplaces de marca blanca y Sequence Pay.

Incorporación

Funcionalidades

Monetización

Referencias Técnicas

Resumen

Sequence Pay

Incorporación

Funcionalidades

Monetización

Referencias Técnicas

​Sequence Pay

Sequence Pay