roamjs-components 0.85.1 → 0.86.0-alpha.2

package/src/util/extensionDeprecatedWarning.ts

@@ -0,0 +1,57 @@
+import idToTitle from "./idToTitle";
+import { render as renderSimpleAlert } from "../components/SimpleAlert";
+import getRoamUrl from "../dom/getRoamUrl";
+import deleteBlock from "../writes/deleteBlock";
+import { render as renderToast } from "../components/Toast";
+import getBasicTreeByParentUid from "../queries/getBasicTreeByParentUid";
+import getPageUidByPageTitle from "../queries/getPageUidByPageTitle";
+import getSubTree from "./getSubTree";
+import { PullBlock } from "../types";
+
+const extensionDeprecatedWarning = async ({
+  extensionId,
+  reason,
+}: {
+  extensionId: string;
+  reason: string;
+}): Promise<void> => {
+  const configUid = getPageUidByPageTitle(extensionId);
+  const config = getBasicTreeByParentUid(configUid);
+  const donotShowAgainUid = getSubTree({
+    tree: config,
+    key: "Do not show again",
+  }).uid;
+  if (!donotShowAgainUid) {
+    const blocks = (
+      window.roamAlphaAPI.data.fast.q(
+        `[:find (pull ?roamjs [:block/uid]) :where [?block :block/string ?contents] [(clojure.string/includes? ?contents  "https://roamjs.com/${extensionId}")] [?roamjs :block/children ?block]]`
+      ) as [PullBlock][]
+    ).map(([block]) => block[":block/uid"] || "");
+    renderSimpleAlert({
+      content: `RoamJS will soon be deprecating and then removing the ${idToTitle(
+        extensionId
+      )} extension.
+
+${reason}
+
+If you no longer use this extension, feel free to uninstall it${
+        blocks.length
+          ? ` by removing the block from [here](${getRoamUrl(
+              blocks[0]
+            )}) or by clicking confirm`
+          : ""
+      }. If this will be an issue for any reason, please reach out to support@roamjs.com.`,
+      onConfirm: () => blocks.map((b) => deleteBlock(b)),
+      onCancel: () =>
+        renderToast({
+          content:
+            "Reach out to supprt@roamjs.com if you would like to keep the extension.",
+          id: `deprecated-${extensionId}`,
+        }),
+      confirmText: "Confirm",
+      dontShowAgain: configUid,
+    });
+  }
+};
+
+export default extensionDeprecatedWarning;

package/src/util/extractRef.ts

@@ -0,0 +1,8 @@
+import { BLOCK_REF_REGEX } from "../dom/constants";
+
+const extractRef = (ref = ""): string =>
+  new RegExp(
+    `(?:\\(\\()?${BLOCK_REF_REGEX.source.slice(4, -4)}(?:\\)\\))?`
+  ).exec(ref)?.[1] || ref;
+
+export default extractRef;

package/src/util/extractTag.ts

@@ -0,0 +1,15 @@
+const extractTag = (tag: string): string =>
+  tag.startsWith("#[[") && tag.endsWith("]]")
+    ? tag.substring(3, tag.length - 2)
+    : tag.startsWith("[[") &&
+      tag.endsWith("]]") &&
+      (tag.slice(2, -2).indexOf("]]") < 0 ||
+        tag.slice(2, -2).indexOf("]]") > tag.slice(2, -2).indexOf("[["))
+    ? tag.substring(2, tag.length - 2)
+    : tag.startsWith("#")
+    ? tag.substring(1)
+    : tag.endsWith("::")
+    ? tag.substring(0, tag.length - 2)
+    : tag;
+
+export default extractTag;

package/src/util/focusMainWindowBlock.ts

@@ -0,0 +1,13 @@
+import getCurrentUserUid from "../queries/getCurrentUserUid";
+import getPageUidByBlockUid from "../queries/getPageUidByBlockUid";
+
+const focusMainWindowBlock = (uid: string) =>
+  window.roamAlphaAPI.ui.setBlockFocusAndSelection({
+    location: {
+      "block-uid": uid,
+      "window-id": `${getCurrentUserUid()}-body-outline-${getPageUidByBlockUid(
+        uid
+      )}`,
+    },
+  });
+export default focusMainWindowBlock;

