malice

export interface AvatarCache {

  match(key: string): Promise<Response | undefined>;

  put(key: string, response: Response): Promise<void>;

}

export function createAvatarLoader(

  cache: () => Promise<AvatarCache>,

  load: (query: string) => Promise<Response>

): (key: string, query: string) => Promise<Response> {

  const pending = new Map<string, Promise<Response>>();

  return async (key, query) => {

    const active = pending.get(key);

    if (active) return (await active).clone();

    const request = (async () => {

      let store: AvatarCache | null = null;

      try {

        store = await cache();

        const cached = await store.match(key);

        if (cached) return cached;

      } catch {

        store = null;

      }

      const response = await load(query);

      if (response.ok && store) {

        try {

          await store.put(key, response.clone());

        } catch {

          return response;

        }

      }

      return response;

    })();

    pending.set(key, request);

    try {

      return (await request).clone();

    } finally {

      if (pending.get(key) === request) pending.delete(key);

    }

  };

}