roamjs-components 0.85.1 → 1.0.0-beta.2

package/src/types/native.ts

@@ -0,0 +1,495 @@
+// emulating Datalog Grammar
+// https://docs.datomic.com/cloud/query/query-data-reference.html#or-clauses
+
+import { ChangeEvent } from "react";
+
+export type DatalogSrcVar = {
+  type: "src-var";
+  value: string;
+};
+
+export type DatalogVariable = {
+  type: "variable";
+  value: string;
+};
+
+export type DatalogAndClause = {
+  type: "and-clause";
+  clauses: DatalogClause[];
+};
+
+export type DatalogExpressionClause =
+  | DatalogDataPattern
+  | DatalogPredExpr
+  | DatalogFnExpr
+  | DatalogRuleExpr;
+
+export type DatalogRuleExpr = {
+  type: "rule-expr";
+  srcVar?: DatalogSrcVar;
+  ruleName: DatalogRuleName;
+  arguments: DatalogArgument[];
+};
+
+export type DatalogNotClause = {
+  type: "not-clause";
+  srcVar?: DatalogSrcVar;
+  clauses: DatalogClause[];
+};
+
+export type DatalogNotJoinClause = {
+  type: "not-join-clause";
+  srcVar?: DatalogSrcVar;
+  variables: DatalogVariable[];
+  clauses: DatalogClause[];
+};
+
+export type DatalogOrClause = {
+  type: "or-clause";
+  srcVar?: DatalogSrcVar;
+  clauses: DatalogClause[];
+};
+
+export type DatalogOrJoinClause = {
+  type: "or-join-clause";
+  srcVar?: DatalogSrcVar;
+  variables: DatalogVariable[];
+  clauses: DatalogClause[];
+};
+
+export type DatalogClause =
+  | DatalogNotClause
+  | DatalogOrJoinClause
+  | DatalogExpressionClause
+  | DatalogOrClause
+  | DatalogNotJoinClause
+  | DatalogAndClause;
+
+export type DatalogDataPattern = {
+  type: "data-pattern";
+  srcVar?: DatalogSrcVar;
+  arguments: DatalogArgument[];
+};
+
+export type DatalogArgument =
+  | DatalogSrcVar
+  | DatalogVariable
+  | DatalogConstant
+  | DatalogUnderscore;
+
+export type DatalogConstant = {
+  type: "constant";
+  value: string;
+};
+
+export type DatalogPredExpr = {
+  type: "pred-expr";
+  pred:
+    | "<"
+    | ">"
+    | "re-matches"
+    | "re-find"
+    | "clojure.string/includes?"
+    | "clojure.string/ends-with?"
+    | "clojure.string/starts-with?";
+  arguments: DatalogArgument[];
+};
+
+export type DatalogFnExpr = {
+  type: "fn-expr";
+  fn: "re-pattern" | "get";
+  arguments: DatalogArgument[];
+  binding: DatalogBinding;
+};
+
+export type DatalogBinding =
+  | DatalogBindScalar
+  | DatalogBindTuple
+  | DatalogBindColl
+  | DatalogBindRel;
+
+export type DatalogBindScalar = {
+  type: "bind-scalar";
+  variable: DatalogVariable;
+};
+export type DatalogBindTuple = {
+  type: "bind-tuple";
+  args: (DatalogVariable | DatalogUnderscore)[];
+};
+export type DatalogBindColl = {
+  type: "bind-col";
+  variable: DatalogVariable;
+};
+
+export type DatalogBindRel = {
+  type: "bind-rel";
+  args: (DatalogVariable | DatalogUnderscore)[];
+};
+
+export type DatalogUnderscore = {
+  type: "underscore";
+  value: "_";
+};
+
+export type DatalogRuleName = {
+  type: "rulename";
+  value: string;
+};
+
+export type RoamBasicBlock = {
+  string: string;
+  uid: string;
+};
+
+export type RoamBasicPage = { title: string; uid: string };
+
+export type RoamBasicNode = {
+  text: string;
+  uid: string;
+  children: RoamBasicNode[];
+};
+
+export type RoamPull = {
+  "block/children"?: RoamNode[];
+  "block/heading"?: number;
+  "block/open"?: boolean;
+  "block/order"?: number;
+  "block/page"?: RoamNode;
+  "block/parents"?: RoamNode[];
+  "block/refs"?: RoamNode[];
+  "block/string"?: string;
+  "block/uid"?: string;
+  "children/view-type"?: `:${ViewType}`;
+  "create/time"?: number;
+  "create/user"?: RoamNode;
+  "edit/time"?: number;
+  "edit/user"?: RoamNode;
+  "log/id"?: number;
+  "node/title"?: string;
+} & RoamNode;
+
+export type PullBlock = {
+  ":attrs/lookup"?: PullBlock[];
+  ":entity/attrs"?: [
+    { ":source": [":block/uid", string]; ":value": [":block/uid", string] },
+    { ":source": [":block/uid", string]; ":value": [":block/uid", string] },
+    {
+      ":source": [":block/uid", string];
+      ":value": string | [":block/uid", string];
+    }
+  ][];
+  ":block/children"?: PullBlock[];
+  ":block/heading"?: number;
+  ":block/open"?: boolean;
+  ":block/order"?: number;
+  ":block/page"?: { ":db/id": number };
+  ":block/parents"?: PullBlock[];
+  ":block/props"?: {
+    ":image-size"?: {
+      [p: string]: {
+        ":height": number;
+        ":width": number;
+      };
+    };
+    ":iframe"?: {
+      [p: string]: {
+        ":size": {
+          ":height": number;
+          ":width": number;
+        };
+      };
+    };
+    [k: `:roamjs-${string}`]: Record<string, unknown>;
+  };
+  ":block/refs"?: { ":db/id": number }[];
+  ":block/string"?: string;
+  ":block/view-type"?: `:${BlockViewType}`;
+  ":block/text-align"?: TextAlignment;
+  ":block/uid"?: string;
+  ":children/view-type"?: `:${ViewType}`;
+  ":create/time"?: number;
+  ":create/user"?: { ":db/id": number };
+  ":edit/time"?: number;
+  ":edit/user"?: { ":db/id": number };
+  ":db/id"?: number;
+  ":log/id"?: number;
+  ":node/title"?: string;
+  ":user/display-name"?: string;
+  ":user/display-page"?: { ":db/id": number };
+  ":user/settings"?: {
+    ":namespace-options": [":none", ":partial", ":full"];
+    ":link-brackets?": boolean;
+    ":showing-inline-references?": boolean;
+    ":right-sidebar-pinned": {
+      [uuid: string]: SidebarWindow;
+    };
+    ":showing-own-icons?": boolean;
+    ":showing-user-icons?": boolean;
+    ":first-day-of-week"?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+  };
+  ":user/uid"?: string;
+  ":user/email"?: string;
+};
+
+export type RoamPullResult = RoamPull | null;
+
+export type ViewType = "document" | "bullet" | "numbered";
+
+export type BlockViewType =
+  | "tabs"
+  | "outline"
+  | "horizontal"
+  | "popout"
+  | "comment"
+  | "side"
+  | "vertical";
+
+export type TextAlignment = "left" | "center" | "right" | "justify";
+
+export type RoamBlock = {
+  attrs?: { source: string[] }[][];
+  children?: { id: number }[];
+  id?: number;
+  string?: string;
+  title?: string;
+  time?: number;
+  uid?: string;
+  order?: number;
+  "view-type"?: ViewType;
+};
+
+export type RoamError = {
+  raw: string;
+  "status-code": number;
+};
+
+export type TreeNode = {
+  text: string;
+  order: number;
+  children: TreeNode[];
+  parents: number[];
+  uid: string;
+  heading: number;
+  open: boolean;
+  viewType: ViewType;
+  editTime: Date;
+  textAlign: TextAlignment;
+  props: {
+    imageResize: {
+      [link: string]: {
+        height: number;
+        width: number;
+      };
+    };
+    iframe: {
+      [link: string]: {
+        height: number;
+        width: number;
+      };
+    };
+  };
+};
+
+export type TextNode = {
+  text: string;
+  children: TextNode[];
+};
+
+export type InputTextNode = {
+  text: string;
+  children?: InputTextNode[];
+  uid?: string;
+  heading?: number;
+  textAlign?: TextAlignment;
+  viewType?: ViewType;
+  open?: boolean;
+  props?: Record<string, unknown>;
+};
+
+type PlusType = [number, string];
+
+export type RoamNode = { "db/id": number };
+
+export type RoamQuery = RoamPull & {
+  "block/graph"?: RoamNode;
+  "node/graph+title"?: PlusType;
+  "block/graph+uid"?: PlusType;
+  "node/graph"?: RoamNode;
+  "edit/email"?: string;
+  "entity/graph"?: RoamNode;
+};
+
+export type RoamQueryResult = number & RoamQuery;
+
+export type ClientParams = {
+  action:
+    | "pull"
+    | "q"
+    | "create-block"
+    | "update-block"
+    | "create-page"
+    | "move-block"
+    | "delete-block"
+    | "delete-page"
+    | "update-page";
+  selector?: string;
+  uid?: string;
+  query?: string;
+  inputs?: string[];
+} & ActionParams;
+
+export type ActionParams = {
+  location?: {
+    "parent-uid": string;
+    order: number | "last";
+  };
+  block?: {
+    string?: string;
+    uid?: string;
+    open?: boolean;
+    heading?: number;
+    "text-align"?: TextAlignment;
+    "children-view-type"?: ViewType;
+    props?: Record<string, unknown>;
+  };
+  page?: {
+    title?: string;
+    uid?: string;
+  };
+};
+
+export type WriteAction = (a: ActionParams) => Promise<void>;
+
+export type UserSettings = {
+  "global-filters": {
+    includes: string[];
+    removes: string[];
+  };
+};
+
+type SidebarWindowType =
+  | SidebarBlockWindow
+  | SidebarMentionsWindow
+  | SidebarGraphWindow
+  | SidebarOutlineWindow;
+
+export type SidebarWindowInput = {
+  "block-uid": string;
+  type: SidebarWindowType["type"];
+};
+
+type SidebarBlockWindow = {
+  type: "block";
+  "block-uid": string;
+};
+
+type SidebarOutlineWindow = {
+  type: "outline";
+  "page-uid": string;
+};
+
+type SidebarMentionsWindow = {
+  type: "mentions";
+  "mentions-uid": string;
+};
+
+type SidebarGraphWindow = {
+  type: "graph";
+  // "page-uid": string; Currently not working despite documentation
+  "block-uid": string;
+};
+
+export type SidebarAction = (action: {
+  window: SidebarWindowInput;
+}) => Promise<void>;
+
+export type SidebarWindow = {
+  "collapsed?": boolean;
+  order: number;
+  "pinned?": boolean;
+  "window-id": string;
+} & SidebarWindowType;
+
+export type AddPullWatch = (
+  pullPattern: string,
+  entityId: string,
+  callback: (before: PullBlock | null, after: PullBlock | null) => void
+) => boolean;
+
+type ButtonAction = {
+  type: "button";
+  onClick?: (e: MouseEvent) => void;
+  content: string;
+};
+
+type SwitchAction = {
+  type: "switch";
+  onChange?: (e: ChangeEvent<HTMLInputElement>) => void;
+};
+
+type InputAction = {
+  type: "input";
+  placeholder: string;
+  onChange?: (e: ChangeEvent<HTMLInputElement>) => void;
+};
+
+type SelectAction = {
+  type: "select";
+  items: string[];
+  onChange?: (e: ChangeEvent<HTMLInputElement>) => void;
+};
+
+type CustomAction = {
+  type: "reactComponent";
+  component: React.FC;
+};
+
+export type Action =
+  | ButtonAction
+  | SwitchAction
+  | InputAction
+  | SelectAction
+  | CustomAction;
+
+type PanelConfig = {
+  tabTitle: string;
+  settings: {
+    id: string;
+    name: string;
+    description: string;
+    action: Action;
+  }[];
+};
+
+export type AddCommandOptions = {
+  label: string;
+  callback: () => void;
+  disableHotkey?: boolean;
+  defaultHotkey?: string | string[];
+};
+
+type RemoveCommandOptions = {
+  label: string;
+};
+
+export type OnloadArgs = {
+  extensionAPI: {
+    settings: {
+      get: (k: string) => unknown;
+      getAll: () => Record<string, unknown>;
+      panel: {
+        create: (c: PanelConfig) => void;
+      };
+      set: (k: string, v: unknown) => Promise<void>;
+    };
+    ui: {
+      commandPalette: {
+        addCommand: (c: AddCommandOptions) => Promise<void>;
+        removeCommand: (c: RemoveCommandOptions) => Promise<void>;
+      };
+    };
+  };
+  extension: {
+    version: string;
+  };
+};

