White Page Generator для TikTok Ads: оптимизация контента в 2025 году

// ContentAnalyzer анализирует контент на соответствие требованиям TikTok
type ContentAnalyzer struct {
    policyValidator    *PolicyValidator
    semanticAnalyzer   *SemanticAnalyzer
    performanceChecker *PerformanceChecker
    mediaOptimizer     *MediaOptimizer
    tiktokClient       *TikTokApiClient
}

// NewContentAnalyzer создает новый экземпляр анализатора контента
func NewContentAnalyzer(
    policyValidator *PolicyValidator,
    semanticAnalyzer *SemanticAnalyzer,
    performanceChecker *PerformanceChecker,
    mediaOptimizer *MediaOptimizer,
    tiktokClient *TikTokApiClient,
) *ContentAnalyzer {
    return &ContentAnalyzer{
        policyValidator:    policyValidator,
        semanticAnalyzer:   semanticAnalyzer,
        performanceChecker: performanceChecker,
        mediaOptimizer:     mediaOptimizer,
        tiktokClient:       tiktokClient,
    }
}

// AnalyzePage проверяет страницу на соответствие требованиям TikTok
func (a *ContentAnalyzer) AnalyzePage(ctx context.Context, page *Page) (*AnalysisResult, error) {
    // Параллельный запуск всех проверок для ускорения анализа
    var wg sync.WaitGroup
    var policyResult *PolicyValidationResult
    var semanticResult *SemanticAnalysisResult
    var performanceResult *PerformanceCheckResult
    var mediaResult *MediaOptimizationResult
    var err error

    wg.Add(4)
    
    // Проверка соответствия политикам TikTok
    go func() {
        defer wg.Done()
        policyResult, err = a.policyValidator.ValidatePage(ctx, page)
    }()
    
    // Семантический анализ контента
    go func() {
        defer wg.Done()
        semanticResult = a.semanticAnalyzer.AnalyzeContent(page.Content)
    }()
    
    // Проверка производительности
    go func() {
        defer wg.Done()
        performanceResult = a.performanceChecker.CheckPerformance(page)
    }()
    
    // Оптимизация медиаресурсов
    go func() {
        defer wg.Done()
        mediaResult = a.mediaOptimizer.OptimizeMedia(page.Media)
    }()
    
    wg.Wait()
    
    if err != nil {
        return nil, err
    }
    
    // Интеграция с TikTok API для предварительной проверки
    preApprovalScore, err := a.tiktokClient.PreApprovePage(
        ctx, 
        &TikTokPreApprovalRequest{
            ContentType:    page.ContentType,
            ContentSummary: semanticResult.Summary,
            Keywords:       semanticResult.Keywords,
            Sentiment:      semanticResult.Sentiment,
        },
    )
    
    if err != nil {
        log.Printf("Warning: Unable to get pre-approval from TikTok API: %v", err)
    }
    
    // Формирование итогового результата анализа
    result := &AnalysisResult{
        PolicyValidation:    policyResult,
        SemanticAnalysis:    semanticResult,
        PerformanceCheck:    performanceResult,
        MediaOptimization:   mediaResult,
        TikTokApprovalScore: preApprovalScore,
        OptimizationSuggestions: a.generateOptimizationSuggestions(
            policyResult,
            semanticResult,
            performanceResult,
            mediaResult,
            preApprovalScore,
        ),
    }
    
    return result, nil
}
        

// media-optimizer.ts
import sharp from 'sharp';
import { StorageService } from './storage-service';
import { TikTokDeviceDetector } from './device-detector';

interface MediaOptimizationOptions {
  targetDevice: 'mobile' | 'tablet' | 'desktop';
  networkType?: '4g' | '5g' | 'wifi' | 'slow-3g';
  maxWidth?: number;
  maxHeight?: number;
  quality?: number;
  format?: 'webp' | 'avif' | 'jpeg';
  placeholder?: boolean;
}

export class TikTokMediaOptimizer {
  private storageService: StorageService;
  private deviceDetector: TikTokDeviceDetector;
  
  constructor(storageService: StorageService, deviceDetector: TikTokDeviceDetector) {
    this.storageService = storageService;
    this.deviceDetector = deviceDetector;
  }
  
