עדכוני Service Worker בפרונטאנד: שליטה בסנכרון ברקע

            if ('serviceWorker' in navigator) {
  navigator.serviceWorker.register('/sw.js')
    .then(function(registration) {
      console.log('Service Worker registered with scope:', registration.scope);
    })
    .catch(function(err) {
      console.error('Service Worker registration failed:', err);
    });
}

            

              
                Copy
              
            
          

            // sw.js

const CACHE_NAME = 'my-app-cache-v1';
const urlsToCache = [
  '/',
  '/index.html',
  '/styles.css',
  '/app.js'
];

// --- Installation ---
self.addEventListener('install', event => {
  // Perform install steps
  event.waitUntil(
    caches.open(CACHE_NAME)
      .then(function(cache) {
        console.log('Opened cache');
        return cache.addAll(urlsToCache);
      })
  );
});

// --- Activation ---
self.addEventListener('activate', event => {
  const cacheWhitelist = [CACHE_NAME];
  event.waitUntil(
    caches.keys().then(cacheNames => {
      return Promise.all(
        cacheNames.map(cacheName => {
          if (cacheWhitelist.indexOf(cacheName) === -1) {
            return caches.delete(cacheName);
          }
        })
      );
    })
  );
});

// --- Fetch Handling (for caching) ---
self.addEventListener('fetch', event => {
  event.respondWith(
    caches.match(event.request)
      .then(response => {
        // Cache hit. Return response
        if (response) {
          return response;
        }
        // Not in cache, fetch from network
        return fetch(event.request).then(
          response => {
            // Check if we received a valid response
            if(!response || response.status !== 200 || response.type !== 'basic') {
              return response;
            }

            // Clone the response to store in cache and return it
            const responseToCache = response.clone();

            caches.open(CACHE_NAME)
              .then(cache => {
                cache.put(event.request, responseToCache);
              });

            return response;
          }
        );
      })
  );
});

// --- Background Sync: Handling Outgoing Requests ---

// Store outgoing requests in IndexedDB
async function storeRequest(request) {
  const db = await openDatabase();
  const tx = db.transaction('requests', 'readwrite');
  const store = tx.objectStore('requests');
  store.add({
    url: request.url,
    method: request.method,
    headers: Object.fromEntries(request.headers),
    body: await request.text(), // This consumes the request body, ensure it's done only once
    timestamp: Date.now()
  });
  await tx.complete; // Wait for the transaction to finish
}

// Open IndexedDB
function openDatabase() {
  return new Promise((resolve, reject) => {
    const indexedDBOpenRequest = indexedDB.open('sync-db', 1);

    indexedDBOpenRequest.onupgradeneeded = function() {
      const db = indexedDBOpenRequest.result;
      db.createObjectStore('requests', { keyPath: 'id', autoIncrement: true });
    };

    indexedDBOpenRequest.onsuccess = function() {
      resolve(indexedDBOpenRequest.result);
    };

    indexedDBOpenRequest.onerror = function(event) {
      reject('Error opening IndexedDB: ' + event.target.error);
    };
  });
}

// Process queued requests
async function processQueue() {
  const db = await openDatabase();
  const tx = db.transaction('requests', 'readonly');
  const store = tx.objectStore('requests');
  const cursor = store.openCursor();
  let requestsProcessed = 0;

  cursor.onsuccess = async (event) => {
    const cursor = event.target.result;
    if (cursor) {
      const requestData = cursor.value;
      
      // Reconstruct the request object
      const reconstructedRequest = new Request(requestData.url, {
        method: requestData.method,
        headers: new Headers(requestData.headers),
        body: requestData.body,
        mode: 'cors' // or 'no-cors' if applicable
      });

      try {
        const response = await fetch(reconstructedRequest);
        if (response.ok) {
          console.log(`Successfully synced: ${requestData.url}`);
          // Remove from queue on success
          const deleteTx = db.transaction('requests', 'readwrite');
          deleteTx.objectStore('requests').delete(requestData.id);
          await deleteTx.complete;
          requestsProcessed++;
        } else {
          console.error(`Failed to sync ${requestData.url}: ${response.status}`);
          // Optionally, re-queue or mark as failed
        }
      } catch (error) {
        console.error(`Network error during sync for ${requestData.url}:`, error);
        // Re-queue if it's a network error
      }
      cursor.continue(); // Move to the next item in the cursor
    }
  };

  cursor.onerror = (event) => {
    console.error('Error iterating through requests:', event.target.error);
  };
}

// Handle Sync Event
self.addEventListener('sync', event => {
  if (event.tag === 'send-message') { // Tag for sending user messages
    console.log('Sync event triggered for "send-message"');
    event.waitUntil(processQueue());
  }
  // Handle other sync tags if you have them
});

