Moving everything into a single repo and build

webapp/syscalls/db.localstorage.ts

@@ -0,0 +1,8 @@
+export default {
+  "db.put": (key: string, value: any) => {
+    localStorage.setItem(key, value);
+  },
+  "db.get": (key: string) => {
+    return localStorage.getItem(key);
+  },
+};

webapp/syscalls/editor.browser.ts

@@ -0,0 +1,133 @@
+import { Editor } from "../editor";
+import { syntaxTree } from "@codemirror/language";
+import { Transaction } from "@codemirror/state";
+import { PageMeta } from "../types";
+
+type SyntaxNode = {
+  name: string;
+  text: string;
+  from: number;
+  to: number;
+};
+
+function ensureAnchor(expr: any, start: boolean) {
+  var _a;
+  let { source } = expr;
+  let addStart = start && source[0] != "^",
+    addEnd = source[source.length - 1] != "$";
+  if (!addStart && !addEnd) return expr;
+  return new RegExp(
+    `${addStart ? "^" : ""}(?:${source})${addEnd ? "$" : ""}`,
+    (_a = expr.flags) !== null && _a !== void 0
+      ? _a
+      : expr.ignoreCase
+      ? "i"
+      : ""
+  );
+}
+
+export default (editor: Editor) => ({
+  "editor.getCurrentPage": (): string => {
+    return editor.currentPage!;
+  },
+  "editor.getText": () => {
+    return editor.editorView?.state.sliceDoc();
+  },
+  "editor.getCursor": (): number => {
+    return editor.editorView!.state.selection.main.from;
+  },
+  "editor.navigate": async (name: string) => {
+    await editor.navigate(name);
+  },
+  "editor.openUrl": async (url: string) => {
+    window.open(url, "_blank")!.focus();
+  },
+  "editor.insertAtPos": (text: string, pos: number) => {
+    editor.editorView!.dispatch({
+      changes: {
+        insert: text,
+        from: pos,
+      },
+    });
+  },
+  "editor.replaceRange": (from: number, to: number, text: string) => {
+    editor.editorView!.dispatch({
+      changes: {
+        insert: text,
+        from: from,
+        to: to,
+      },
+    });
+  },
+  "editor.moveCursor": (pos: number) => {
+    editor.editorView!.dispatch({
+      selection: {
+        anchor: pos,
+      },
+    });
+  },
+  "editor.insertAtCursor": (text: string) => {
+    let editorView = editor.editorView!;
+    let from = editorView.state.selection.main.from;
+    editorView.dispatch({
+      changes: {
+        insert: text,
+        from: from,
+      },
+      selection: {
+        anchor: from + text.length,
+      },
+    });
+  },
+  "editor.getSyntaxNodeUnderCursor": (): SyntaxNode | undefined => {
+    const editorState = editor.editorView!.state;
+    let selection = editorState.selection.main;
+    if (selection.empty) {
+      let node = syntaxTree(editorState).resolveInner(selection.from);
+      if (node) {
+        return {
+          name: node.name,
+          text: editorState.sliceDoc(node.from, node.to),
+          from: node.from,
+          to: node.to,
+        };
+      }
+    }
+  },
+  "editor.matchBefore": (
+    regexp: string
+  ): { from: number; to: number; text: string } | null => {
+    const editorState = editor.editorView!.state;
+    let selection = editorState.selection.main;
+    let from = selection.from;
+    if (selection.empty) {
+      let line = editorState.doc.lineAt(from);
+      let start = Math.max(line.from, from - 250);
+      let str = line.text.slice(start - line.from, from - line.from);
+      let found = str.search(ensureAnchor(new RegExp(regexp), false));
+      // console.log("Line", line, start, str, new RegExp(regexp), found);
+      return found < 0
+        ? null
+        : { from: start + found, to: from, text: str.slice(found) };
+    }
+    return null;
+  },
+  "editor.getSyntaxNodeAtPos": (pos: number): SyntaxNode | undefined => {
+    const editorState = editor.editorView!.state;
+    let node = syntaxTree(editorState).resolveInner(pos);
+    if (node) {
+      return {
+        name: node.name,
+        text: editorState.sliceDoc(node.from, node.to),
+        from: node.from,
+        to: node.to,
+      };
+    }
+  },
+  "editor.dispatch": (change: Transaction) => {
+    editor.editorView!.dispatch(change);
+  },
+  "editor.prompt": (message: string, defaultValue = ""): string | null => {
+    return prompt(message, defaultValue);
+  },
+});

webapp/syscalls/indexer.native.ts

@@ -0,0 +1,22 @@
+import { Space, KV } from "../space";
+
+export default (space: Space) => ({
+  "indexer.scanPrefixForPage": async (pageName: string, keyPrefix: string) => {
+    return await space.indexScanPrefixForPage(pageName, keyPrefix);
+  },
+  "indexer.scanPrefixGlobal": async (keyPrefix: string) => {
+    return await space.indexScanPrefixGlobal(keyPrefix);
+  },
+  "indexer.get": async (pageName: string, key: string): Promise<any> => {
+    return await space.indexGet(pageName, key);
+  },
+  "indexer.set": async (pageName: string, key: string, value: any) => {
+    await space.indexSet(pageName, key, value);
+  },
+  "indexer.batchSet": async (pageName: string, kvs: KV[]) => {
+    await space.indexBatchSet(pageName, kvs);
+  },
+  "indexer.delete": async (pageName: string, key: string) => {
+    await space.indexDelete(pageName, key);
+  },
+});

webapp/syscalls/space.native.ts

@@ -0,0 +1,28 @@
+import { Editor } from "../editor";
+import { PageMeta } from "../types";
+
+export default (editor: Editor) => ({
+  "space.listPages": (): PageMeta[] => {
+    return [...editor.viewState.allPages];
+  },
+  "space.readPage": async (
+    name: string
+  ): Promise<{ text: string; meta: PageMeta }> => {
+    return await editor.space.readPage(name);
+  },
+  "space.writePage": async (name: string, text: string): Promise<PageMeta> => {
+    return await editor.space.writePage(name, text);
+  },
+  "space.deletePage": async (name: string) => {
+    console.log("Clearing page index", name);
+    await editor.space.indexDeletePrefixForPage(name, "");
+    // If we're deleting the current page, navigate to the start page
+    if (editor.currentPage === name) {
+      await editor.navigate("start");
+    }
+    // Remove page from open pages in editor
+    editor.openPages.delete(name);
+    console.log("Deleting page");
+    await editor.space.deletePage(name);
+  },
+});

webapp/syscalls/ui.browser.ts

@@ -0,0 +1,20 @@
+// @ts-ignore
+let frameTest = document.getElementById("main-frame");
+
+window.addEventListener("message", async (event) => {
+  let messageEvent = event as MessageEvent;
+  let data = messageEvent.data;
+  if (data.type === "iframe_event") {
+    // @ts-ignore
+    window.mainPlug.dispatchEvent(data.data.event, data.data.data);
+  }
+});
+
+export default {
+  "ui.update": function (doc: any) {
+    // frameTest.contentWindow.postMessage({
+    //     type: "loadContent",
+    //     doc: doc,
+    // });
+  },
+};