Isomorphic Git

// initially, because it's on every change 
// a commit will mostly be for a single
// file at a time the immediate exception 
// being when a file with output files 
// is edited, in which case the commit 
// includes those files.

export const fn = async () => {
  const now = (new Date()).toISOString()

  const fs = lit.lfs 
  const dir = lit.location.root
  const git = lit.git
  const FILE = 0, WORKDIR = 2, STAGE = 3

  const unstaged = row => {
    return row[WORKDIR] !== row[STAGE]
  }

  // get/list unstaged files
  const status = await git.statusMatrix({ fs,dir})
  const files = status
                .filter( unstaged )
                .map(row => row[FILE])

  // stage everything
  await git.add({fs, dir, filepath: '.'})

  // message 
  const message = `Commit ${lit.location.src}

at ${now} includes the following ${files.length} files:
${files.map(f=> "- " + f).join('\n')}`

  // return message

  // commit
  const sha = await git.commit({fs, dir,
    message,
    author: {
      name: 'dotlitbot',
      email: 'bot@dotlit.org'
    }
  })
  return `Committed ${sha.slice(0,6)} 
${message}`
}

export const menu = (ctx, {React, Menu}) => {
  const rc = React.createElement
  const commit = lit.file.data.plugins.fn['git-commit-all']
  const onClick = async ev => alert(await commit())
  return rc( Menu, {
    title:"Git",
    disabled: false,
  }, [rc('span', {onClick}, 'Commit All')])
}

export const proxy = async (returnEndpoint) => {
  const setup = (resolve, reject) => {
    if (typeof lit === "undefined") reject("No lit");
    else if (!window.__runkitCORSProxyEnpoint) {
      (async (fn) => {
        const rkEmbed = document.createElement("script");
        rkEmbed.onload = async (fn) => {
          const el = document.createElement("div");
          document.body.appendChild(el);
          el.setAttribute("style", "height:0;");
          RunKit.createNotebook({
            element: el,
            mode: "endpoint",
            onLoad: async (rk) => {
              const endpoint = await rk.getEndpointURL();
              window.__runkitCORSProxyEnpoint = endpoint;
              document.body.removeChild(el);
            },
            evaluateOnLoad: true,
            source: await lit.fs.readFile(
              "/testing/runkit-express-cors-proxy.js",
              {
                encoding: "utf8",
              }
            ),
          });
        };
        rkEmbed.setAttribute("src", "https://embed.runkit.com");
        document.body.appendChild(rkEmbed);
      })();
    } else {
      resolve(window.__runkitCORSProxyEnpoint);
    }
  };

  const endpoint = await new Promise(setup).then((e) => e);
  if (false && !window.__runkitCORSProxyEnpoint) {
    return "Still setting up proxy endpoint";
  } else {
    if (returnEndpoint) return endpoint;

    const getAndReplaceDomain = (originalUrl, newDomain) => {
      return newDomain + originalUrl.replace(/^https?:\/\//, "/");
    };

    const proxyFetch = async (url, opts = {}) => {
      const proxyUrl = getAndReplaceDomain(url, endpoint);
      return fetch(proxyUrl, opts);
    };

    return proxyFetch;
  }
};