vendor/codefog/contao-haste/library/Haste/Ajax/ReloadHelper.php line 33

Open in your IDE?
  1. <?php
  3. namespace Haste\Ajax;
  5. use Haste\Http\Response\JsonResponse;
  7. class ReloadHelper
  8. {
  9.     const TYPE_CONTENT = 'ce';
  10.     const TYPE_MODULE = 'fmd';
  12.     /**
  13.      * Listeners
  14.      * @var array
  15.      */
  16.     private static $listeners = [];
  18.     /**
  19.      * Response
  20.      * @var array
  21.      */
  22.     private static $response = [];
  24.     /**
  25.      * Subscribe the listener
  26.      *
  27.      * @param string $id
  28.      * @param array  $events
  29.      */
  30.     public static function subscribe($id, array $events)
  31.     {
  32.         foreach ($events as $event) {
  33.             if (!static::$listeners[$event] || !in_array($id, static::$listeners[$event], true)) {
  34.                 static::$listeners[$event][] = $id;
  35.             }
  36.         }
  37.     }
  39.     /**
  40.      * Store the response if applicable
  41.      *
  42.      * @param string $id
  43.      * @param string $event
  44.      * @param string $buffer
  45.      */
  46.     public static function storeResponse($id, $event, $buffer)
  47.     {
  48.         if (isset(static::$listeners[$event])
  49.             && !isset(static::$response[$id])
  50.             && in_array($id, static::$listeners[$event], true)
  51.         ) {
  52.             static::$response[$id] = $buffer;
  53.         }
  54.     }
  56.     /**
  57.      * Update the buffer
  58.      *
  59.      * @param string $id
  60.      * @param string $buffer
  61.      * @param bool   $isAjax
  62.      *
  63.      * @return string
  64.      */
  65.     public static function updateBuffer($id, $buffer, $isAjax = false)
  66.     {
  67.         $events = [];
  69.         foreach (static::$listeners as $event => $entries) {
  70.             if (in_array($id, $entries, true)) {
  71.                 $events[] = $event;
  72.             }
  73.         }
  75.         if (count($events) > 0) {
  76.             $buffer = static::addDataAttributes($buffer, $id, $events, $isAjax);
  77.         }
  79.         return $buffer;
  80.     }
  82.     /**
  83.      * Return true if there are listeners
  84.      *
  85.      * @return bool
  86.      */
  87.     public static function hasListeners()
  88.     {
  89.         return count(static::$listeners) > 0;
  90.     }
  92.     /**
  93.      * Get the response
  94.      *
  95.      * @return JsonResponse|null
  96.      */
  97.     public static function getResponse()
  98.     {
  99.         if (count(static::$response) < 1) {
  100.             return null;
  101.         }
  103.         $response = new JsonResponse(static::$response);
  104.         $response->setHeader('Vary', 'Accept');
  106.         return $response;
  107.     }
  109.     /**
  110.      * Return true if the listener is registered
  111.      *
  112.      * @param string $id
  113.      *
  114.      * @return bool
  115.      */
  116.     public static function isRegistered($id)
  117.     {
  118.         foreach (static::$listeners as $entries) {
  119.             if (in_array($id, $entries, true)) {
  120.                 return true;
  121.             }
  122.         }
  124.         return false;
  125.     }
  127.     /**
  128.      * Get the events
  129.      *
  130.      * @param string $id
  131.      *
  132.      * @return array
  133.      */
  134.     public static function getEvents($id)
  135.     {
  136.         $events = [];
  138.         foreach (static::$listeners as $event => $entries) {
  139.             if (in_array($id, $entries, true)) {
  140.                 $events[] = $event;
  141.             }
  142.         }
  144.         return array_unique($events);
  145.     }
  147.     /**
  148.      * Get the unique ID
  149.      *
  150.      * @param string $type
  151.      * @param int    $id
  152.      *
  153.      * @return string
  154.      */
  155.     public static function getUniqid($type, $id)
  156.     {
  157.         if (!in_array($type, [self::TYPE_CONTENT, self::TYPE_MODULE], true)) {
  158.             throw new \InvalidArgumentException(sprintf('The type "%s" is not supported', $type));
  159.         }
  161.         return $type.$id;
  162.     }
  164.     /**
  165.      * Add the data attributes
  166.      *
  167.      * @param string $buffer
  168.      * @param string $id
  169.      * @param array  $events
  170.      * @param bool   $isAjax
  171.      *
  172.      * @return string
  173.      */
  174.     private static function addDataAttributes($buffer, $id, array $events, $isAjax = false)
  175.     {
  176.         // Merge the data attributes if already present
  177.         preg_replace_callback(
  178.             '/\s?data-haste-ajax-id="[^"]*" data-haste-ajax-listeners="([^"]*)"/',
  179.             function ($matches) use (&$events) {
  180.                 $events = array_merge($events, trimsplit(' ', $matches[1]));
  182.                 return '';
  183.             },
  184.             $buffer
  185.         );
  187.         // Remove the HTML comments on AJAX request so they don't appear doubled in the DOM
  188.         if ($isAjax) {
  189.             $buffer = preg_replace('/<!--(.*)-->/', '', $buffer);
  190.         }
  192.         // Add the necessary attributes to the first wrapping element
  193.         $buffer = preg_replace(
  194.             '/<([^>!]+)>/',
  195.             sprintf(
  196.                 '<$1 data-haste-ajax-id="%s" data-haste-ajax-listeners="%s">',
  197.                 $id,
  198.                 implode(' ', array_unique($events))
  199.             ),
  200.             $buffer,
  201.             1
  202.         );
  204.         // Trim the buffer to avoid JS break
  205.         return trim($buffer);
  206.     }
  207. }