// Modify fetch to queue failed requests
self.addEventListener('fetch', event => {
  if (event.request.method === 'POST' || event.request.method === 'PUT' || event.request.method === 'DELETE') {
    // For methods that might modify data, try to fetch first
    event.respondWith(
      fetch(event.request).catch(async error => {
        console.error('Fetch failed, queuing request:', error);
        // Check if the request was already consumed (e.g., by a prior body read)
        let requestToStore = event.request;
        // For POST/PUT requests with a body, the body might be consumed. 
        // A more robust solution would clone the body or use a technique to re-read it if available.
        // For simplicity, let's assume we have the original request data.

        // Ensure the request body is available for storage if it's a POST/PUT.
        // This is a common challenge: a request body can only be consumed once.
        // A robust pattern involves cloning the request or ensuring the body is processed before this point.
        
        // A more robust approach for POST/PUT would be to intercept the request *before* it's made
        // and decide whether to queue it or send it. Here, we're reacting to a failure.
        
        // For demonstration, we'll assume we can get the body again or that it's not critical to store for GET requests.
        // For actual implementation, consider a different pattern for handling request bodies.
        
        // If it's a request we want to queue (e.g., data submission)
        if (event.request.method === 'POST' || event.request.method === 'PUT') {
          await storeRequest(event.request);
          // Register for background sync if not already
          // This registration should happen only once or be managed carefully.
          // A common pattern is to register on the first failure.
          return navigator.serviceWorker.ready.then(registration => {
            return registration.sync.register('send-message');
          }).then(() => {
            console.log('Background sync registered.');
            // Return a placeholder response or a message indicating the task is queued
            return new Response('Queued for background sync', { status: 202 });
          }).catch(err => {
            console.error('Failed to register sync:', err);
            return new Response('Failed to queue sync', { status: 500 });
          });
        }

        return new Response('Network error', { status: 503 });
      })
    );
  } else {
    // For other requests (GET, etc.), use standard caching strategy
    event.respondWith(
      caches.match(event.request)
        .then(response => {
          if (response) {
            return response;
          }
          return fetch(event.request);
        })
    );
  }
});

// --- Periodic Background Sync (Experimental) ---
// Requires specific registration and listener
// Example: Registering for periodic sync
/*
navigator.serviceWorker.ready.then(registration => {
  return registration.periodicSync.register('daily-content-update', {
    minInterval: 60 * 60 * 1000 // 1 hour
  });
}).then(() => console.log('Periodic sync registered'))
.catch(err => console.error('Periodic sync registration failed', err));
*/

// Listener for periodic sync event
/*
self.addEventListener('periodicsync', event => {
  if (event.tag === 'daily-content-update') {
    console.log('Periodic sync triggered for "daily-content-update"');
    event.waitUntil(
      // Fetch latest content and update cache
      fetch('/api/latest-content').then(response => response.json())
      .then(data => {
        // Update cache with new content
        console.log('Fetched new content:', data);
      })
    );
  }
});
*/

// --- Handling Re-hydration of Request Bodies (Advanced) ---
// If you need to reliably store and re-process request bodies (especially for POST/PUT),
// you'll need a more sophisticated approach. One common pattern is to clone the request
// before the initial fetch attempt, store the cloned request data, and then perform the fetch.
// For simplicity in this example, we are using `await request.text()` in `storeRequest`, 
// which consumes the body. This works if `storeRequest` is called only once before the fetch is attempted.
// If `fetch` fails, the body is already consumed. A better approach:

/*
self.addEventListener('fetch', event => {
  if (event.request.method === 'POST' || event.request.method === 'PUT') {
    event.respondWith(
      fetch(event.request).catch(async error => {
        console.error('Fetch failed, preparing to queue request:', error);
        
        // Clone the request to store its data without consuming the original for fetch
        const clonedRequest = event.request.clone();
        const requestData = {
          url: clonedRequest.url,
          method: clonedRequest.method,
          headers: Object.fromEntries(clonedRequest.headers),
          body: await clonedRequest.text(), // Consume the clone's body
          timestamp: Date.now()
        };

        const db = await openDatabase(); // Assume openDatabase is defined as above
        const tx = db.transaction('requests', 'readwrite');
        const store = tx.objectStore('requests');
        store.add(requestData);
        await tx.complete;
        console.log('Request queued in IndexedDB.');

        // Register for background sync
        return navigator.serviceWorker.ready.then(registration => {
          return registration.sync.register('send-message');
        }).then(() => {
          console.log('Background sync registered.');
          return new Response('Queued for background sync', { status: 202 });
        }).catch(err => {
          console.error('Failed to register sync:', err);
          return new Response('Failed to queue sync', { status: 500 });
        });
      })
    );
  } else {
    // Standard fetch for other methods
    event.respondWith(fetch(event.request));
  }
});
*/

            

              
                Copy
              
            
          

            // In your main app.js or similar file

async function submitFormData() {
  const response = await fetch('/api/submit-data', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ /* your data */ })
  });

  if (!response.ok) {
    console.error('Failed to submit data. Attempting background sync.');
    
    // Save data locally (e.g., in IndexedDB) if not already handled by SW fetch intercept
    // await saveLocalData({ /* your data */ }, 'submit-data');
    
    // Register the sync task
    navigator.serviceWorker.ready.then(registration => {
      return registration.sync.register('send-message'); // Use the same tag as in SW
    }).then(() => {
      console.log('Background sync task registered successfully.');
      // Inform user that data will be sent when online
      alert('Your data has been queued and will be sent when you are back online.');
    }).catch(err => {
      console.error('Error registering background sync:', err);
      // Inform user about potential data loss or failure
      alert('Could not queue your data. Please try again later.');
    });
  } else {
    console.log('Data submitted successfully!');
    // Handle successful submission
  }
}

            

              
                Copy