package/src/util/getAuthorizationHeader.ts

@@ -0,0 +1,11 @@
+import getCurrentUserEmail from "../queries/getCurrentUserEmail";
+import getToken from "./getToken";
+
+const getAuthorizationHeader = (service?: string) => {
+  const token = getToken();
+  return token
+    ? `Bearer ${window.btoa(`${getCurrentUserEmail()}:${getToken()}`)}`
+    : getToken(service);
+};
+
+export default getAuthorizationHeader;

package/src/util/getLocalStorageKey.ts

@@ -0,0 +1,4 @@
+const getLocalStorageKey = (key: string, skipGraph?: true): string =>
+  `roamjs:${key}${skipGraph ? "" : `:${window.roamAlphaAPI.graph.name}`}`;
+
+export default getLocalStorageKey;

package/src/util/getOauth.ts

@@ -0,0 +1,57 @@
+import getEditTimeByBlockUid from "../queries/getEditTimeByBlockUid";
+import getPageUidByPageTitle from "../queries/getPageUidByPageTitle";
+import getShallowTreeByParentUid from "../queries/getShallowTreeByParentUid";
+import localStorageGet from "./localStorageGet";
+import toConfigPageName from "./toConfigPageName";
+import toFlexRegex from "./toFlexRegex";
+
+const getOauth = (service: string, label?: string): string => {
+  const fromStorage = localStorageGet(`oauth-${service}`);
+  if (fromStorage) {
+    const accounts = JSON.parse(fromStorage) as {
+      text: string;
+      data: string;
+    }[];
+    const accountNode =
+      (label ? accounts.find(({ text }) => text === label) : accounts[0]) ||
+      ({} as { data?: string });
+    const { data, ...node } = accountNode;
+    return data ? JSON.stringify({ ...JSON.parse(data), node }) : "{}";
+  }
+  const tree = getShallowTreeByParentUid(
+    getPageUidByPageTitle(toConfigPageName(service))
+  );
+  const node = tree.find((s) => toFlexRegex("oauth").test(s.text.trim()));
+  if (!node) {
+    return "{}";
+  }
+  const nodeChildren = getShallowTreeByParentUid(node.uid);
+  const index = label
+    ? nodeChildren.findIndex((t) => toFlexRegex(label).test(t.text))
+    : 0;
+  const labelNode = nodeChildren[index];
+  if (!labelNode) {
+    return "{}";
+  }
+  if (labelNode.text.startsWith("{") && labelNode.text.endsWith("}")) {
+    const obj = JSON.parse(labelNode.text);
+    obj.node = {
+      uid: labelNode.uid,
+      time: getEditTimeByBlockUid(labelNode.uid),
+    };
+    return JSON.stringify(obj);
+  }
+  const dataNode = getShallowTreeByParentUid(labelNode.uid)[0];
+  const uid = dataNode?.uid || "";
+  if (!dataNode?.text) {
+    return "{}";
+  }
+  const obj = JSON.parse(dataNode.text);
+  obj.node = {
+    uid,
+    time: uid ? getEditTimeByBlockUid(uid) : 0,
+  };
+  return JSON.stringify(obj);
+};
+
+export default getOauth;

package/src/util/getOauthAccounts.ts

@@ -0,0 +1,26 @@
+import getShallowTreeByParentUid from "../queries/getShallowTreeByParentUid";
+import getPageUidByPageTitle from "../queries/getPageUidByPageTitle";
+import localStorageGet from "./localStorageGet";
+import toConfigPageName from "./toConfigPageName";
+import toFlexRegex from "./toFlexRegex";
+
+const getOauthAccounts = (service: string): string[] => {
+  const fromStorage = localStorageGet(`oauth-${service}`);
+  if (fromStorage) {
+    const accounts = JSON.parse(fromStorage) as {
+      text: string;
+      data: string;
+    }[];
+    return accounts.map((a) => a.text);
+  }
+  const tree = getShallowTreeByParentUid(
+    getPageUidByPageTitle(toConfigPageName(service))
+  );
+  const node = tree.find((s) => toFlexRegex("oauth").test(s.text.trim()));
+  if (!node) {
+    return [];
+  }
+  return getShallowTreeByParentUid(node.uid).map((t) => t.text);
+};
+
+export default getOauthAccounts;