package/src/types/query-builder.ts

@@ -0,0 +1,10 @@
+export type Result = { text: string; uid: string } & Record<
+  `${string}-uid`,
+  string
+> &
+  Record<string, string | number | Date>;
+
+export type RunQuery = (parentUid: string) => Promise<Result[]>;
+export type RunQuerySync = (parentUid: string) => Result[];
+export type ListActiveQueries = () => { uid: string }[];
+export type IsDiscourseNode = (uid: string) => boolean;

package/src/types/smartblocks.ts

@@ -0,0 +1,39 @@
+import { InputTextNode } from "./native";
+
+type CommandOutput = string | string[] | InputTextNode[];
+export type CommandHandler = (
+  ...args: string[]
+) => CommandOutput | Promise<CommandOutput>;
+
+export type SmartBlocksContext = {
+  onBlockExit: CommandHandler;
+  targetUid: string;
+  triggerUid: string;
+  ifCommand?: boolean;
+  exitBlock: "yes" | "no" | "end" | "empty" | "childless";
+  exitWorkflow: boolean;
+  variables: Record<string, string>;
+  cursorPosition?: { uid: string; selection: number };
+  currentUid?: string;
+  currentContent: string;
+  indent: Set<string>;
+  unindent: Set<string>;
+  focusOnBlock?: string;
+  dateBasisMethod?: string;
+  refMapping: Record<string, string>;
+  afterWorkflowMethods: (() => void | Promise<void>)[];
+};
+
+export type RegisterCommand = (args: {
+  text: string;
+  help?: string;
+  handler: (
+    c: Pick<SmartBlocksContext, "targetUid" | "variables"> & {
+      proccessBlockText: (s: string) => Promise<InputTextNode[]>;
+      processBlock: (s: InputTextNode) => Promise<InputTextNode[]>;
+    }
+  ) => CommandHandler;
+  delayArgs?: true;
+}) => () => void;
+
+export type UnregisterCommand = (t: string) => void;

