JavaScript

export function updateAnyTypeInvoiceInvoiceRecordMutationObservable(classCode, catalogId, invRecordId, jsonData, data) {

        const observer = new MutationObserver(mutationsList => {
            for (const mutation of mutationsList) {

                // Text content within one of the observed nodes has changed
                // You can respond to the change here
                console.log('Text content has changed:', mutation.target.textContent);

                Code that adds up all the invoice cost, and changes the total at the bottom

                // get a list of unprocessed mutations
                // should be called before disconnecting,
                // if you care about possibly unhandled recent mutations
                let mutationRecords = observer.takeRecords();
                console.log(mutationRecords);

                // After a reasonable time, disconnect the observer even if the element wasn't found
                observer.disconnect();

            }
        });

        // Specify the options for the observer
        const config = { childList: true, subtree: true, characterData: true };
        const targetNode = document.getElementById('invInvoiceAmount_' + classCode + '_' + invRecordId);<br />
        observer.observe(targetNode, config);

        Javascript that changes the invoice values called last

    } catch (error) {
        console.log('updateAnyTypeInvoiceInvoiceRecordMutationObservable Error', error);
        alert('updateAnyTypeInvoiceInvoiceRecordMutationObservable Error: ' + error);
    }
}

jkirkerx wrote:

I concluded that I need to create the observer first, populate that observer with code to update the totals posted at the bottom, and then run the code to change the invoice.

Tammy Gombez wrote:

I'm currently facing a perplexing issue

Maximilien wrote:

I tried adding an await before the call to getFilmName and give does not "compile" :

async function blah() {
  try {
    // protocol in URL removed because of syntax coloring bug
    const response = await fetch('blah.com');
    return await response.json();
  } catch(ex) {
    console.error(ex);
  }
}

// if you call blah synchronously, it will not work
blah(); // problem

// call it from another async routine, thenable promise, or an async IIFE
(async () => {
  await blah(); // works
})();

async function getPeople() {
    console.log("fetchNames");
    const url = "https://swapi.dev/api/people";
    const res = await fetch(url);
    const data = await res.json();
    console.log(data);
    
    const results = data.results;
    
    const promises = results.map(async (person) => {
        const filmPromises = person.films.map(getFilmName);
        const films = await Promise.all(filmPromises);
        return { person, films };
    });
    
    return await Promise.all(promises);
}

(async () => {
    const people = await getPeople();
    people.forEach(person => {
        console.log(`${person.person.name} stars in :`);
        person.films.forEach(filmName => console.log(filmName));
    });
})();

// this level needs a promise.all too
results.map(async person => {
  // loop all films for each person
  await Promise.all(arr.map(async filmURL => {
    const filmName = await getFilmName(filmURL);
  }));
};

for await (const filmName of getFilmNames()) {
  // so fancy and clean
}

(async () => {
    const response = await fetch("http://localhost:4000/features");
    if (!response.ok) {
        alert("Error loading the feature list.");
        return;
    }
    
    const { features } = await response.json();
    const specificFeature = features.find(f => f.properties.id === 1);
    if (!specificFeature) {
        alert("Feature 1 was not found.");
        return;
    }
    
    // Do something with the feature here...
})();

{
    "items": [{
            "id": 1
        },
        {
            "id": 2
        },
        {
            "id": 2
        }
    ]
}

{
    "items": [{
            "properties":{
            "id": 1
        }

        },
        {
            "properties":{
                "id": 2
            }
            },
        {
            "properties":{
                "id": 3
            }
            }
    ]
}

Member 15940361 wrote:

Write a function which takes a positive number as input and returns true if it has no prime factor larger than 5

const doStuff = input => {
  // something cool should be done with the input
  return (has no prime factor larger than 5);
};