  /**
   * Оптимизирует изображение для TikTok Ads с учетом устройства и сети
   */
  async optimizeImage(
    imageUrl: string,
    options: MediaOptimizationOptions
  ): Promise {
    // Загрузка оригинального изображения
    const imageBuffer = await this.storageService.downloadImage(imageUrl);
    
    // Определение оптимальных параметров
    const { width, height, quality, format } = this.calculateOptimalParameters(
      options.targetDevice,
      options.networkType || '4g',
      options.maxWidth,
      options.maxHeight,
      options.quality,
      options.format
    );
    
    // Оптимизация изображения
    let processedImage = sharp(imageBuffer)
      .resize({
        width,
        height,
        fit: 'inside',
        withoutEnlargement: true,
      });
    
    // Применение нужного формата изображения
    switch (format) {
      case 'webp':
        processedImage = processedImage.webp({ quality });
        break;
      case 'avif':
        processedImage = processedImage.avif({ quality });
        break;
      default:
        processedImage = processedImage.jpeg({ quality, mozjpeg: true });
    }
    
    // Генерация плейсхолдера для ускорения загрузки
    let placeholderUrl = null;
    if (options.placeholder) {
      const placeholderBuffer = await sharp(imageBuffer)
        .resize(20)
        .blur(10)
        .toBuffer();
      
      placeholderUrl = await this.storageService.uploadImage(
        `placeholders/${this.extractFilename(imageUrl)}`,
        placeholderBuffer
      );
    }
    
    // Сохранение оптимизированного изображения
    const outputBuffer = await processedImage.toBuffer();
    const optimizedUrl = await this.storageService.uploadImage(
      `optimized/${this.extractFilename(imageUrl)}`,
      outputBuffer
    );
    
    return {
      url: optimizedUrl,
      placeholder: placeholderUrl,
      originalSize: imageBuffer.length,
      optimizedSize: outputBuffer.length,
      compressionRatio: 1 - (outputBuffer.length / imageBuffer.length),
      width,
      height,
      format
    };
  }
  
  // Дополнительные методы класса...
}
        

// personalization-engine.ts
import { SegmentDetector } from './segment-detector';
import { ContentRepository } from './content-repository';
import { UserProfileService } from './user-profile-service';
import { TikTokVisitorData, ContentBlock, PersonalizationRule } from './types';

export class PersonalizationEngine {
  private segmentDetector: SegmentDetector;
  private contentRepository: ContentRepository;
  private userProfileService: UserProfileService;
  
  constructor(
    segmentDetector: SegmentDetector,
    contentRepository: ContentRepository,
    userProfileService: UserProfileService
  ) {
    this.segmentDetector = segmentDetector;
    this.contentRepository = contentRepository;
    this.userProfileService = userProfileService;
  }
  
  /**
   * Персонализирует содержимое страницы для конкретного посетителя
   */
  async personalizeContent(pageId: string, visitorData: TikTokVisitorData): Promise {
    // Получение шаблона страницы
    const template = await this.contentRepository.getPageTemplate(pageId);
    
    // Определение сегмента пользователя
    const userSegments = await this.segmentDetector.detectSegments(visitorData);
    
    // Получение или создание профиля пользователя
    const userProfile = await this.userProfileService.getOrCreateProfile(
      visitorData.visitorId,
      visitorData.deviceInfo,
      visitorData.location,
      userSegments
    );
    
    // Применение правил персонализации
    const personalizedBlocks = template.contentBlocks.map(block => {
      // Если для блока нет правил персонализации, возвращаем оригинальный блок
      if (!block.personalizationRules || block.personalizationRules.length === 0) {
        return block;
      }
      
      // Поиск первого совпадающего правила персонализации
      const matchingRule = this.findMatchingRule(block.personalizationRules, userSegments, userProfile);
      
      // Если нет совпадающего правила, возвращаем оригинальный блок
      if (!matchingRule) {
        return block;
      }
      
      // Применение персонализации
      return {
        ...block,
        content: matchingRule.contentVariation.content,
        style: {
          ...block.style,
          ...matchingRule.contentVariation.style
        },
        media: matchingRule.contentVariation.media || block.media
      };
    });
    
    // Запись данных для дальнейшего анализа
    this.userProfileService.recordPersonalization(
      visitorData.visitorId,
      pageId,
      userSegments,
      personalizedBlocks.map(b => b.id)
    );
    
    return personalizedBlocks;
  }
  