package/src/util/addInputSetting.ts

@@ -0,0 +1,33 @@
+import getBasicTreeByParentUid from "../queries/getBasicTreeByParentUid";
+import createBlock from "../writes/createBlock";
+import toFlexRegex from "./toFlexRegex";
+
+const addInputSetting = async ({
+  blockUid,
+  value,
+  key,
+  index = 0,
+}: {
+  blockUid: string;
+  value: string;
+  key: string;
+  index?: number;
+}): Promise<string> => {
+  const tree = await getBasicTreeByParentUid(blockUid);
+  const keyNode = tree.find((t) => toFlexRegex(key).test(t.text));
+  if (keyNode) {
+    return createBlock({
+      node: { text: value },
+      order: keyNode.children.length,
+      parentUid: keyNode.uid,
+    });
+  } else {
+    return createBlock({
+      parentUid: blockUid,
+      order: index,
+      node: { text: key, children: [{ text: value }] },
+    });
+  }
+};
+
+export default addInputSetting;

package/src/util/apiDelete.ts

@@ -0,0 +1,5 @@
+import handleUrlFetch from "./handleUrlFetch";
+
+const apiDelete = handleUrlFetch("DELETE");
+
+export default apiDelete;

package/src/util/apiGet.ts

@@ -0,0 +1,5 @@
+import handleUrlFetch from "./handleUrlFetch";
+
+const apiGet = handleUrlFetch("GET");
+
+export default apiGet;

