How to use solid-auth-client - 10 common examples

export function checkUser (
  setUserCallback?: (me: $rdf.NamedNode | null) => T
): Promise<$rdf.NamedNode | T> {
  // Check to see if already logged in / have the WebID
  const me = defaultTestUser()
  if (me) {
    return Promise.resolve(setUserCallback ? setUserCallback(me) : me)
  }

  // doc = kb.any(doc, ns.link('userMirror')) || doc

  return solidAuthClient
    .currentSession()
    .then(webIdFromSession)
    .catch(err => {
      console.log('Error fetching currentSession:', err)
    })
    .then(webId => {
      // if (webId.startsWith('dns:')) {  // legacy rww.io pseudo-users
      //   webId = null
      // }
      const me = saveUser(webId)

      if (me) {
        console.log(`(Logged in as ${me} by authentication)`)
      }

      return setUserCallback ? setUserCallback(me) : me

const next = async () => {
      if (done)
        return { done };
      done = true;

      // Find the document to update
      const sources = await (source ? this.toComunicaSources(source) : this._sources);
      if (!sources || sources.length !== 1)
        throw new Error('Can only update a single source.');
      const [{ value: document }] = sources;
      if (!/^https?:\/\//.test(document))
        throw new Error('Can only update an HTTP(s) document.');

      // Send authenticated PATCH request to the document
      const { ok, status, statusText } = await auth.fetch(document, {
        method: 'PATCH',
        headers: {
          'Content-Type': 'application/sparql-update',
        },
        body: sparql,
      });

      // Error if the server response was not ok
      if (!ok)
        throw new Error(`Update query failed (${status}): ${statusText}`);

      // Clear stale cached versions of the document
      await this.clearCache(document);

      return { value: createBindings({ ok }) };
    };

signInPopUpButton.addEventListener('click', () => {
    const offline = offlineTestID()
    if (offline) return setUserCallback(offline.uri)
    return solidAuthClient.popupLogin().then(session => {
      const webIdURI = session.webId
      // setUserCallback(webIdURI)
      const divs = dom.getElementsByClassName(magicClassName)
      console.log(`Logged in, ${divs.length} panels to be serviced`)
      // At the same time, satisfy all the other login boxes
      for (let i = 0; i < divs.length; i++) {
        const div: any = divs[i]
        // @@ TODO Remove the need to manipulate HTML elements
        if (div.setUserCallback) {
          try {
            div.setUserCallback(webIdURI)
            const parent = div.parentNode
            if (parent) {
              parent.removeChild(div)
            }
          } catch (e) {

fetch: async function(url,request){
    var res = await solid.fetch(url,request).catch(err => {
       this.err = err; return false 
    })
    if(!res.ok) { 
        this.err = res.status + " ("+res.statusText+")"
        return false 
    }
    var txt = await res.text().catch(err => {
       this.err = err; return false 
    })
    return({value:txt})
},
/* SESSION MANAGEMENT

function getResourceOptions (url, options = {}) {
  var _fetch = Config.User.OIDC? solidAuth.fetch : fetch;
  url = url || currentLocation()

  options.method = 'OPTIONS'

  if (!options.noCredentials) {
    options.credentials = 'include'
  }

  return _fetch(url, options)

    .then(response => {
      if (!response.ok) {  // not a 2xx level response
        let error = new Error('Error fetching resource OPTIONS: ' +
          response.status + ' ' + response.statusText)
        error.status = response.status
        error.response = response

function logoutButtonHandler (_event) {
    // UI.preferences.set('me', '')
    solidAuthClient.logout().then(
      function () {
        const message = `Your WebID was ${me}. It has been forgotten.`
        me = null
        try {
          log.alert(message)
        } catch (e) {
          window.alert(message)
        }
        box.refresh()
        if (listener) listener(null)
      },
      err => {
        alert('Fail to log out:' + err)
      }
    )
  }

if (me) {
            box.appendChild(logoutButton(me, options))
          } else {
            box.appendChild(signInOrSignUpBox(dom, setIt, options))
          }
        }
        box.me = me ? me.uri : null
      },
      err => {
        alert(`loginStatusBox: ${err}`)
      }
    )
  }

  if (solidAuthClient.trackSession) {
    solidAuthClient.trackSession(session => {
      if (session && session.webId) {
        me = $rdf.sym(session.webId)
      } else {
        me = null
      }
      box.refresh()
    })
  }

  box.me = '99999' // Force refresh
  box.refresh()
  return box
}

*/
export default function useWebId(reducer = getWebId) {
  const [result, updateWebId] = useReducer(reducer, webId, reducer);
  useDebugValue(webId);

  useEffect(() => {
    updateWebId(webId);
    subscribers.add(updateWebId);
    return () => subscribers.delete(updateWebId);
  }, []);

  return result;
}

// Inform subscribers when the WebID changes
auth.trackSession(session => {
  webId = session ? session.webId : null;
  for (const subscriber of subscribers)
    subscriber(webId);
});

return;

  // Invalidate the cache for the resource
  const url = match[1];
  ldflex.clearCache(url);

  // Notify the subscribers
  const update = { timestamp: new Date(), url };
  for (const subscriber of subscribers[url] || [])
    subscriber(update);
  for (const subscriber of subscribers[ALL] || [])
    subscriber(update);
}

// Keep track of all fetched resources
auth.on('request', url => {
  if (!fetchedUrls.has(url)) {
    if (ALL in subscribers)
      trackResource(url);
    fetchedUrls.add(url);
  }
});

fetchAndParse: async function(url,contentType){
    contentType = contentType || this.guessFileType(url)
    var res = await solid.fetch(url).catch(err=>{
        this.err=err; console.log(err); return false;
    })
    if(!res.ok) { 
        this.err = res.status + " ("+res.statusText+")"
        return false 
    }
    if( contentType==='application/json' ){
        var obj = await res.json().catch(err=>{this.err=err; return false })
        return (obj)
    }
    var txt = await res.text().catch(err=>{this.err=err; return false })
    return this.text2graph(txt,url,contentType)
},
text2graph: function(text,url,contentType){