is this because callbacks go into the callback queue ie. lower priority than the microtask queue ?

promises and mutation observer go into the microtask queue and have higher higher priority, are DOM mutations the "important tasks" that James is refering to ??

is this because promises go into the microtask queue ( higher priority than the callback queue ) ??

this is also applicable tor .catch() . since catch() is just a special case of .then() ie. .then(null , failure handler). Check the description of promise.catch in the "A Spoonful of Sugar" chapter.

```js document.createAnnotation()

document.getAnnotations(nodes)

document.removeAnnotation(annotation) ```

```js Annotation#addTarget(target)

Annotation#addBody(body) ```

Cache using fetch

Determine how to cache a resource by setting TTLs, custom cache keys, and cache headers in a fetch request.

```js async function handleRequest(request) { const url = new URL(request.url);

// Only use the path for the cache key, removing query strings // and always store using HTTPS, for example, https://www.example.com/file-uri-here const someCustomKey = https://${url.hostname}${url.pathname};

let response = await fetch(request, { cf: { // Always cache this fetch regardless of content type // for a max of 5 seconds before revalidating the resource cacheTtl: 5, cacheEverything: true, //Enterprise only feature, see Cache API for other plans cacheKey: someCustomKey, }, }); // Reconstruct the Response object to make its headers mutable. response = new Response(response.body, response);

// Set cache control headers to cache on browser for 25 minutes response.headers.set('Cache-Control', 'max-age=1500'); return response; }

addEventListener('fetch', event => { return event.respondWith(handleRequest(event.request)); }); ```

---

Caching HTML resources

Setting the cache level to Cache Everything will override the default cacheability of the asset. For time-to-live (TTL), Cloudflare will still rely on headers set by the origin.

js // Force Cloudflare to cache an asset fetch(event.request, { cf: { cacheEverything: true } });

``js let originalHTML =

Hello Mr. Wayne, decide what to do:

• Call Alfred
• Take Thalia Al Gul to the cinema
• Save Gotham

<span>Use the mouse to choose an option.</span> `;

let newHTML = `

Hello Batman, decide what to do:

• Kill The Joker
• Save Thalia Al Gul
• Save Gotham

<span>Use the batarang to choose an option.</span> `;

// Diff HTML strings let output = htmldiff(originalHTML, newHTML);

// Show HTML diff output as HTML (crazy right?)! document.getElementById("output").innerHTML = output; ```

```css ins { text-decoration: none; background-color: #d4fcbc; }

del { text-decoration: line-through; background-color: #fbb6c2; color: #555; } ```

Hire ReactJS Developers

```js

//If you write your own code, remember hex color shortcuts (eg., #fff, #000)

function hexToRgbA(hex){ var c; if(/^#([A-Fa-f0-9]{3}){1,2}$/.test(hex)){ c= hex.substring(1).split(''); if(c.length== 3){ c= [c[0], c[0], c[1], c[1], c[2], c[2]]; } c= '0x'+c.join(''); return 'rgba('+[(c>>16)&255, (c>>8)&255, c&255].join(',')+',1)'; } throw new Error('Bad Hex'); }

hexToRgbA('#fbafff')

/ returned value: (String) rgba(251,175,255,1) / ```

Records and Tuples break that convention, and allow us to compare by value. Deep comparisons of objects has been something that's been quite tricky in Javascript for a long time, but with Tuples and Records we can finally do that. As such, the following code returns true:

js console.log(#{ a: { b : 3 }} === #{ a: { b : 3 }}) // return true console.log(#[1, 2, 3] === #[1, 2, 3]) // returns true

Integrating AbortController

js export const Timeout = (time) => { let controller = new AbortController(); setTimeout(() => controller.abort(), time * 1000); return controller; }

```js import { useEffect, useState } from "react"; //imports goes here

export default function App() { //state goes here

//update useEffect(() => { fetch("https://jsonplaceholder.typicode.com/todos/1", { signal: Timeout(10).signal }) .then((resp) => resp.json()) .then((resp) => setData(resp)) .catch((err) => setError(true)); return () => {}; }, []); return ( <div> {* JSX goes here*} </div> ); } ```

2. Timeout a fetch() request

```js async function fetchWithTimeout(resource, options = {}) { const { timeout = 8000 } = options;

const controller = new AbortController(); const id = setTimeout(() => controller.abort(), timeout); const response = await fetch(resource, { ...options, signal: controller.signal<br /> }); clearTimeout(id); return response; }

async function loadGames() { try { const response = await fetchWithTimeout('/games', { timeout: 6000 }); const games = await response.json(); return games; } catch (error) { // Timeouts if the request takes // longer than 6 seconds console.log(error.name === 'AbortError'); } } ```

So Gitea—or Codeberg, at least—should be amenable to the suggestion of un-messing the process of self-hosting where it brings the aspiring self-hoster into contact with NodeJS/NPM silliness. Make that part optional.

Reacquiring a wake lock

The following code reacquires the wake lock should the visibility of the document change and the wake lock is released.

js document.addEventListener('visibilitychange', async () => { if (wakeLock !== null && document.visibilityState === 'visible') { wakeLock = await navigator.wakeLock.request('screen'); } });

https://output.jsbin.com/rifoyu

A note on setting worker-loader’s publicPath with webpack 5

Webpack 5 introduced a mechanism to detect the publicPath that should be used automatically

[...]

Webpack 5 exposes a global variable called __webpack_public_path__ that allows you to do that.

// Updates the `publicPath` at runtime, overriding whatever was set in the
// webpack's `output` section.
__webpack_public_path__ = "/workers/";

const myWorker = new Worker(
  new URL("/workers/worker.js");
);

// Eventually, restore the `publicPath` to whatever was set in output.
__webpack_public_path__ = "https://my-static-cdn/";

String.split() can also accept a regular expression:

input.split(/[ ,]+/);

b) rgb(), rgba(), hsl() and hsla():

^(rgb|hsl)(a?)[(]\s*([\d.]+\s*%?)\s*,\s*([\d.]+\s*%?)\s*,\s*([\d.]+\s*%?)\s*(?:,\s*([\d.]+)\s*)?[)]$

function parseLinkHeader( linkHeader ) {
   const linkHeadersArray = linkHeader.split( ", " ).map( header => header.split( "; " ) );
   const linkHeadersMap = linkHeadersArray.map( header => {
      const thisHeaderRel = header[1].replace( /"/g, "" ).replace( "rel=", "" );
      const thisHeaderUrl = header[0].slice( 1, -1 );
      return [ thisHeaderRel, thisHeaderUrl ]
   } );
   return Object.fromEntries( linkHeadersMap );
}

Web Workers

As of webpack 5, you can use Web Workers without worker-loader.

Syntax

new Worker(new URL('./worker.js', import.meta.url));

Instant Dates and Times

Temporal.Instant returns an object representing a date and time to the nearest nanosecond according to an ISO 8601 formatted string:

// main.js
const { RemoteReadableStream, RemoteWritableStream } = RemoteWebStreams;
(async () => {
  const worker = new Worker('./worker.js');
  // create a stream to send the input to the worker
  const { writable, readablePort } = new RemoteWritableStream();
  // create a stream to receive the output from the worker
  const { readable, writablePort } = new RemoteReadableStream();
  // transfer the other ends to the worker
  worker.postMessage({ readablePort, writablePort }, [readablePort, writablePort]);

  const response = await fetch('./some-data.txt');
  await response.body
    // send the downloaded data to the worker
    // and receive the results back
    .pipeThrough({ readable, writable })
    // show the results as they come in
    .pipeTo(new WritableStream({
      write(chunk) {
        const results = document.getElementById('results');
        results.appendChild(document.createTextNode(chunk)); // tadaa!
      }
    }));
})();

// worker.js
const { fromReadablePort, fromWritablePort } = RemoteWebStreams;
self.onmessage = async (event) => {
  // create the input and output streams from the transferred ports
  const { readablePort, writablePort } = event.data;
  const readable = fromReadablePort(readablePort);
  const writable = fromWritablePort(writablePort);

  // process data
  await readable
    .pipeThrough(new TransformStream({
      transform(chunk, controller) {
        controller.enqueue(process(chunk)); // do the actual work
      }
    }))
    .pipeTo(writable); // send the results back to main thread
};

Yes, why ?