text: /*
   * Quick-n-dirty algebraic datatypes.
   *
   * These let us handle the possibility of failure without having to constantly write code to check for it.
   * We can apply all of the transformations we need as if the data is present using `map`.
   * If there's a None, or a FetchError, or a Pending, those are left untouched.
   *
   * I've used perhaps an odd bit of terminology from scalaz in `fold`.  This is basically a `switch` statement:
   * You pass it a set of functions to handle the various different states of the datatype, and if it finds the
   * function it'll call it on its value.
   *
   * It's handy to have this in functional style when dealing with React as we can dispatch different ways of rendering
   * really simply:
   * ```
   * bundleFetchStatus.fold({
   *     some: (fetchStatus) => <ProgressBar fetchsStatus={fetchStatus} />,
   * }),
   * ```
   */
  
  
  class Optional {
      static from(value) {
          return value && Some.of(value) || None;
      }
      map(f) {
          return this;
      }
      flatMap(f) {
          return this;
      }
      fold({ none }) {
          return none && none();
      }
  }
  class Some extends Optional {
      constructor(value) {
          super();
          this.value = value;
      }
      map(f) {
          return Some.of(f(this.value));
      }
      flatMap(f) {
          return f(this.value);
      }
      fold({ some }) {
          return some && some(this.value);
      }
      static of(value) {
          return new Some(value);
      }
  }
  const None = new Optional();
  
  class FetchStatus {
      constructor(opt = {}) {
          this.opt = { at: Date.now(), ...opt };
      }
      map(f) {
          return this;
      }
      flatMap(f) {
          return this;
      }
  }
  class Success extends FetchStatus {
      static of(value) {
          return new Success(value);
      }
      constructor(value, opt) {
          super(opt);
          this.value = value;
      }
      map(f) {
          return new Success(f(this.value), this.opt);
      }
      flatMap(f) {
          return f(this.value, this.opt);
      }
      fold({ success }) {
          return success instanceof Function ? success(this.value, this.opt) : undefined;
      }
  }
  class Pending extends FetchStatus {
      static of(opt) {
          return new Pending(opt);
      }
      constructor(opt) {
          super(opt);
      }
      fold({ pending }) {
          return pending instanceof Function ? pending(this.opt) : undefined;
      }
  }
  class FetchError extends FetchStatus {
      static of(reason, opt) {
          return new FetchError(reason, opt);
      }
      constructor(reason, opt) {
          super(opt);
          this.reason = reason;
      }
      fold({ error }) {
          return error instanceof Function ? error(this.reason, this.opt) : undefined;
      }
  }
  