Silly Excessive Example of calling Synchronous function as async in javascript

readme.md

Example 2

🟠 fnSync => exit: 🚀 Sync before Async all()
🟢 fnAsync => enter: 🐒
🟠 fnSync => exit: 🐒
🟢 fnAsync => enter: 🐈
🟠 fnSync => exit: 🐈
🟠 fnSync => exit: 🚀 Sync after Async all(), "after" is read as in air quotes
'[ SyncResult: 🚀 Sync after Async all(), "after" is read as in air quotes ]'
resolveAfter: 1, 🙊 invoked early
resolveAfter: 300, 🙊
resolveAfter: 1200, 🙊 last to invoke
Final Results: 🙊 last to invoke,[ SyncResult: 🐒  ],🙊,[ SyncResult: 🐈 ],🙊 invoked early
🟠 fnSync => exit: 🐱‍🐉 manual sync after promise list, x = 🙊 last to invoke,[ SyncResult: 🐒  ],🙊,[ SyncResult: 🐈 ],🙊 invoked early
Promise.all() => end. x = [ SyncResult: 🐱‍🐉 manual sync after promise list, x = 🙊 last to invoke,[ SyncResult: 🐒  ],🙊,[ SyncResult: 🐈 ],🙊 invoked early ]

Example 1

fnSync => exit: 🚀 Sync before Async all()
fnSync => exit: 🐒
fnSync => exit: 🚀 Sync after Async all(), "after" is read as in air quotes
'📌 returned by fnSync: 🚀 Sync after Async all(), "after" is read as in air quotes'
resolveAfter: 10, SpeedyFirst
resolveAfter: 700, first1?
resolveAfter: 700, first2?
resolveAfter: 1200, SlowLast
Final Results: 📌 returned by fnSync: 🐒 ,SlowLast,first1?,first2?,SpeedyFirst
fnSync => exit: 🐱‍🐉 manual sync after promise list, x = 📌 returned by fnSync: 🐒 ,SlowLast,first1?,first2?,SpeedyFirst
Promise.all() => end. x = 📌 returned by fnSync: 🐱‍🐉 manual sync after promise list, x = 📌 returned by fnSync: 🐒 ,SlowLast,first1?,first2?,SpeedyFirst

SillySyncAsAsyncExample-2.js

function fnSync ( params ) {
    // some Sync function that returns something
    console.log( `🟠 fnSync => exit: ${ params }` )
    return `[ SyncResult: ${ params } ]` // renders nicer in the log than
    // return { syncResult: 'didStuff', params: params }
}
function fnAsync ( params ) {
    // now it's async
    return new Promise( ( resolve ) => {
        console.log( `🟢 fnAsync => enter: ${ params }` )
        resolve( fnSync( params ) )
    } )
}
function asyncDelay ( params, delay ) {
    delay ??= 700
    return new Promise( ( resolve ) => {
        setTimeout( () => {
            console.log( `resolveAfter: ${ delay ?? '' }, ${ params ?? '' }` )
            resolve( params )
        }, delay )
    } )
}
fnSync( '🚀 Sync before Async all() ' )

stuff = [
    asyncDelay( `🙊 last to invoke`, 1200 ),
    fnAsync( '🐒 ' ),
    asyncDelay( `🙊`, 300 ),
    fnAsync( '🐈' ),
    asyncDelay( `🙊 invoked early`, 1 ),
]
Promise.all( stuff )
    .then( ( x ) => {
        console.log( `Final Results: ${ x }` )
        return fnSync( `🐱‍🐉 manual sync after promise list, x = ${ x }` )
        //return fnAsync( `🐱‍🐉 manual async after promise list, x = ${ x }` )
    } )
    .then( ( x ) => console.log( `Promise.all() => end. x = ${ x }` ) )

fnSync( '🚀 Sync after Async all(), "after" is read as in air quotes' )

SillySyncAsAsyncExample-3.js

function fnSync ( params ) {
  // some Sync function that returns something
  console.log( `fnSync => exit: ${ params }` )
  return `SyncResult: ${ params }` //   return { syncResult: 'didStuff', params: params } 
}
function fnAsync ( params ) {
   // now it's async
   return new Promise( (resolve) => {
       resolve( fnSync( params ) )
   })  
}

fnSync( '🚀 Sync before Async all() ' )

stuff = [ fnAsync( '🐒 '), fnAsync( '🐈' ) ]
Promise.all( stuff ) 
  .then( (x) => {
    console.log( `Accumulated Responses: ${ x }` ) 
    return fnSync( `🐱‍🐉 manual sync after promise list, x = ${ x }`)
    //return fnAsync( `🐱‍🐉 manual async after promise list, x = ${ x }` ) 
  })
  .then( (x) => console.log( `Promise.all() => end. x = ${ x }` ) )

fnSync( '🚀 Sync after Async all(), "after" is read as in air quotes' )

SillySyncAsAsyncExample.js

function fnSync ( params ) {
  // some random Sync function
  // console.log( `fnSync => enter: ${ params }` )  
  // ...
  console.log( `fnSync => exit: ${ params }` )
  return `📌 returned by fnSync: ${ params }`
}

function fnAsync ( params ) {
   return new Promise( (resolve) => {
       resolve( fnSync( params ) )
   })  
}
function resolveAfter( params, delay ) {
  delay ??= 700
  return new Promise((resolve) => {
    setTimeout(() => {
      console.log( `resolveAfter: ${ delay ?? '' }, ${ params ?? '' }` )
      resolve( params );
    }, delay );
  });
}

fnSync( '🚀 Sync before Async all() ' )
stuff = [
  fnAsync( '🐒 '),
  resolveAfter( 'SlowLast', 1200 ),
  resolveAfter( 'first1?' ),
  resolveAfter( 'first2?' ),  
  resolveAfter( 'SpeedyFirst', 10 ),
]

Promise.all( stuff )
  .then( (x) => {
    console.log( `Final Results: ${ x }` ) 
    return fnSync( `🐱‍🐉 manual sync after promise list, x = ${ x }`)
    //return fnAsync( `🐱‍🐉 manual async after promise list, x = ${ x }` ) 
  })
  .then( (x) => console.log( `Promise.all() => end. x = ${ x }` ) )

fnSync( '🚀 Sync after Async all(), "after" is read as in air quotes' )