  // Дополнительные методы класса...
}
        

// white-page-generator.js
const { TikTokApiClient } = require('./tiktok-api-client');
const { ContentOptimizer } = require('./content-optimizer');
const { TemplateRenderer } = require('./template-renderer');
const { MediaProcessor } = require('./media-processor');
const { PerformanceOptimizer } = require('./performance-optimizer');
const { ComplianceChecker } = require('./compliance-checker');

class WhitePageGenerator {
  constructor(config) {
    this.tikTokClient = new TikTokApiClient(config.tikTokApi);
    this.contentOptimizer = new ContentOptimizer(config.contentOptimizer);
    this.templateRenderer = new TemplateRenderer(config.templateRenderer);
    this.mediaProcessor = new MediaProcessor(config.mediaProcessor);
    this.performanceOptimizer = new PerformanceOptimizer(config.performanceOptimizer);
    this.complianceChecker = new ComplianceChecker(config.complianceChecker);
    
    this.config = config;
  }
  
  /**
   * Создает новую White Page для TikTok Ads кампании
   */
  async generateWhitePage(templateId, parameters, targetAudience) {
    try {
      // Получение и проверка шаблона
      const template = await this.getTemplate(templateId);
      
      // Оптимизация содержимого для целевой аудитории
      const optimizedContent = await this.contentOptimizer.optimize(
        template, 
        parameters,
        targetAudience
      );
      
      // Обработка медиаресурсов
      const processedMedia = await this.mediaProcessor.processMedia(
        optimizedContent.media,
        targetAudience.devices
      );
      
      // Рендеринг страницы
      const renderedPage = await this.templateRenderer.render({
        template: template,
        content: optimizedContent,
        media: processedMedia,
        parameters: parameters
      });
      
      // Оптимизация производительности
      const optimizedPage = await this.performanceOptimizer.optimize(renderedPage);
      
      // Проверка соответствия требованиям TikTok
      const complianceResult = await this.complianceChecker.check(optimizedPage);
      
      if (!complianceResult.compliant) {
        // Автоматическое устранение проблем соответствия
        const fixedPage = await this.autoFixComplianceIssues(
          optimizedPage,
          complianceResult.issues
        );
        
        // Повторная проверка после исправлений
        const reCheckResult = await this.complianceChecker.check(fixedPage);
        
        if (!reCheckResult.compliant) {
          throw new Error(
            `Невозможно автоматически исправить все проблемы соответствия: ${JSON.stringify(reCheckResult.issues)}`
          );
        }
        
        // Сохранение и публикация страницы
        return await this.publishPage(fixedPage, parameters.campaignId);
      }
      
      // Сохранение и публикация страницы
      return await this.publishPage(optimizedPage, parameters.campaignId);
    } catch (error) {
      console.error('Ошибка при генерации White Page:', error);
      throw error;
    }
  }
  
  // Дополнительные методы класса...
}

module.exports = { WhitePageGenerator };
        

// template-renderer.js
const { minify } = require('html-minifier');
const { optimizeCSS } = require('./css-optimizer');
const { optimizeJS } = require('./js-optimizer');
const { generateCriticalCSS } = require('./critical-css-generator');
const { adaptToDevice } = require('./device-adapter');

class TemplateRenderer {
  constructor(config) {
    this.config = config;
    this.renderCache = new Map();
    this.ssrEnabled = config.enableSSR !== false;
    this.criticalCSSEnabled = config.enableCriticalCSS !== false;
  }
  
  /**
   * Рендерит страницу на основе шаблона и параметров
   */
  async render(options) {
    const { template, content, media, parameters } = options;
    
    // Проверка кэша рендеринга
    const cacheKey = this.generateCacheKey(template.id, parameters);
    if (this.renderCache.has(cacheKey)) {
      return this.renderCache.get(cacheKey);
    }
    
    try {
      // Рендеринг основного контента
      let html = this.renderTemplate(template, content, media, parameters);
      
      // Адаптация для разных устройств
      const deviceAdaptedHTML = await adaptToDevice(html, parameters.targetDevice || 'mobile');
      
      // Оптимизация для TikTok WebView
      const optimizedHTML = await this.optimizeForTikTok(deviceAdaptedHTML, parameters);
      
      // Кэширование результата
      this.renderCache.set(cacheKey, optimizedHTML);
      
      return optimizedHTML;
    } catch (error) {
      console.error('Ошибка рендеринга шаблона:', error);
      throw new Error(`Ошибка рендеринга шаблона: ${error.message}`);
    }
  }
  