package/src/util/getRenderRoot.ts

@@ -0,0 +1,17 @@
+// @DEPRECATED
+
+const getRenderRoot = (id: string): HTMLDivElement => {
+  const rootId = `roamjs-${id}-root`;
+  const existing = document.getElementById(rootId) as HTMLDivElement;
+  if (existing) {
+    existing.setAttribute("data-existing", "true");
+    return existing;
+  }
+  const app = document.getElementById("app");
+  const newRoot = document.createElement("div");
+  newRoot.id = rootId;
+  app?.parentElement?.appendChild(newRoot);
+  return newRoot;
+};
+
+export default getRenderRoot;

package/src/util/getSettingIntFromTree.ts

@@ -0,0 +1,18 @@
+import type { InputTextNode } from "../types";
+import toFlexRegex from "./toFlexRegex";
+
+const getSettingIntFromTree = ({
+  tree,
+  key,
+  defaultValue = 0,
+}: {
+  tree: InputTextNode[];
+  key: string;
+  defaultValue?: number;
+}): number => {
+  const node = tree.find((s) => toFlexRegex(key).test(s.text.trim()));
+  const value = node?.children?.[0]?.text?.trim?.() || "";
+  return !value || isNaN(Number(value)) ? defaultValue : Number(value);
+};
+
+export default getSettingIntFromTree;

package/src/util/getSettingValueFromTree.ts

@@ -0,0 +1,23 @@
+import getBasicTreeByParentUid from "../queries/getBasicTreeByParentUid";
+import type { InputTextNode } from "../types";
+import toFlexRegex from "./toFlexRegex";
+
+const getSettingValueFromTree = ({
+  parentUid = "",
+  tree = getBasicTreeByParentUid(parentUid),
+  key,
+  defaultValue = "",
+}: {
+  parentUid?: string;
+  tree?: InputTextNode[];
+  key: string;
+  defaultValue?: string;
+}): string => {
+  const node = tree.find((s) => toFlexRegex(key).test(s.text.trim()));
+  const value = node?.children?.[0]
+    ? node?.children?.[0].text.trim()
+    : defaultValue;
+  return value;
+};
+
+export default getSettingValueFromTree;

package/src/util/getSettingValuesFromTree.ts

@@ -0,0 +1,20 @@
+import type { InputTextNode } from "../types";
+import toFlexRegex from "./toFlexRegex";
+
+const getSettingValuesFromTree = ({
+  tree,
+  key,
+  defaultValue = [],
+}: {
+  tree: InputTextNode[];
+  key: string;
+  defaultValue?: string[];
+}): string[] => {
+  const node = tree.find((s) => toFlexRegex(key).test(s.text.trim()));
+  const value = node?.children
+    ? node.children.map((t) => t.text.trim())
+    : defaultValue;
+  return value;
+};
+
+export default getSettingValuesFromTree;

package/src/util/getSubTree.ts

@@ -0,0 +1,31 @@
+import getBasicTreeByParentUid from "../queries/getBasicTreeByParentUid";
+import type { RoamBasicNode } from "../types/native";
+import createBlock from "../writes/createBlock";
+import toFlexRegex from "./toFlexRegex";
+
+const getSubTree = ({
+  key,
+  parentUid,
+  order = 0,
+  tree = parentUid ? getBasicTreeByParentUid(parentUid) : [],
+}: {
+  key: string;
+  parentUid?: string;
+  tree?: RoamBasicNode[];
+  order?: number;
+}): RoamBasicNode => {
+  const node = tree.find((s) => toFlexRegex(key).test(s.text.trim()));
+  if (node) return node;
+  const defaultNode = { text: "", children: [] };
+  if (parentUid) {
+    const uid = window.roamAlphaAPI.util.generateUID();
+    createBlock({ node: { text: key, uid }, parentUid, order });
+    return {
+      uid,
+      ...defaultNode,
+    };
+  }
+  return { uid: "", ...defaultNode };
+};
+
+export default getSubTree;

