How to use the @dbeining/react-atom.deref function in @dbeining/react-atom

export function readDataItem(ctx: Atom, key: string) {
  return deref(ctx).data[key];
}

function signOut(e) {
  const { userSession } = deref(contextAtom)
  const update = { userData: null,
                   signIn: signIn,
                   signOut: null,
                   person: null }
  setContext( update )
  userSession.signUserOut()
}

function useDirectAtom(atom: any, opts: any) {
  const state = deref(atom);
  const select = opts && opts.select;
  return isfunc(select) ? select(state) : state;
}

export function updateFeed(
  ctx: Atom,
  id: string,
  item: TItem,
  reducer: FeedReducer,
) {
  const feed = deref(ctx).feeds[id];
  const result = reducer(feed.data, item);

  if (result instanceof Promise) {
    return result
      .then(data => loadedFeed(ctx, id, data, undefined))
      .catch(error => loadedFeed(ctx, id, undefined, error));
  } else if (result !== feed.data) {
    loadedFeed(ctx, id, result, undefined);
  }
}

export function triggerSearch(ctx: Atom, query?: string, immediate = false): Disposable {
  const state = deref(ctx);
  const providers = state.registry.searchProviders;
  const { input, results } = state.search;
  const { loading } = results;

  if (query === undefined) {
    query = input;
  }

  if (input !== query || !loading) {
    const allProviders = Object.keys(providers);
    const providerKeys = allProviders.filter(m => !providers[m].onlyImmediate || immediate);
    const load = !!query && providerKeys.length > 0;
    resetSearchResults(ctx, query, load);

    if (load) {
      let searchCount = providerKeys.length;

function getLocalizer(ctx: Atom) {
  return deref(ctx).localizer;
}

getUser() {
        return deref(context.state).user;
      },
    };