  // Дополнительные методы класса...
}

module.exports = { TemplateRenderer };
        

// js-optimizer.js
const { minify } = require('terser');
const { analyze } = require('./js-analyzer');

/**
 * Оптимизирует JavaScript код для TikTok WebView
 */
async function optimizeJS(scripts, options) {
  try {
    // Анализ скриптов для выявления проблем и оптимизаций
    const analysisResult = await analyze(scripts, options);
    
    // Применяем TikTok-специфичные замены API
    const tiktokCompatibleScripts = applyTikTokCompatibility(
      scripts,
      analysisResult.incompatibleAPIs
    );
    
    // Оптимизация бандла
    const { code } = await minify(tiktokCompatibleScripts, {
      compress: {
        ecma: 2020,
        passes: 2,
        unsafe_arrows: true,
        unsafe_methods: true,
        unsafe_regexp: true,
        unsafe_math: true,
        conditionals: true,
        evaluate: true,
        drop_console: options.production === true,
        drop_debugger: true,
      },
      mangle: true,
      format: {
        ecma: 2020,
        comments: false,
      },
      module: analysisResult.isModule,
      sourceMap: false,
      toplevel: true,
    });
    
    // Добавляем полифиллы для TikTok WebView при необходимости
    const polyfills = getRequiredPolyfills(
      analysisResult.features,
      options.target,
      options.device
    );
    
    // Безопасное обертывание кода для предотвращения утечек глобальных переменных
    const wrappedCode = wrapCodeForSafety(code);
    
    return polyfills ? `${polyfills}\n${wrappedCode}` : wrappedCode;
  } catch (error) {
    console.error('Ошибка оптимизации JavaScript:', error);
    
    // В случае ошибки возвращаем исходный код с минимальной обработкой
    return scripts.join(';\n');
  }
}

// Дополнительные функции...

module.exports = {
  optimizeJS,
  applyTikTokCompatibility,
  getRequiredPolyfills
};
        

// tiktok-api-client.ts
import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
import { RateLimiter } from './rate-limiter';
import { TikTokCampaign, TikTokAd, TikTokCreative, TikTokPixel } from './types';

interface TikTokApiConfig {
  appId: string;
  appSecret: string;
  accessToken: string;
  refreshToken: string;
  advertiserId: string;
  baseUrl?: string;
  maxRetries?: number;
  rateLimits?: {
    requestsPerSecond: number;
    requestsPerHour: number;
  };
}

export class TikTokApiClient {
  private client: AxiosInstance;
  private config: TikTokApiConfig;
  private rateLimiter: RateLimiter;
  
  constructor(config: TikTokApiConfig) {
    this.config = {
      baseUrl: 'https://business-api.tiktok.com/open_api/v1.3',
      maxRetries: 3,
      rateLimits: {
        requestsPerSecond: 10,
        requestsPerHour: 3600
      },
      ...config
    };
    
    this.client = axios.create({
      baseURL: this.config.baseUrl,
      timeout: 10000,
      headers: {
        'Content-Type': 'application/json',
        'Access-Token': this.config.accessToken
      }
    });
    
    this.rateLimiter = new RateLimiter({
      maxRequests: this.config.rateLimits!.requestsPerSecond,
      interval: 1000,
      maxRequestsPerHour: this.config.rateLimits!.requestsPerHour
    });
    
    // Настройка перехватчиков для обработки обновления токена и повторных попыток
    this.setupInterceptors();
  }
  