package/src/util/getToken.ts

@@ -0,0 +1,12 @@
+import getBasicTreeByParentUid from "../queries/getBasicTreeByParentUid";
+import getPageUidByPageTitle from "../queries/getPageUidByPageTitle";
+import getTokenFromTree from "./getTokenFromTree";
+import localStorageGet from "./localStorageGet";
+
+const getToken = (service = "roamjs"): string =>
+  localStorageGet(`token${service === "roamjs" ? "" : `-${service}`}`) ||
+  getTokenFromTree(
+    getBasicTreeByParentUid(getPageUidByPageTitle(`roam/js/${service}`))
+  );
+
+export default getToken;

package/src/util/getTokenFromTree.ts

@@ -0,0 +1,6 @@
+import type { RoamBasicNode } from "../types";
+
+const getTokenFromTree = (tree: RoamBasicNode[]): string =>
+  tree.find((t) => /token/i.test(t.text))?.children?.[0]?.text || "";
+
+export default getTokenFromTree;

package/src/util/getWorkerClient.ts

@@ -0,0 +1,55 @@
+const getWorkerClient = ({
+  name,
+  onLoad,
+}: {
+  name: string;
+  onLoad?: () => Promise<void>;
+}) => {
+  const workerUrl = (document.currentScript as HTMLScriptElement).src.replace(
+    /\/main\.js$/,
+    `/${name}.js`
+  );
+
+  const worker: { current?: Worker; init: boolean } = {
+    current: undefined,
+    init: false,
+  };
+
+  const listeners: { [name: string]: (a: unknown) => void } = {};
+  const initializeWorker = () =>
+    fetch(workerUrl)
+      .then((r) => r.blob())
+      .then((r) => {
+        worker.current = new Worker(window.URL.createObjectURL(r));
+        worker.current.onmessage = (e) => {
+          const { method, ...data } = e.data;
+          listeners[method]?.(data);
+        };
+        return onLoad ? onLoad() : Promise.resolve();
+      })
+      .then(() => {
+        worker.init = true;
+        document.body.dispatchEvent(new Event(`roamjs:${name}-worker:init`));
+        return worker.current;
+      });
+  const terminateWorker = () => {
+    worker.current?.terminate();
+  };
+  const getWorker = (): Promise<Worker> =>
+    worker.current && worker.init
+      ? Promise.resolve(worker.current)
+      : new Promise((resolve) =>
+          document.body.addEventListener(
+            `roamjs:${name}-worker:init`,
+            () => worker.current && resolve(worker.current)
+          )
+        );
+  return {
+    getWorker,
+    terminateWorker,
+    initializeWorker,
+    listeners,
+  };
+};
+
+export default getWorkerClient;

package/src/util/handleBodyFetch.ts

@@ -0,0 +1,38 @@
+import { getNodeEnv } from "./env";
+import handleFetch, { HandleFetchArgs } from "./handleFetch";
+
+const handleBodyFetch =
+  (method: "POST" | "PUT") =>
+  <T extends Record<string, unknown> | ArrayBuffer = Record<string, never>>(
+    args: string | HandleFetchArgs,
+    _data?: Record<string, unknown>
+  ) => {
+    const { data, ...fetchArgs } =
+      typeof args === "string" ? { path: args, data: _data } : args;
+
+    return handleFetch<T>((url, init) => {
+      const body =
+        data instanceof Uint8Array
+          ? data
+          : getNodeEnv() === "development" &&
+            /(localhost|roamjs)/.test(url.toString())
+          ? JSON.stringify({ dev: true, ...data })
+          : JSON.stringify(data || {});
+      return [
+        url,
+        {
+          ...init,
+          body,
+          headers: Object.fromEntries(
+            Object.entries({
+              "Content-Type": "application/json",
+              ...init?.headers,
+            }).filter((h) => !!h[1])
+          ),
+          method,
+        },
+      ];
+    }, fetchArgs);
+  };
+
+export default handleBodyFetch;