package/src/util/apiPost.ts

@@ -0,0 +1,5 @@
+import handleBodyFetch from "./handleBodyFetch";
+
+const apiPost = handleBodyFetch("POST");
+
+export default apiPost;

package/src/util/apiPut.ts

@@ -0,0 +1,5 @@
+import handleBodyFetch from "./handleBodyFetch";
+
+const apiPut = handleBodyFetch("PUT")
+
+export default apiPut;

package/src/util/createOverlayRender.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import renderOverlay, { RoamOverlayProps } from "./renderOverlay";
+
+const createOverlayRender =
+  <T extends Record<string, unknown>>(
+    id: string,
+    Overlay: (props: RoamOverlayProps<T>) => React.ReactElement
+  ) =>
+  (props: T) =>
+    renderOverlay<T>({ id, Overlay, props });
+
+export default createOverlayRender;

package/src/util/createTagRegex.ts

@@ -0,0 +1,7 @@
+const createTagRegex = (title: string): RegExp => {
+  const escapedTitle = title.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(
+    `(?:#\\[\\[${escapedTitle}\\]\\]|#${escapedTitle}(?!\\w)|\\[\\[${escapedTitle}\\]\\])`
+  );
+};
+export default createTagRegex;

package/src/util/dispatchToRegistry.ts