  /**
   * Получает список кампаний
   */
  async getCampaigns(options: { 
    page?: number;
    pageSize?: number;
    status?: 'CAMPAIGN_STATUS_ENABLE' | 'CAMPAIGN_STATUS_DISABLE' | 'CAMPAIGN_STATUS_DELETE';
  } = {}): Promise {
    await this.rateLimiter.waitForPermission();
    
    const response = await this.client.get('/campaign/get/', {
      params: {
        advertiser_id: this.config.advertiserId,
        page: options.page || 1,
        page_size: options.pageSize || 10,
        status: options.status
      }
    });
    
    this.validateResponse(response.data);
    
    return response.data.data.list || [];
  }
  
  // Другие методы API...
  
  // Обработчик обновления токена
  public onTokenRefresh?: (tokens: { 
    accessToken: string;
    refreshToken: string;
    expiresIn: number;
  }) => void;
}
        

// tiktok-pixel-manager.js
class TikTokPixelManager {
  constructor(pixelId, options = {}) {
    this.pixelId = pixelId;
    this.options = {
      debug: false,
      autoConfig: true,
      ...options
    };
    
    this.isInitialized = false;
    this.eventQueue = [];
    
    // Инициализация пикселя при создании экземпляра
    if (this.options.autoInit !== false) {
      this.init();
    }
  }
  
  /**
   * Инициализирует TikTok Pixel
   */
  init() {
    // Предотвращаем повторную инициализацию
    if (this.isInitialized) {
      return;
    }
    
    // Вставка базового кода пикселя TikTok
    !function (w, d, t) {
      w.TiktokAnalyticsObject = t;
      var ttq = w[t] = w[t] || [];
      ttq.methods = ["page", "track", "identify", "instances", "debug", "on", "off", "once", "ready", "alias", "group", "enableCookie", "disableCookie"];
      ttq.setAndDefer = function(t, e) {
        t[e] = function() {
          t.push([e].concat(Array.prototype.slice.call(arguments, 0)));
        }
      };
      for (var i = 0; i < ttq.methods.length; i++) ttq.setAndDefer(ttq, ttq.methods[i]);
      ttq.instance = function(t) {
        for (var e = ttq._i[t] || [], n = 0; n < ttq.methods.length; n++) ttq.setAndDefer(e, ttq.methods[n]);
        return e;
      };
      ttq.load = function(e, n) {
        var i = "https://analytics.tiktok.com/i18n/pixel/events.js";
        ttq._i = ttq._i || {};
        ttq._i[e] = [];
        ttq._i[e]._u = i;
        ttq._t = ttq._t || {};
        ttq._t[e] = +new Date();
        ttq._o = ttq._o || {};
        ttq._o[e] = n || {};
        var r = document.createElement("script");
        r.type = "text/javascript";
        r.async = true;
        r.src = i + "?sdkid=" + e + "&lib=" + t;
        var s = document.getElementsByTagName("script")[0];
        s.parentNode.insertBefore(r, s);
      };
    
      // Загрузка с заданным ID пикселя
      ttq.load(this.pixelId);
      
      // Отправка события просмотра страницы
      if (this.options.autoConfig) {
        ttq.page();
      }
    }(window, document, 'ttq');
    
    this.isInitialized = true;
    
    // Обработка отложенных событий
    this.processEventQueue();
    
    if (this.options.debug) {
      console.log(`TikTok Pixel ${this.pixelId} initialized`);
    }
  }
  
  // Дополнительные методы...
}

// Экспортируем класс
module.exports = { TikTokPixelManager };
        

// core-web-vitals-optimizer.js
const { injectScript } = require('./script-injector');
const { optimizeResources } = require('./resource-optimizer');

class CoreWebVitalsOptimizer {
  constructor(options = {}) {
    this.options = {
      lcp: true,
      cls: true,
      fid: true,
      ttfb: true,
      ...options
    };
    
    this.metrics = {
      lcp: null,
      cls: null,
      fid: null,
      ttfb: null
    };
    
    this.thresholds = {
      lcp: 2500, // ms
      cls: 0.1,  // score
      fid: 100,  // ms
      ttfb: 800  // ms
    };
  }
  