package/src/util/handleFetch.ts

@@ -0,0 +1,70 @@
+import { getApiUrlEnv } from "./env";
+import getAuthorizationHeader from "./getAuthorizationHeader";
+
+export type HandleFetchArgs = {
+  path?: string;
+  domain?: string;
+  href?: string;
+  data?: Record<string, unknown> | Uint8Array;
+  authorization?: string;
+  anonymous?: boolean;
+  headers?: Record<string, string>;
+  buffer?: boolean;
+};
+
+// type HandleFetchReturn<T, B> = B extends true
+//   ? Promise<ArrayBuffer>
+//   : Promise<T>;
+
+type HandleFetch = <T extends Record<string, unknown> | ArrayBuffer>(
+  transformArgs: (...info: [URL, RequestInit]) => Parameters<typeof fetch>,
+  args: Pick<RequestInit, "method"> & Omit<HandleFetchArgs, "data">
+  // ) => HandleFetchReturn<T, B>;
+) => Promise<T>;
+
+const handleFetch: HandleFetch = (
+  transformArgs,
+  { method, anonymous, authorization, path, href, domain, headers = {}, buffer }
+) => {
+  const url = new URL(href || `${domain || getApiUrlEnv()}/${path}`);
+  const defaultHeaders = !anonymous
+    ? { Authorization: authorization || getAuthorizationHeader() }
+    : ({} as HeadersInit);
+  return fetch(
+    ...transformArgs(url, {
+      method,
+      headers: { ...defaultHeaders, ...headers },
+    })
+  ).then((r) => {
+    if (!r.ok) {
+      return r.text().then((e) => {
+        try {
+          return Promise.reject(JSON.parse(e));
+        } catch {
+          return Promise.reject(new Error(e));
+        }
+      });
+    } else if (r.status === 204) {
+      return {} as ReturnType<HandleFetch>;
+    }
+    const type = r.headers.get("content-type") || "";
+
+    return (
+      buffer
+        ? r.arrayBuffer()
+        : /^application\/json/.test(type)
+        ? r.json().then((d) => ({
+            ...(Array.isArray(d) ? { data: d } : d),
+            headers: Object.fromEntries(r.headers.entries()),
+            status: r.status,
+          }))
+        : r.text().then((t) => ({
+            data: t,
+            headers: Object.fromEntries(r.headers.entries()),
+            status: r.status,
+          }))
+    ).catch(() => r.text().then((e) => Promise.reject(new Error(e))));
+  });
+};
+
+export default handleFetch;

package/src/util/handleUrlFetch.ts

@@ -0,0 +1,30 @@
+import { getNodeEnv } from "./env";
+import handleFetch, { HandleFetchArgs } from "./handleFetch";
+
+const handleUrlFetch =
+  (method: "GET" | "DELETE") =>
+  <T extends Record<string, unknown> | ArrayBuffer = Record<string, never>>(
+    args: string | HandleFetchArgs,
+    _data?: Record<string, unknown>
+  ) => {
+    const { data = {}, ...fetchArgs } =
+      typeof args === "string" ? { path: args, data: _data } : args;
+
+    return handleFetch<T>((url, init) => {
+      if (getNodeEnv() === "development") {
+        url.searchParams.set("dev", "true");
+      }
+      Object.entries(data).forEach(([k, v]) =>
+        url.searchParams.set(k, v as string)
+      );
+      return [
+        url,
+        {
+          ...init,
+          method,
+        },
+      ];
+    }, fetchArgs);
+  };
+
+export default handleUrlFetch;

package/src/util/idToTitle.ts

@@ -0,0 +1,8 @@
+const idToTitle = (id: string): string =>
+  id
+    .split(/[\s-]/)
+    .map((s) => `${s.substring(0, 1).toUpperCase()}${s.substring(1)}`)
+    .join(" ")
+    .replace(/_/g, " ");
+
+export default idToTitle;

package/{util/index.d.ts → src/util/index.ts}

