roamjs-components 0.85.2 → 0.85.4

package/testing/mockRoamEnvironment.js

@@ -0,0 +1,1254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const edn_data_1 = require("edn-data");
+const nanoid_1 = tslib_1.__importDefault(require("nanoid"));
+const jsdom_1 = require("jsdom");
+const initMockGraph = () => ({
+    state: {},
+    uids: {},
+    titles: {},
+});
+const getDbId = () => Math.ceil(Math.random() * 1000000);
+const isNode = (v) => typeof v === "object" && v !== null && !(v instanceof RegExp);
+const resolvePattern = (pattern, result, graph) => Array.isArray(result)
+    ? result.map((r) => resolvePattern(pattern, r, graph))
+    : pattern.some((pat) => pat.type === "wildcard")
+        ? result
+        : Object.fromEntries(pattern.flatMap((pat) => {
+            if (pat.type === "constant") {
+                return [[pat.value, result[pat.value]]];
+            }
+            else if (pat.type === "attr-expr") {
+                if (pat.option.type === "as-expr") {
+                    return [[pat.option.value, result[pat.name]]];
+                }
+                else {
+                    throw new Error(`Unexpected pull attribute expression type: ${pat.option.type}`);
+                }
+            }
+            else if (pat.type === "map-spec") {
+                return pat.entries.map(({ key, value }) => {
+                    const k = typeof key === "string"
+                        ? key
+                        : key.type === "as-expr"
+                            ? key.value
+                            : "";
+                    const nestedResult = result[k];
+                    if (!nestedResult)
+                        return [k, []];
+                    if (value === "...") {
+                        const nestedResults = (Array.isArray(nestedResult) ? nestedResult : [nestedResult])
+                            .map((a) => a[":db/id"])
+                            .filter((id) => typeof id === "number")
+                            .map((id) => graph.state[id]);
+                        return [k, resolvePattern(pattern, nestedResults, graph)];
+                    }
+                    else {
+                        return [k, resolvePattern(value, nestedResult, graph)];
+                    }
+                });
+            }
+            else {
+                throw new Error(`Unexpected pull pattern type: ${pat.type}`);
+            }
+        }));
+const fireQuery = ({ graph, find, where, }) => {
+    const getAssignments = (where, initialVars = []) => {
+        return where.reduce((programs, clause, index) => {
+            if (programs.assignments.size === 0 && index > 0)
+                return programs;
+            const reconcile = (matches, vars) => {
+                vars.forEach((v) => programs.vars.add(v));
+                programs.assignments = new Set(Array.from(new Set((programs.assignments.size === 0 && index === 0
+                    ? matches
+                    : Array.from(programs.assignments).flatMap((dict) => matches.map((dic) => (Object.assign(Object.assign({}, dict), dic))))).map((a) => 
+                // remove duplicate assignments
+                JSON.stringify(Object.entries(a).sort(([ka], [kb]) => ka.localeCompare(kb)))))).map((s) => Object.fromEntries(JSON.parse(s))));
+            };
+            if (clause.type === "data-pattern") {
+                const [source, relation, target] = clause.arguments;
+                if (source.type !== "variable") {
+                    throw new Error("Expected source type to be variable");
+                }
+                const sourceVar = source.value;
+                if (relation.type !== "constant") {
+                    throw new Error("Expected relation type to be constant");
+                }
+                const rel = relation.value;
+                const targetString = target.value.replace(/^"/, "").replace(/"$/, "");
+                const targetVar = target.value;
+                if (programs.vars.has(sourceVar)) {
+                    const newAssignments = Array.from(programs.assignments).flatMap((dict) => {
+                        var _a, _b, _c;
+                        const sourceEntry = dict[sourceVar];
+                        if (!isNode(sourceEntry)) {
+                            throw new Error("Expected the source variable to map to a node");
+                            return [];
+                        }
+                        const sourceId = sourceEntry.id;
+                        if (rel === ":block/refs") {
+                            throw new Error("TODO");
+                            //   if (target.type !== "variable") {
+                            //     throw new Error(
+                            //       "Expected target for :block/refs to be a variable"
+                            //     );
+                            //     return [];
+                            //   }
+                            //   const targetEntry = dict[targetVar];
+                            //   const refs = (
+                            //     isNode(targetEntry)
+                            //       ? [targetEntry.id]
+                            //       : graph.edges.referencesByUid[sourceId] || []
+                            //   ).map((ref) => ({
+                            //     ...dict,
+                            //     [targetVar]: { uid: ref },
+                            //   }));
+                            //   if (refs.length) programs.vars.add(targetVar);
+                            //   return refs;
+                        }
+                        else if (rel === ":block/page") {
+                            //   if (target.type !== "variable") {
+                            //     throw new Error(
+                            //       "Expected target for :block/page to be a variable"
+                            //     );
+                            //     return [];
+                            //   }
+                            //   const targetEntry = dict[targetVar];
+                            //   if (graph.edges.pagesByUid[sourceId]) {
+                            //     return [];
+                            //   } else if (isNode(targetEntry)) {
+                            //     return targetEntry.id ===
+                            //       graph.edges.blocksPageByUid[sourceId]
+                            //       ? [dict]
+                            //       : [];
+                            //   } else {
+                            //     programs.vars.add(targetVar);
+                            //     return [
+                            //       {
+                            //         ...dict,
+                            //         [targetVar]: {
+                            //           uid: graph.edges.blocksPageByUid[sourceId],
+                            //         },
+                            //       },
+                            //     ];
+                            //   }
+                            throw new Error("TODO");
+                        }
+                        else if (rel === ":node/title") {
+                            const sourceTitle = (_a = graph.state[sourceId]) === null || _a === void 0 ? void 0 : _a[":node/title"];
+                            if (target.type === "constant") {
+                                if (graph.titles[targetString] === sourceId) {
+                                    return [dict];
+                                }
+                                else {
+                                    return [];
+                                }
+                            }
+                            else if (target.type === "underscore") {
+                                return [dict];
+                            }
+                            else if (!sourceTitle) {
+                                return [];
+                            }
+                            else {
+                                programs.vars.add(targetVar);
+                                return [
+                                    Object.assign(Object.assign({}, dict), { [targetVar]: sourceTitle }),
+                                ];
+                            }
+                        }
+                        else if (rel === ":block/children") {
+                            if (target.type !== "variable") {
+                                throw new Error("Expected target for :block/children to be a variable");
+                            }
+                            const targetEntry = dict[targetVar];
+                            const children = (isNode(targetEntry)
+                                ? [targetEntry.id]
+                                : (((_b = graph.state[sourceId]) === null || _b === void 0 ? void 0 : _b[":block/children"]) || []).map((c) => c[":db/id"] || 0)).map((id) => (Object.assign(Object.assign({}, dict), { [targetVar]: { id } })));
+                            if (children.length)
+                                programs.vars.add(targetVar);
+                            return children;
+                        }
+                        else if (rel === ":block/parents") {
+                            if (target.type !== "variable") {
+                                throw new Error("Expected target for :block/parents to be a variable");
+                            }
+                            const targetEntry = dict[targetVar];
+                            const ancestors = (isNode(targetEntry)
+                                ? [targetEntry.id]
+                                : (((_c = graph.state[sourceId]) === null || _c === void 0 ? void 0 : _c[":block/parents"]) || []).map((d) => d[":db/id"] || 0)).map((id) => (Object.assign(Object.assign({}, dict), { [targetVar]: { id } })));
+                            if (ancestors.length)
+                                programs.vars.add(targetVar);
+                            return ancestors;
+                        }
+                        else if (rel === ":block/string") {
+                            //   if (target.type === "constant") {
+                            //     if (graph.edges.blocksByUid[sourceId] === targetString) {
+                            //       return [dict];
+                            //     } else {
+                            //       return [];
+                            //     }
+                            //   } else if (target.type === "underscore") {
+                            //     return [dict];
+                            //   } else {
+                            //     programs.vars.add(targetVar);
+                            //     return [
+                            //       {
+                            //         ...dict,
+                            //         [targetVar]: graph.edges.blocksByUid[sourceId],
+                            //       },
+                            //     ];
+                            //   }
+                            throw new Error("TODO");
+                        }
+                        else if (rel === ":block/heading") {
+                            //   if (target.type === "constant") {
+                            //     if (
+                            //       graph.edges.headingsByUid[sourceId] ===
+                            //       Number(targetString)
+                            //     ) {
+                            //       return [dict];
+                            //     } else {
+                            //       return [];
+                            //     }
+                            //   } else if (target.type === "underscore") {
+                            //     return [dict];
+                            //   } else {
+                            //     programs.vars.add(targetVar);
+                            //     return [
+                            //       {
+                            //         ...dict,
+                            //         [targetVar]: graph.edges.headingsByUid[sourceId],
+                            //       },
+                            //     ];
+                            //   }
+                            throw new Error("TODO");
+                        }
+                        else if (rel === ":create/user") {
+                            //   if (target.type !== "variable") {
+                            //     throw new Error(
+                            //       "Expected target for :create/user to be a variable"
+                            //     );
+                            //     return [];
+                            //   }
+                            //   const targetEntry = dict[targetVar];
+                            //   const userId = graph.edges.createUserByUid[sourceId];
+                            //   if (isNode(targetEntry)) {
+                            //     return targetEntry.id === userId ? [dict] : [];
+                            //   } else {
+                            //     programs.vars.add(targetVar);
+                            //     return [
+                            //       {
+                            //         ...dict,
+                            //         [targetVar]: { uid: userId },
+                            //       },
+                            //     ];
+                            //   }
+                            throw new Error("TODO");
+                        }
+                        else if (rel === ":edit/user") {
+                            //   if (target.type !== "variable") {
+                            //     throw new Error(
+                            //       "Expected target for :edit/user to be a variable"
+                            //     );
+                            //     return [];
+                            //   }
+                            //   const targetEntry = dict[targetVar];
+                            //   const userId = graph.edges.editUserByUid[sourceId];
+                            //   if (isNode(targetEntry)) {
+                            //     return targetEntry.id === userId ? [dict] : [];
+                            //   } else {
+                            //     programs.vars.add(targetVar);
+                            //     return [
+                            //       {
+                            //         ...dict,
+                            //         [targetVar]: { uid: userId },
+                            //       },
+                            //     ];
+                            //   }
+                            throw new Error("TODO");
+                        }
+                        else if (rel === ":create/time") {
+                            //   if (target.type === "constant") {
+                            //     if (
+                            //       graph.edges.createTimeByUid[sourceId] ===
+                            //       Number(targetString)
+                            //     ) {
+                            //       return [dict];
+                            //     } else {
+                            //       return [];
+                            //     }
+                            //   } else if (target.type === "underscore") {
+                            //     return [dict];
+                            //   } else {
+                            //     programs.vars.add(targetVar);
+                            //     return [
+                            //       {
+                            //         ...dict,
+                            //         [targetVar]: graph.edges.createTimeByUid[sourceId],
+                            //       },
+                            //     ];
+                            //   }
+                            throw new Error("TODO");
+                        }
+                        else if (rel === ":edit/time") {
+                            //   if (target.type === "constant") {
+                            //     if (
+                            //       graph.edges.editTimeByUid[sourceId] ===
+                            //       Number(targetString)
+                            //     ) {
+                            //       return [dict];
+                            //     } else {
+                            //       return [];
+                            //     }
+                            //   } else if (target.type === "underscore") {
+                            //     return [dict];
+                            //   } else {
+                            //     programs.vars.add(targetVar);
+                            //     return [
+                            //       {
+                            //         ...dict,
+                            //         [targetVar]: graph.edges.editTimeByUid[sourceId],
+                            //       },
+                            //     ];
+                            //   }
+                            throw new Error("TODO");
+                        }
+                        else if (rel === ":user/display-name") {
+                            //   if (target.type === "constant") {
+                            //     if (
+                            //       graph.edges.userDisplayByUid[sourceId] === targetString
+                            //     ) {
+                            //       return [dict];
+                            //     } else {
+                            //       return [];
+                            //     }
+                            //   } else if (target.type === "underscore") {
+                            //     return [dict];
+                            //   } else {
+                            //     programs.vars.add(targetVar);
+                            //     return [
+                            //       {
+                            //         ...dict,
+                            //         [targetVar]: graph.edges.userDisplayByUid[sourceId],
+                            //       },
+                            //     ];
+                            //   }
+                            throw new Error("TODO");
+                        }
+                        else {
+                            throw new Error(`Unknown rel: ${rel}`);
+                        }
+                    });
+                    programs.assignments = new Set(newAssignments);
+                }
+                else if (target.type === "variable" &&
+                    programs.vars.has(targetVar)) {
+                    const newAssignments = Array.from(programs.assignments).flatMap((_dict) => {
+                        // const targetEntry = dict[targetVar];
+                        if (rel === ":block/refs") {
+                            //   if (!isNode(targetEntry)) {
+                            //     throw new Error(
+                            //       "Expected the target variable to map to a node in :block/refs"
+                            //     );
+                            //     return [];
+                            //   }
+                            //   const targetId = targetEntry.id;
+                            //   const refs = (
+                            //     graph.edges.linkedReferencesByUid[targetId] || []
+                            //   ).map((ref) => ({
+                            //     ...dict,
+                            //     [v]: { uid: ref },
+                            //   }));
+                            //   if (refs.length) programs.vars.add(v);
+                            //   return refs;
+                            throw new Error("TODO");
+                        }
+                        else if (rel === ":block/page") {
+                            //   if (!isNode(targetEntry)) {
+                            //     throw new Error(
+                            //       "Expected the target variable to map to a node in :block/page"
+                            //     );
+                            //     return [];
+                            //   }
+                            //   const targetId = targetEntry.id;
+                            //   if (!graph.edges.pagesByUid[targetId]) {
+                            //     return [];
+                            //   } else {
+                            //     const children = Array.from(
+                            //       graph.edges.descendantsByUid[targetId] || []
+                            //     ).map((d) => ({
+                            //       ...dict,
+                            //       [v]: { uid: d },
+                            //     }));
+                            //     if (children.length) programs.vars.add(v);
+                            //     return children;
+                            //   }
+                            throw new Error("TODO");
+                        }
+                        else if (rel === ":node/title") {
+                            //   if (typeof targetEntry !== "string") {
+                            //     throw new Error(
+                            //       "Expected the target variable to map to a string in :block/refs"
+                            //     );
+                            //     return [];
+                            //   }
+                            //   const page = graph.edges.pageUidByTitle[targetEntry];
+                            //   if (page) {
+                            //     programs.vars.add(v);
+                            //     return [
+                            //       {
+                            //         ...dict,
+                            //         [v]: { uid: page },
+                            //       },
+                            //     ];
+                            //   }
+                            //   return [];
+                            throw new Error("TODO");
+                        }
+                        else if (rel === ":block/children") {
+                            //   if (!isNode(targetEntry)) {
+                            //     throw new Error(
+                            //       "Expected the target variable to map to a node in :block/children"
+                            //     );
+                            //   }
+                            //   const targetId = targetEntry.id;
+                            //   const parent = graph.edges.parentByUid[targetId];
+                            //   if (parent) {
+                            //     programs.vars.add(v);
+                            //     return [
+                            //       {
+                            //         ...dict,
+                            //         [v]: { uid: parent },
+                            //       },
+                            //     ];
+                            //   } else {
+                            //     return [];
+                            //   }
+                            throw new Error("TODO");
+                        }
+                        else if (rel === ":block/parents") {
+                            //   if (!isNode(targetEntry)) {
+                            //     throw new Error(
+                            //       "Expected the target variable to map to a node in :block/parents"
+                            //     );
+                            //     return [];
+                            //   }
+                            //   const targetId = targetEntry.id;
+                            //   const ancestors = Array.from(
+                            //     graph.edges.ancestorsByUid[targetId] || []
+                            //   ).map((child) => ({
+                            //     ...dict,
+                            //     [v]: { uid: child },
+                            //   }));
+                            //   if (ancestors.length) programs.vars.add(v);
+                            //   return ancestors;
+                            throw new Error("TODO");
+                        }
+                        else if (rel === ":block/string") {
+                            //   if (typeof targetEntry !== "string") {
+                            //     throw new Error(
+                            //       "Expected the target variable to map to a string in :block/string"
+                            //     );
+                            //     return [];
+                            //   }
+                            //   const blocks = Object.entries(graph.edges.blocksByUid)
+                            //     .filter(([_, v]) => v === targetEntry)
+                            //     .map(([child]) => ({
+                            //       ...dict,
+                            //       [v]: { uid: child },
+                            //     }));
+                            //   if (blocks.length) programs.vars.add(v);
+                            //   return blocks;
+                            throw new Error("TODO");
+                        }
+                        else if (rel === ":block/heading") {
+                            //   if (typeof targetEntry !== "number") {
+                            //     throw new Error(
+                            //       "Expected the target variable to map to a number in :block/heading"
+                            //     );
+                            //     return [];
+                            //   }
+                            //   const blocks = Object.entries(graph.edges.headingsByUid)
+                            //     .filter(([_, v]) => v === targetEntry)
+                            //     .map(([child]) => ({
+                            //       ...dict,
+                            //       [v]: { uid: child },
+                            //     }));
+                            //   if (blocks.length) programs.vars.add(v);
+                            //   return blocks;
+                            throw new Error("TODO");
+                        }
+                        else if (rel === ":create/user") {
+                            //   if (!isNode(targetEntry)) {
+                            //     throw new Error(
+                            //       "Expected the target variable to map to a node in :create/user"
+                            //     );
+                            //   }
+                            //   const targetId = targetEntry.id;
+                            //   const children = Object.keys(graph.edges.createUserByUid)
+                            //     .filter(
+                            //       (node) => graph.edges.createUserByUid[node] === targetId
+                            //     )
+                            //     .map((d) => ({
+                            //       ...dict,
+                            //       [v]: { uid: d },
+                            //     }));
+                            //   if (children.length) programs.vars.add(v);
+                            //   return children;
+                            throw new Error("TODO");
+                        }
+                        else if (rel === ":edit/user") {
+                            //   if (!isNode(targetEntry)) {
+                            //     throw new Error(
+                            //       "Expected the target variable to map to a node in :edit/user"
+                            //     );
+                            //   }
+                            //   const targetId = targetEntry.id;
+                            //   const children = Object.keys(graph.edges.editUserByUid)
+                            //     .filter(
+                            //       (node) =>
+                            //         graph.edges.editUserByUid[Number(node)] === targetId
+                            //     )
+                            //     .map((d) => ({
+                            //       ...dict,
+                            //       [v]: { uid: d },
+                            //     }));
+                            //   if (children.length) programs.vars.add(v);
+                            //   return children;
+                            throw new Error("TODO");
+                        }
+                        else if (rel === ":create/time") {
+                            //   if (typeof targetEntry !== "number") {
+                            //     throw new Error(
+                            //       "Expected the target variable to map to a number in :create/time"
+                            //     );
+                            //   }
+                            //   const blocks = Object.entries(graph.edges.createTimeByUid)
+                            //     .filter(([_, v]) => v === targetEntry)
+                            //     .map(([child]) => ({
+                            //       ...dict,
+                            //       [v]: { uid: child },
+                            //     }));
+                            //   if (blocks.length) programs.vars.add(v);
+                            //   return blocks;
+                            throw new Error("TODO");
+                        }
+                        else if (rel === ":edit/time") {
+                            //   if (typeof targetEntry !== "number") {
+                            //     throw new Error(
+                            //       "Expected the target variable to map to a number in :edit/time"
+                            //     );
+                            //   }
+                            //   const blocks = Object.entries(graph.edges.editTimeByUid)
+                            //     .filter(([_, v]) => v === targetEntry)
+                            //     .map(([child]) => ({
+                            //       ...dict,
+                            //       [v]: { uid: child },
+                            //     }));
+                            //   if (blocks.length) programs.vars.add(v);
+                            //   return blocks;
+                            throw new Error("TODO");
+                        }
+                        else if (rel === ":user/display-name") {
+                            //   if (typeof targetEntry !== "string") {
+                            //     throw new Error(
+                            //       "Expected the target variable to map to a string in :block/refs"
+                            //     );
+                            //   }
+                            //   const displayName = targetEntry
+                            //     .replace(/^"/, "")
+                            //     .replace(/"$/, "");
+                            //   const user = graph.edges.userUidByDisplay[displayName];
+                            //   if (user) {
+                            //     programs.vars.add(v);
+                            //     return [
+                            //       {
+                            //         ...dict,
+                            //         [v]: { uid: user },
+                            //       },
+                            //     ];
+                            //   }
+                            //   return [];
+                            throw new Error("TODO");
+                        }
+                        else {
+                            throw new Error(`Unknown rel: ${rel}`);
+                        }
+                    });
+                    programs.assignments = new Set(newAssignments);
+                }
+                else {
+                    const matches = rel === ":children/view-type"
+                        ? target.type === "constant"
+                            ? Object.values(graph.uids)
+                                .filter((id) => graph.state[id][":children/view-type"] !==
+                                targetString)
+                                .map((id) => ({ [sourceVar]: { id } }))
+                            : target.type === "underscore"
+                                ? Object.values(graph.uids).map((id) => ({
+                                    [sourceVar]: { id },
+                                }))
+                                : Object.values(graph.uids).map((id) => ({
+                                    [sourceVar]: { id },
+                                    [targetVar]: graph.state[id][":children/view-type"] || ":bullet",
+                                }))
+                        : rel === ":block/uid"
+                            ? target.type === "constant"
+                                ? [{ [sourceVar]: { id: graph.uids[target.value] } }]
+                                : target.type === "underscore"
+                                    ? Object.values(graph.uids).map((id) => ({
+                                        [sourceVar]: { id },
+                                    }))
+                                    : Object.entries(graph.uids).map(([uid, id]) => ({
+                                        [sourceVar]: { id },
+                                        [targetVar]: uid,
+                                    }))
+                            : new Error(`Unknown rel: ${rel}`);
+                    /*
+                      rel === ":block/refs"
+                        ? target.type !== "variable"
+                          ? []
+                          : Object.entries(graph.edges.referencesByUid).flatMap(
+                              ([source, refs]) =>
+                                refs.map((ref) => ({
+                                  [v]: { uid: source },
+                                  [targetVar]: { uid: ref },
+                                }))
+                            )
+                        : rel === ":block/page"
+                        ? target.type !== "variable"
+                          ? []
+                          : Object.entries(graph.edges.blocksPageByUid).map(
+                              ([b, p]) => ({
+                                [v]: { uid: b },
+                                [targetVar]: { uid: p },
+                              })
+                            )
+                        : rel === ":node/title"
+                        ? target.type === "constant"
+                          ? graph.edges.pageUidByTitle[targetString]
+                            ? [
+                                {
+                                  [v]: {
+                                    uid: graph.edges.pageUidByTitle[targetString],
+                                  },
+                                },
+                              ]
+                            : []
+                          : target.type === "underscore"
+                          ? Object.values(graph.edges.pageUidByTitle).map((uid) => ({
+                              [v]: { uid },
+                            }))
+                          : Object.entries(graph.edges.pageUidByTitle).map(
+                              ([title, uid]) => ({
+                                [v]: { uid },
+                                [targetVar]: title,
+                              })
+                            )
+                        : rel === ":block/children"
+                        ? target.type !== "variable"
+                          ? []
+                          : Object.entries(graph.edges.childrenByUid).flatMap(
+                              ([source, refs]) =>
+                                refs.map((ref) => ({
+                                  [v]: { uid: source },
+                                  [targetVar]: { uid: ref },
+                                }))
+                            )
+                        : rel === ":block/parents"
+                        ? target.type !== "variable"
+                          ? []
+                          : Object.entries(graph.edges.ancestorsByUid).flatMap(
+                              ([source, refs]) =>
+                                Array.from(refs).map((ref) => ({
+                                  [v]: { uid: source },
+                                  [targetVar]: { uid: ref },
+                                }))
+                            )
+                        : rel === ":block/string"
+                        ? target.type === "constant"
+                          ? Object.entries(graph.edges.blocksByUid)
+                              .filter(([_, text]) => text !== targetString)
+                              .map(([uid]) => ({ [v]: { uid } }))
+                          : target.type === "underscore"
+                          ? Object.keys(graph.edges.blocksByUid).map((uid) => ({
+                              [v]: { uid },
+                            }))
+                          : Object.entries(graph.edges.blocksByUid).map(
+                              ([uid, text]) => ({
+                                [v]: { uid },
+                                [targetVar]: text,
+                              })
+                            )
+                        : rel === ":block/heading"
+                        ? target.type === "constant"
+                          ? Object.entries(graph.edges.headingsByUid)
+                              .filter(([_, text]) => text !== Number(targetString))
+                              .map(([uid]) => ({ [v]: { uid } }))
+                          : target.type === "underscore"
+                          ? Object.keys(graph.edges.headingsByUid).map((uid) => ({
+                              [v]: { uid },
+                            }))
+                          : Object.entries(graph.edges.headingsByUid).map(
+                              ([uid, text]) => ({
+                                [v]: { uid },
+                                [targetVar]: text,
+                              })
+                            )
+                        : rel === ":create/user"
+                        ? target.type !== "variable"
+                          ? []
+                          : Object.entries(graph.edges.createUserByUid).map(
+                              ([b, p]) => ({
+                                [v]: { uid: b },
+                                [targetVar]: { uid: p },
+                              })
+                            )
+                        : rel === ":edit/user"
+                        ? target.type !== "variable"
+                          ? []
+                          : Object.entries(graph.edges.editUserByUid).map(([b, p]) => ({
+                              [v]: { uid: b },
+                              [targetVar]: { uid: p },
+                            }))
+                        : rel === ":create/time"
+                        ? target.type === "constant"
+                          ? Object.entries(graph.edges.createTimeByUid)
+                              .filter(([_, text]) => text !== Number(targetString))
+                              .map(([uid]) => ({ [v]: { uid } }))
+                          : target.type === "underscore"
+                          ? Object.keys(graph.edges.createTimeByUid).map((uid) => ({
+                              [v]: { uid },
+                            }))
+                          : Object.entries(graph.edges.createTimeByUid).map(
+                              ([uid, text]) => ({
+                                [v]: { uid },
+                                [targetVar]: text,
+                              })
+                            )
+                        : rel === ":edit/time"
+                        ? target.type === "constant"
+                          ? Object.entries(graph.edges.editTimeByUid)
+                              .filter(([_, text]) => text !== Number(targetString))
+                              .map(([uid]) => ({ [v]: { uid } }))
+                          : target.type === "underscore"
+                          ? Object.keys(graph.edges.editTimeByUid).map((uid) => ({
+                              [v]: { uid },
+                            }))
+                          : Object.entries(graph.edges.editTimeByUid).map(
+                              ([uid, text]) => ({
+                                [v]: { uid },
+                                [targetVar]: text,
+                              })
+                            )
+                        : rel === ":user/display-name"
+                        ? target.type === "constant"
+                          ? graph.edges.userUidByDisplay[targetString]
+                            ? [
+                                {
+                                  [v]: {
+                                    uid: graph.edges.userUidByDisplay[targetString],
+                                  },
+                                },
+                              ]
+                            : []
+                          : target.type === "underscore"
+                          ? Object.values(graph.edges.userUidByDisplay).map((uid) => ({
+                              [v]: { uid },
+                            }))
+                          : Object.entries(graph.edges.userUidByDisplay).map(
+                              ([title, uid]) => ({
+                                [v]: { uid },
+                                [targetVar]: title,
+                              })
+                            )*/
+                    if (matches instanceof Error) {
+                        throw matches;
+                    }
+                    reconcile(matches, target.type === "variable" ? [sourceVar, targetVar] : [sourceVar]);
+                }
+            }
+            else if (clause.type === "or-clause" ||
+                clause.type === "or-join-clause") {
+                let matches = [];
+                for (const cls of clause.clauses) {
+                    const assignments = getAssignments([cls], Array.from(programs.vars));
+                    if (assignments.size) {
+                        matches = Array.from(assignments);
+                        break;
+                    }
+                }
+                const vars = clause.type === "or-join-clause"
+                    ? clause.variables.map((v) => v.value)
+                    : Object.keys(matches[0] || {});
+                const varSet = new Set(vars);
+                matches.forEach((a) => {
+                    Object.keys(a).forEach((k) => {
+                        if (!varSet.has(k)) {
+                            delete a[k];
+                        }
+                    });
+                });
+                reconcile(matches, vars);
+            }
+            else if (clause.type === "and-clause") {
+                const matches = Array.from(getAssignments(clause.clauses, Array.from(programs.vars)));
+                reconcile(matches, Object.keys(matches[0] || {}));
+            }
+            else if (clause.type === "pred-expr") {
+                if (clause.pred === "clojure.string/includes?") {
+                    const [variable, constant] = clause.arguments;
+                    if ((variable === null || variable === void 0 ? void 0 : variable.type) !== "variable") {
+                        throw new Error("Expected type to be variable for first clojure.string/includes? argument.");
+                    }
+                    const v = variable.value;
+                    if (!programs.vars.has(v)) {
+                        throw new Error("Expected first clojure.string/includes? argument to be predefined variable.");
+                    }
+                    if ((constant === null || constant === void 0 ? void 0 : constant.type) !== "constant") {
+                        throw new Error("Expected type to be constant for second clojure.string/includes? argument.");
+                    }
+                    const newAssignments = Array.from(programs.assignments).flatMap((dict) => {
+                        const sourceEntry = dict[v];
+                        if (typeof sourceEntry !== "string") {
+                            throw new Error("Expected the variable to map to a string");
+                        }
+                        if (sourceEntry.includes(constant.value.replace(/^"/, "").replace(/"$/, ""))) {
+                            return [dict];
+                        }
+                        else {
+                            return [];
+                        }
+                    });
+                    programs.assignments = new Set(newAssignments);
+                }
+                else if (clause.pred === "clojure.string/starts-with?") {
+                    const [variable, constant] = clause.arguments;
+                    const v = variable.value;
+                    if ((variable === null || variable === void 0 ? void 0 : variable.type) !== "variable") {
+                        throw new Error("Expected type to be variable for first clojure.string/starts-with? argument.");
+                    }
+                    if (!programs.vars.has(v)) {
+                        throw new Error("Expected first clojure.string/starts-with? argument to be predefined variable.");
+                    }
+                    if ((constant === null || constant === void 0 ? void 0 : constant.type) !== "constant") {
+                        throw new Error("Expected type to be constant for second clojure.string/starts-with? argument.");
+                    }
+                    const newAssignments = Array.from(programs.assignments).flatMap((dict) => {
+                        const sourceEntry = dict[v];
+                        if (typeof sourceEntry !== "string") {
+                            throw new Error("Expected the variable to map to a string");
+                            return [];
+                        }
+                        if (sourceEntry.startsWith(constant.value.replace(/^"/, "").replace(/"$/, ""))) {
+                            return [dict];
+                        }
+                        else {
+                            return [];
+                        }
+                    });
+                    programs.assignments = new Set(newAssignments);
+                }
+                else if (clause.pred === "clojure.string/ends-with?") {
+                    const [variable, constant] = clause.arguments;
+                    const v = variable.value;
+                    if ((variable === null || variable === void 0 ? void 0 : variable.type) !== "variable") {
+                        throw new Error("Expected type to be variable for first clojure.string/ends-with? argument.");
+                    }
+                    if (!programs.vars.has(v)) {
+                        throw new Error("Expected first clojure.string/ends-with? argument to be predefined variable.");
+                    }
+                    if ((constant === null || constant === void 0 ? void 0 : constant.type) !== "constant") {
+                        throw new Error("Expected type to be constant for second clojure.string/ends-with? argument.");
+                    }
+                    const newAssignments = Array.from(programs.assignments).flatMap((dict) => {
+                        const sourceEntry = dict[v];
+                        if (typeof sourceEntry !== "string") {
+                            throw new Error("Expected the variable to map to a string");
+                        }
+                        if (sourceEntry.endsWith(constant.value.replace(/^"/, "").replace(/"$/, ""))) {
+                            return [dict];
+                        }
+                        else {
+                            return [];
+                        }
+                    });
+                    programs.assignments = new Set(newAssignments);
+                }
+                else if (clause.pred === "re-find") {
+                    const [regex, variable] = clause.arguments;
+                    const v = variable.value;
+                    const r = regex.value;
+                    if ((variable === null || variable === void 0 ? void 0 : variable.type) !== "variable") {
+                        throw new Error("Expected type to be variable for first re-find argument.");
+                    }
+                    if (!programs.vars.has(v)) {
+                        throw new Error("Expected first re-find argument to be predefined variable.");
+                    }
+                    if ((regex === null || regex === void 0 ? void 0 : regex.type) !== "variable") {
+                        throw new Error("Expected type to be variable for second re-find argument.");
+                    }
+                    if (!programs.vars.has(r)) {
+                        throw new Error("Expected second re-find argument to be predefined variable.");
+                    }
+                    const newAssignments = Array.from(programs.assignments).filter((dict) => {
+                        const regexEntry = dict[r];
+                        if (!(regexEntry instanceof RegExp)) {
+                            throw new Error("Expected the variable to map to a regexp");
+                        }
+                        const targetEntry = dict[v];
+                        if (typeof targetEntry !== "string") {
+                            throw new Error("Expected the variable to map to a string");
+                        }
+                        return regexEntry.test(targetEntry);
+                    });
+                    programs.assignments = new Set(newAssignments);
+                }
+                else if (clause.pred === ">") {
+                    const [left, right] = clause.arguments;
+                    const l = left.value;
+                    const r = right.value;
+                    if ((left === null || left === void 0 ? void 0 : left.type) === "variable" && !programs.vars.has(l)) {
+                        throw new Error("If left argument is a variable, it must be predefined");
+                    }
+                    if ((right === null || right === void 0 ? void 0 : right.type) === "variable" && !programs.vars.has(r)) {
+                        throw new Error("If right argument is a variable, it must be predefined");
+                    }
+                    const newAssignments = Array.from(programs.assignments).filter((dict) => {
+                        const leftValue = left.type === "constant" ? Number(left.value) : dict[r];
+                        if (typeof leftValue !== "number") {
+                            throw new Error("Left argument must be a number");
+                        }
+                        const rightValue = right.type === "constant" ? Number(right.value) : dict[r];
+                        if (typeof rightValue !== "number") {
+                            throw new Error("Right argument must be a number");
+                        }
+                        return leftValue > rightValue;
+                    });
+                    programs.assignments = new Set(newAssignments);
+                }
+                else if (clause.pred === "<") {
+                    const [left, right] = clause.arguments;
+                    const l = left.value;
+                    const r = right.value;
+                    if ((left === null || left === void 0 ? void 0 : left.type) === "variable" && !programs.vars.has(l)) {
+                        throw new Error("If left argument is a variable, it must be predefined");
+                    }
+                    if ((right === null || right === void 0 ? void 0 : right.type) === "variable" && !programs.vars.has(r)) {
+                        throw new Error("If right argument is a variable, it must be predefined");
+                    }
+                    const newAssignments = Array.from(programs.assignments).filter((dict) => {
+                        const leftValue = left.type === "constant" ? Number(left.value) : dict[r];
+                        if (typeof leftValue !== "number") {
+                            throw new Error("Left argument must be a number");
+                        }
+                        const rightValue = right.type === "constant" ? Number(right.value) : dict[r];
+                        if (typeof rightValue !== "number") {
+                            throw new Error("Right argument must be a number");
+                        }
+                        return leftValue < rightValue;
+                    });
+                    programs.assignments = new Set(newAssignments);
+                }
+                else {
+                    throw new Error(`Unexpected predicate ${clause.pred}`);
+                }
+            }
+            else if (clause.type === "fn-expr") {
+                if (clause.fn === "re-pattern") {
+                    const [constant] = clause.arguments;
+                    if ((constant === null || constant === void 0 ? void 0 : constant.type) !== "constant") {
+                        throw new Error("Expected type to be constant for first re-pattern argument.");
+                    }
+                    const { binding } = clause;
+                    if (binding.type !== "bind-scalar") {
+                        throw new Error("Expected type to be scalar for first re-pattern binding.");
+                    }
+                    const newAssignments = Array.from(programs.assignments).map((dict) => {
+                        return Object.assign(Object.assign({}, dict), { [binding.variable.value]: new RegExp(constant.value.replace(/^"/, "").replace(/"$/, "")) });
+                    });
+                    programs.assignments = new Set(newAssignments);
+                }
+                else {
+                    throw new Error(`Unexpected fn name ${clause.fn}`);
+                }
+            }
+            else {
+                throw new Error(`Unexpected type ${clause.type}`);
+            }
+            return programs;
+        }, {
+            assignments: new Set([]),
+            vars: new Set(initialVars),
+        }).assignments;
+    };
+    const assignments = getAssignments(where);
+    const results = Array.from(assignments).map((res) => find.elements.map((el) => {
+        if (el.type === "variable") {
+            const node = res[el.value];
+            if (isNode(node)) {
+                return node.id;
+            }
+            else if (node instanceof RegExp) {
+                return node.source;
+            }
+            else {
+                return node;
+            }
+        }
+        else if (el.type === "pull") {
+            const node = res[el.variable.value];
+            if (typeof node === "undefined") {
+                throw new Error(`Failed to find ${el.variable.value} in result: ${JSON.stringify(res)}`);
+            }
+            if (el.pattern.type === "pattern-data-literal") {
+                if (isNode(node)) {
+                    const result = graph.state[node.id];
+                    return resolvePattern(el.pattern.value, result, graph);
+                }
+                else {
+                    throw new Error(`Unexpected pull variable: ${el.variable.value} - ${node}`);
+                }
+            }
+            else {
+                throw new Error(`Unexpected pull element pattern type: ${el.pattern.type}`);
+            }
+        }
+        throw new Error(`Unexpected Find element type: ${el.type}`);
+    }));
+    return results;
+};
+const mockQuery = ({ graph, query }) => {
+    const data = (0, edn_data_1.parseEDNString)(query);
+    const findIndex = data.findIndex((d) => typeof d === "object" && "key" in d && d.key === "find");
+    const whereIndex = data.findIndex((d) => typeof d === "object" && "key" in d && d.key === "where");
+    const findPattern = data.slice(findIndex + 1, whereIndex);
+    const find = {
+        type: "rel",
+        elements: findPattern.map((p) => {
+            if (typeof p !== "object") {
+                throw new Error(`Unexpected type for datalog find, looking for object: ${JSON.stringify(p)}`);
+            }
+            if ("sym" in p)
+                return { type: "variable", value: p.sym };
+            if ("list" in p) {
+                const [pull, name, attrs] = p.list;
+                if (typeof pull !== "object" ||
+                    !("sym" in pull) ||
+                    pull.sym !== "pull") {
+                    throw new Error(`Expected first edn value to be a pull symbol. Found: ${JSON.stringify(p)}`);
+                }
+                if (typeof name !== "object" || !("sym" in name)) {
+                    throw new Error(`Expected second edn value to be a pull symbol. Found: ${JSON.stringify(p)}`);
+                }
+                if (!Array.isArray(attrs)) {
+                    throw new Error(`Expected third edn value to be an array. Found: ${JSON.stringify(p)}`);
+                }
+                return {
+                    type: "pull",
+                    variable: { type: "variable", value: name.sym.replace(/^\?/, "") },
+                    pattern: {
+                        type: "pattern-data-literal",
+                        value: attrs.map((attr) => {
+                            if (typeof attr === "object" && "key" in attr) {
+                                return {
+                                    type: "constant",
+                                    value: `:${attr.key}`,
+                                };
+                            }
+                            if (Array.isArray(attr)) {
+                                const [name, expr, option] = attr;
+                                if (typeof name !== "object" || !("key" in name)) {
+                                    throw new Error(`Expected attribute expression to start with key. Found: ${JSON.stringify(attr)}`);
+                                }
+                                if (typeof expr !== "object" ||
+                                    !("key" in expr) ||
+                                    !["as", "limit", "default"].includes(expr.key)) {
+                                    throw new Error(`Expected attribute expression to have second key :as, :limit, or :default. Found: ${JSON.stringify(attr)}`);
+                                }
+                                if (typeof option !== "string") {
+                                    throw new Error(`Expected attribute expression to end with literal. Found: ${JSON.stringify(attr)}`);
+                                }
+                                const pullOption = expr.key === "as"
+                                    ? { type: "as-expr", value: option }
+                                    : undefined; // should be impossible
+                                if (!pullOption) {
+                                    throw new Error(`Expected attribute expression to be an \`as\` key. Found: ${JSON.stringify(expr)}`);
+                                }
+                                return {
+                                    type: "attr-expr",
+                                    name: `:${name.key}`,
+                                    option: pullOption,
+                                };
+                            }
+                            if (typeof attr === "object" && "map" in attr) {
+                                return {
+                                    type: "map-spec",
+                                    entries: attr.map.map((entry) => {
+                                        const [key, value] = entry;
+                                        if (typeof key !== "object" || !("key" in key)) {
+                                            throw new Error(`Unexpected pattern map key. Found: ${JSON.stringify(entry)}`);
+                                        }
+                                        if (typeof value !== "object" ||
+                                            !("sym" in value) ||
+                                            value.sym !== "...") {
+                                            throw new Error(`Unexpected pattern map value. Found: ${JSON.stringify(entry)}`);
+                                        }
+                                        return {
+                                            key: `:${key.key}`,
+                                            value: value.sym,
+                                        };
+                                    }),
+                                };
+                            }
+                            throw new Error(`Unexpected pattern literal attribute. Found: ${JSON.stringify(attr)}`);
+                        }),
+                    },
+                };
+            }
+            throw new Error(`Unexpected object for datalog find: ${JSON.stringify(p)}`);
+        }),
+    };
+    const wherePattern = data.slice(whereIndex + 1);
+    const toDatalog = (e) => {
+        if (Array.isArray(e)) {
+            if (e.length === 3) {
+                return {
+                    type: "data-pattern",
+                    arguments: e.map((a) => {
+                        if (typeof a === "object") {
+                            if ("key" in a) {
+                                return {
+                                    type: "constant",
+                                    value: `:${a.key}`,
+                                };
+                            }
+                            else if ("sym" in a) {
+                                return {
+                                    type: "variable",
+                                    value: a.sym.slice(1),
+                                };
+                            }
+                            else {
+                                throw new Error(`Expected data-pattern argument to come from non array EDN: ${JSON.stringify(a)}`);
+                            }
+                        }
+                        else {
+                            return {
+                                type: "constant",
+                                value: a,
+                            };
+                        }
+                    }),
+                };
+            }
+        }
+        throw new Error(`Unknown value for datalog clause: ${JSON.stringify(e)}`);
+    };
+    const where = wherePattern.map(toDatalog);
+    return fireQuery({ graph, find, where });
+};
+const mockRoamEnvironment = () => {
+    const graph = initMockGraph();
+    const dom = new jsdom_1.JSDOM();
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    global.window = dom.window;
+    global.document = dom.window.document;
+    global.window.roamAlphaAPI = Object.assign(Object.assign({}, global.window.roamAlphaAPI), { pull: (_, id) => {
+            const pick = (node) => {
+                // TODO - process exp
+                return node;
+            };
+            if (Array.isArray(id)) {
+                const [attr, val] = id;
+                if (attr === ":block/uid") {
+                    return pick(graph.state[graph.uids[val]]);
+                }
+                else if (attr === ":node/title") {
+                    return pick(graph.state[graph.titles[val]]);
+                }
+                else {
+                    throw new Error(`Attr is not supported: ${attr}`);
+                }
+            }
+            else if (typeof id === "number") {
+                return pick(graph.state[id]);
+            }
+            else {
+                throw new Error(`Id is not supported: ${id}`);
+            }
+        }, q: (query, ..._params) => {
+            return mockQuery({ graph, query });
+        }, createBlock: (action) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            if (!action.block)
+                throw new Error(`block field is required`);
+            if (!action.location)
+                throw new Error(`location field is required`);
+            const parent = graph.uids[action.location["parent-uid"]];
+            if (!parent)
+                throw new Error(`Could not find parent by uid: ${action.location["parent-uid"]}`);
+            const parentBlock = graph.state[parent];
+            const id = getDbId();
+            const block = {
+                ":block/string": action.block.string,
+                ":block/uid": action.block.uid || window.roamAlphaAPI.util.generateUID(),
+                ":block/parents": [{ ":db/id": parent }].concat(parentBlock[":block/parents"] || []),
+                ":db/id": id,
+                ":block/order": action.location.order,
+            };
+            graph.uids[block[":block/uid"]] = id;
+            parentBlock[":block/children"] = (parentBlock[":block/children"] || []).concat({ ":db/id": id });
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            graph.state[id] = block;
+        }), updateBlock: (action) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            if (!action.block)
+                throw new Error(`block field is required`);
+            if (!action.block.uid)
+                throw new Error(`block uid is required`);
+            const block = graph.uids[action.block.uid];
+            if (!block) {
+                throw new Error(`Could not find block by uid: ${action.block.uid}`);
+            }
+            if (typeof action.block.string !== "undefined") {
+                graph.state[block][":block/string"] = action.block.string;
+            }
+            if (typeof action.block.open !== "undefined") {
+                graph.state[block][":block/open"] = action.block.open;
+            }
+            if (typeof action.block.heading !== "undefined") {
+                graph.state[block][":block/heading"] = action.block.heading;
+            }
+            if (typeof action.block["text-align"] !== "undefined") {
+                graph.state[block][":block/text-align"] = action.block["text-align"];
+            }
+            if (typeof action.block["children-view-type"] !== "undefined") {
+                graph.state[block][":children/view-type"] = `:${action.block["children-view-type"]}`;
+            }
+        }), createPage: (action) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            if (!action.page)
+                throw new Error(`page field is required`);
+            if (!action.page.title)
+                throw new Error(`page title field is required`);
+            const id = getDbId();
+            const page = {
+                ":node/title": action.page.title,
+                ":block/uid": action.page.uid || window.roamAlphaAPI.util.generateUID(),
+                ":db/id": id,
+            };
+            graph.titles[action.page.title] = id;
+            graph.uids[page[":block/uid"]] = id;
+            graph.state[id] = page;
+        }) });
+    global.window.roamAlphaAPI.data = Object.assign(Object.assign({}, global.window.roamAlphaAPI.data), { fast: {
+            q: (query, ..._params) => {
+                return mockQuery({ graph, query });
+            },
+        } });
+    global.window.roamAlphaAPI.util = Object.assign(Object.assign({}, global.window.roamAlphaAPI.util), { generateUID: () => (0, nanoid_1.default)().slice(0, 9) });
+};
+exports.default = mockRoamEnvironment;
+//# sourceMappingURL=mockRoamEnvironment.js.map