@@ -0,0 +1,11 @@
+import { Registry } from "../types";
+import { getRoamJSExtensionIdEnv } from "./env";
+
+const dispatchToRegistry = (detail: Partial<Registry>) =>
+  document.body.dispatchEvent(
+    new CustomEvent(`roamjs:${getRoamJSExtensionIdEnv()}:register`, {
+      detail,
+    })
+  );
+
+export default dispatchToRegistry;

package/src/util/env.ts

@@ -0,0 +1,44 @@
+// Some developers may use roamjs-components without RoamJS scripting, in which case
+// envs wont be interpolated. best way to deal with that afaik is to try to get the value
+// catch defaulting to a known value
+
+// Cannot do a DRY approach either because bundlers need the full `process.env.VAR` text
+// outlined to be replaced
+
+export const getNodeEnv = (defaultValue = "production") => {
+  try {
+    return process.env.NODE_ENV || defaultValue;
+  } catch {
+    return defaultValue;
+  }
+};
+
+export const getRoamJSVersionEnv = () => {
+  try {
+    return process.env.ROAMJS_VERSION || process.env.VERSION || getNodeEnv("");
+  } catch {
+    return getNodeEnv("");
+  }
+};
+
+export const getApiUrlEnv = () => {
+  const defaultValue =
+    getNodeEnv() === "production"
+      ? "https://lambda.roamjs.com"
+      : "http://localhost:3003";
+  try {
+    return process.env.API_URL || defaultValue;
+  } catch {
+    return defaultValue;
+  }
+};
+
+export const getRoamJSExtensionIdEnv = () => {
+  try {
+    return (
+      process.env.PACKAGE_NAME || "roamjs"
+    );
+  } catch {
+    return "roamjs";
+  }
+};

package/src/util/extensionApiContext.ts

@@ -0,0 +1,17 @@
+import { OnloadArgs } from "../types";
+
+let extensionApi: OnloadArgs["extensionAPI"] | null = null;
+
+export const provideExtensionApi = (api: OnloadArgs["extensionAPI"]) => {
+  if (extensionApi) {
+    throw new Error("Extension API already provided");
+  }
+  extensionApi = api;
+};
+
+const getExtensionApi = () => {
+  if (!extensionApi) throw new Error("Extension API not provided");
+  return extensionApi;
+};
+
+export default getExtensionApi;