@@ -1,24 +1,24 @@
-export { default as addInputSetting } from "./addInputSetting";
-export { default as apiDelete } from "./apiDelete";
-export { default as apiGet } from "./apiGet";
-export { default as apiPost } from "./apiPost";
-export { default as apiPut } from "./apiPut";
-export { default as createOverlayRender } from "./createOverlayRender";
-export { default as createTagRegex } from "./createTagRegex";
-export { default as extractRef } from "./extractRef";
-export { default as extractTag } from "./extractTag";
-export { default as extensionDeprecatedWarning } from "./extensionDeprecatedWarning";
-export { default as getOauth } from "./getOauth";
-export { default as getOauthAccounts } from "./getOauthAccounts";
-export { default as getRenderRoot } from "./getRenderRoot";
-export { default as getSettingIntFromTree } from "./getSettingIntFromTree";
-export { default as getSettingValueFromTree } from "./getSettingValueFromTree";
-export { default as getSettingValuesFromTree } from "./getSettingValuesFromTree";
-export { default as getSubTree } from "./getSubTree";
-export { default as getWorkerClient } from "./getWorkerClient";
-export { default as idToTitle } from "./idToTitle";
-export { default as isControl } from "./isControl";
-export { default as runExtension } from "./runExtension";
-export { default as setInputSetting } from "./setInputSetting";
-export { default as setInputSettings } from "./setInputSettings";
-export { default as toFlexRegex } from "./toFlexRegex";
+export { default as addInputSetting } from "./addInputSetting";
+export { default as apiDelete} from "./apiDelete";
+export { default as apiGet} from "./apiGet";
+export { default as apiPost} from "./apiPost";
+export { default as apiPut} from "./apiPut";
+export { default as createOverlayRender } from "./createOverlayRender";
+export { default as createTagRegex } from "./createTagRegex";
+export { default as extractRef } from "./extractRef";
+export { default as extractTag } from "./extractTag";
+export { default as extensionDeprecatedWarning } from "./extensionDeprecatedWarning";
+export { default as getOauth } from "./getOauth";
+export { default as getOauthAccounts } from "./getOauthAccounts";
+export { default as getRenderRoot } from "./getRenderRoot";
+export { default as getSettingIntFromTree } from "./getSettingIntFromTree";
+export { default as getSettingValueFromTree } from "./getSettingValueFromTree";
+export { default as getSettingValuesFromTree } from "./getSettingValuesFromTree";
+export { default as getSubTree } from "./getSubTree";
+export { default as getWorkerClient } from "./getWorkerClient";
+export { default as idToTitle } from "./idToTitle";
+export { default as isControl } from "./isControl";
+export { default as runExtension } from "./runExtension";
+export { default as setInputSetting } from "./setInputSetting";
+export { default as setInputSettings } from "./setInputSettings";
+export { default as toFlexRegex } from "./toFlexRegex";

package/src/util/isControl.ts

@@ -0,0 +1,4 @@
+const isControl = (e: KeyboardEvent | MouseEvent): boolean =>
+  (e.ctrlKey && window.roamAlphaAPI.platform.isPC) || (e.metaKey && !window.roamAlphaAPI.platform.isPC);
+
+export default isControl;

package/src/util/localStorageGet.ts

@@ -0,0 +1,6 @@
+import getLocalStorageKey from "./getLocalStorageKey";
+
+export const localStorageGet = (key: string, skipGraph?: true): string =>
+  localStorage.getItem(getLocalStorageKey(key, skipGraph)) || "";
+
+export default localStorageGet;

package/src/util/localStorageRemove.ts

@@ -0,0 +1,6 @@
+import getLocalStorageKey from "./getLocalStorageKey";
+
+const localStorageRemove = (key: string, skipGraph?: true): void =>
+  localStorage.removeItem(getLocalStorageKey(key, skipGraph));
+
+export default localStorageRemove;

package/src/util/localStorageSet.ts

@@ -0,0 +1,6 @@
+import getLocalStorageKey from "./getLocalStorageKey";
+
+export const localStorageSet = (key: string, val: string, skipGraph?: true): void =>
+  localStorage.setItem(getLocalStorageKey(key, skipGraph), val);
+
+export default localStorageSet;