Function makeRouteWithContents

extension/background.js:122–180

(getData, setData)

  }

  const makeRouteWithContents = (getData, setData) => ({
    // getData: (req: Request U Vars) -> Promise<contentsOfFile: String|Uint8Array>
    // setData [optional]: (req: Request U Vars, newContentsOfFile: String) -> Promise<>

    // You can override file operations (like `truncate` or `getattr`)
    // in the returned set if you want different behavior from what's
    // defined here.

    async getattr(req) {
      const data = await getData(req);
      if (typeof data === 'undefined') { throw new UnixError(unix.ENOENT); }
      return {
        st_mode: unix.S_IFREG | 0444 | (setData ? 0222 : 0),
        st_nlink: 1,
        // you'll want to override this if getData() is slow, because
        // getattr() gets called a lot more cavalierly than open().
        st_size: toUtf8Array(data).length
      };
    },

    // We call getData() once when the file is opened, then cache that
    // data for all subsequent reads from that application.
    async open(req) {
      const data = await getData(req);
      if (typeof data === 'undefined') { throw new UnixError(unix.ENOENT); }
      return { fh: Cache.storeObject(req.path, toUtf8Array(data)) };
    },
    async read({fh, size, offset}) {
      return { buf: Cache.getObjectForHandle(fh).slice(offset, offset + size) };
    },
    async write(req) {
      const {fh, offset, buf} = req;
      let arr = Cache.getObjectForHandle(fh);
      const bufarr = stringToUtf8Array(buf);
      if (offset + bufarr.length > arr.length) {
        const newArr = new Uint8Array(offset + bufarr.length);
        newArr.set(arr.slice(0, Math.min(offset, arr.length)));
        arr = newArr;
        Cache.setObjectForHandle(fh, arr);
      }
      arr.set(bufarr, offset);
      // I guess caller should override write() if they want to actually
      // patch and not just re-set the whole string (for example,
      // if they want to hot-reload just one function the user modified)
      await setData(req, utf8ArrayToString(arr)); return { size: bufarr.length };
    },
    async release({fh}) { Cache.removeObjectForHandle(fh); return {}; },

    async truncate(req) {
      let arr = toUtf8Array(await getData(req));
      if (req.size !== arr.length) {
        const newArr = new Uint8Array(req.size);
        newArr.set(arr.slice(0, Math.min(req.size, arr.length)));
        arr = newArr;
      }
      Cache.setObjectForPath(req.path, arr);
      await setData(req, utf8ArrayToString(arr)); return {};
    }