  /**
   * Оптимизирует страницу для улучшения Core Web Vitals
   */
  async optimize(html, pageData) {
    let optimizedHtml = html;
    
    // Оптимизация Largest Contentful Paint (LCP)
    if (this.options.lcp) {
      optimizedHtml = await this.optimizeLCP(optimizedHtml, pageData);
    }
    
    // Оптимизация Cumulative Layout Shift (CLS)
    if (this.options.cls) {
      optimizedHtml = await this.optimizeCLS(optimizedHtml);
    }
    
    // Оптимизация First Input Delay (FID)
    if (this.options.fid) {
      optimizedHtml = await this.optimizeFID(optimizedHtml);
    }
    
    // Оптимизация Time to First Byte (TTFB)
    if (this.options.ttfb) {
      optimizedHtml = await this.optimizeTTFB(optimizedHtml);
    }
    
    // Вставка скрипта для мониторинга метрик
    if (this.options.monitor) {
      optimizedHtml = this.injectMonitoringScript(optimizedHtml);
    }
    
    return optimizedHtml;
  }
  
  // Дополнительные методы...
}

module.exports = { CoreWebVitalsOptimizer };
        

// tiktok-webview-optimizer.ts
import { JSDOM } from 'jsdom';
import { minify as minifyHTML } from 'html-minifier-terser';
import { minify as minifyJS } from 'terser';
import { optimize as optimizeCSS } from 'csso';
import { lazyLoadImages } from './lazy-load-images';
import { optimizeAssets } from './asset-optimizer';
import { applyTikTokSpecificFixes } from './tiktok-specific-fixes';

interface TikTokWebViewOptimizerOptions {
  minifyHTML?: boolean;
  minifyJS?: boolean;
  minifyCSS?: boolean;
  lazyLoadImages?: boolean;
  optimizeAssets?: boolean;
  applyCoreWebVitals?: boolean;
  applyTikTokFixes?: boolean;
  target?: 'android' | 'ios' | 'all';
}

export class TikTokWebViewOptimizer {
  private options: TikTokWebViewOptimizerOptions;
  
  constructor(options: TikTokWebViewOptimizerOptions = {}) {
    this.options = {
      minifyHTML: true,
      minifyJS: true,
      minifyCSS: true,
      lazyLoadImages: true,
      optimizeAssets: true,
      applyCoreWebVitals: true,
      applyTikTokFixes: true,
      target: 'all',
      ...options
    };
  }
  
  /**
   * Оптимизирует HTML для TikTok WebView
   */
  async optimize(html: string): Promise {
    // Парсинг HTML с помощью JSDOM
    const dom = new JSDOM(html);
    const document = dom.window.document;
    
    // Различные оптимизации...
    
    return optimizedHTML;
  }
  
  // Дополнительные методы...
}
        

// analytics-service.ts
import { AnalyticsEvent, PageVisit, UserInteraction, ConversionEvent } from './types';
import { MongoClient, Collection } from 'mongodb';
import { TikTokApiClient } from './tiktok-api-client';
import { PerformanceMetricsService } from './performance-metrics-service';

interface AnalyticsServiceConfig {
  mongoUri: string;
  tiktokApiClient: TikTokApiClient;
  performanceService: PerformanceMetricsService;
  database: string;
  realTimeEnabled: boolean;
}

export class AnalyticsService {
  private client: MongoClient;
  private tiktokApi: TikTokApiClient;
  private performanceService: PerformanceMetricsService;
  private config: AnalyticsServiceConfig;
  
  private pageVisits: Collection;
  private interactions: Collection;
  private conversions: Collection;
  
  private initialized: boolean = false;
  
  constructor(config: AnalyticsServiceConfig) {
    this.config = config;
    this.client = new MongoClient(config.mongoUri);
    this.tiktokApi = config.tiktokApiClient;
    this.performanceService = config.performanceService;
  }
  
  /**
   * Инициализирует сервис аналитики
   */
  async initialize(): Promise {
    if (this.initialized) {
      return;
    }
    
    try {
      // Подключение к MongoDB
      await this.client.connect();
      
      const db = this.client.db(this.config.database);
      
      // Инициализация коллекций
      this.pageVisits = db.collection('page_visits');
      this.interactions = db.collection('user_interactions');
      this.conversions = db.collection('conversions');
      
      // Создание индексов для эффективных запросов
      await this.createIndexes();
      
      this.initialized = true;
      console.log('Analytics service initialized successfully');
    } catch (error) {
      console.error('Failed to initialize analytics service:', error);
      throw error;
    }
  }
  
  // Другие методы...
}