@gogitcms/editor 0.23.0

package/app/vendor/markdown-editor/src/flavors/gfm/serializer.ts

@@ -0,0 +1,82 @@
+import {
+  MarkdownSerializer,
+  MarkdownSerializerState,
+  defaultMarkdownSerializer,
+} from "prosemirror-markdown";
+import type { Node as PMNode } from "prosemirror-model";
+import { gfmSchema } from "./schema";
+
+const strikethrough = {
+  open: "~~",
+  close: "~~",
+  mixable: true,
+  expelEnclosingWhitespace: true,
+};
+
+// Inline-only serializer used to render a single table cell's content to a
+// markdown string. Cells never contain tables, so there is no recursion back
+// into the table handler.
+const inlineSerializer = new MarkdownSerializer(defaultMarkdownSerializer.nodes, {
+  ...defaultMarkdownSerializer.marks,
+  strikethrough,
+});
+
+function cellText(cell: PMNode): string {
+  const para = gfmSchema.nodes.paragraph.createChecked(null, cell.content);
+  const doc = gfmSchema.topNodeType.createChecked(null, [para]);
+  // Collapse newlines and escape pipes so the cell stays on one table row.
+  return inlineSerializer
+    .serialize(doc)
+    .trim()
+    .replace(/\n+/g, " ")
+    .replace(/\|/g, "\\|");
+}
+
+function serializeTable(state: MarkdownSerializerState, node: PMNode) {
+  const rows: string[][] = [];
+  node.forEach((row) => {
+    const cells: string[] = [];
+    row.forEach((cell) => cells.push(cellText(cell)));
+    rows.push(cells);
+  });
+  if (rows.length === 0) return;
+
+  const cols = rows[0].length;
+  const line = (cells: string[]) => {
+    const padded = [...cells];
+    while (padded.length < cols) padded.push("");
+    return "| " + padded.slice(0, cols).join(" | ") + " |";
+  };
+
+  state.write(line(rows[0]) + "\n");
+  state.write("| " + Array(cols).fill("---").join(" | ") + " |\n");
+  for (let i = 1; i < rows.length; i++) state.write(line(rows[i]) + "\n");
+  state.closeBlock(node);
+}
+
+const nodes = {
+  ...defaultMarkdownSerializer.nodes,
+  // Prefix task items with `[x] `/`[ ] `; the surrounding list handler has
+  // already written the `- `/`1. ` bullet.
+  list_item(state: MarkdownSerializerState, node: PMNode) {
+    if (node.attrs.checked !== null) {
+      state.write(node.attrs.checked ? "[x] " : "[ ] ");
+    }
+    state.renderContent(node);
+  },
+  table: serializeTable,
+  // Never reached (serializeTable renders rows/cells itself) but required so the
+  // serializer has an entry for every node type it might look up.
+  table_row() {},
+  table_header() {},
+  table_cell() {},
+};
+
+const serializer = new MarkdownSerializer(nodes, {
+  ...defaultMarkdownSerializer.marks,
+  strikethrough,
+});
+
+export function serializeGfm(doc: PMNode): string {
+  return serializer.serialize(doc);
+}

package/app/vendor/markdown-editor/src/flavors/gfm/taskList.ts

@@ -0,0 +1,39 @@
+import { Plugin } from "prosemirror-state";
+import type { EditorView } from "prosemirror-view";
+import { gfmSchema } from "./schema";
+
+// Makes the task-list checkboxes interactive: clicking one toggles the enclosing
+// list_item's `checked` attribute. The checkbox itself is contenteditable=false,
+// so we intercept the mousedown before selection handling.
+export function taskListPlugin(): Plugin {
+  return new Plugin({
+    props: {
+      handleDOMEvents: {
+        mousedown(view: EditorView, event: Event) {
+          const target = event.target as HTMLElement | null;
+          const box = target?.closest?.(".task-list-item-checkbox");
+          if (!box) return false;
+          const li = box.closest("li");
+          if (!li) return false;
+
+          const pos = view.posAtDOM(li, 0);
+          const $pos = view.state.doc.resolve(pos);
+          for (let d = $pos.depth; d > 0; d--) {
+            const node = $pos.node(d);
+            if (node.type === gfmSchema.nodes.list_item && node.attrs.checked !== null) {
+              const itemPos = $pos.before(d);
+              const tr = view.state.tr.setNodeMarkup(itemPos, undefined, {
+                ...node.attrs,
+                checked: !node.attrs.checked,
+              });
+              view.dispatch(tr);
+              event.preventDefault();
+              return true;
+            }
+          }
+          return false;
+        },
+      },
+    },
+  });
+}

package/app/vendor/markdown-editor/src/flavors/registry.ts

@@ -0,0 +1,13 @@
+import type { Flavor } from "./types";
+import { commonmark } from "./commonmark";
+import { gfm } from "./gfm";
+
+// All available flavors, keyed by id. Adding a dialect = one import + one entry.
+export const FLAVORS: Record<string, Flavor> = {
+  [commonmark.id]: commonmark,
+  [gfm.id]: gfm,
+};
+
+export function resolveFlavor(id: string | undefined): Flavor {
+  return (id && FLAVORS[id]) || commonmark;
+}

package/app/vendor/markdown-editor/src/flavors/shared/inputrules.ts

@@ -0,0 +1,79 @@
+import {
+  InputRule,
+  inputRules,
+  wrappingInputRule,
+  textblockTypeInputRule,
+  smartQuotes,
+  emDash,
+  ellipsis,
+} from "prosemirror-inputrules";
+import type { NodeType } from "prosemirror-model";
+import type { Schema } from "prosemirror-model";
+import type { Plugin } from "prosemirror-state";
+
+// Markdown "type it and it transforms" shortcuts: `> ` for blockquote, `1. ` /
+// `- ` for lists, ``` for a code block, `## ` for a heading. Mirrors the rules
+// from prosemirror-example-setup but built from whatever nodes the flavor's
+// schema actually declares.
+
+function blockQuoteRule(nodeType: NodeType) {
+  return wrappingInputRule(/^\s*>\s$/, nodeType);
+}
+
+function orderedListRule(nodeType: NodeType) {
+  return wrappingInputRule(
+    /^(\d+)\.\s$/,
+    nodeType,
+    (match) => ({ order: +match[1] }),
+    (match, node) => node.childCount + node.attrs.order === +match[1],
+  );
+}
+
+function bulletListRule(nodeType: NodeType) {
+  return wrappingInputRule(/^\s*([-+*])\s$/, nodeType);
+}
+
+function codeBlockRule(nodeType: NodeType) {
+  return textblockTypeInputRule(/^```$/, nodeType);
+}
+
+function headingRule(nodeType: NodeType, maxLevel: number) {
+  return textblockTypeInputRule(
+    new RegExp("^(#{1," + maxLevel + "})\\s$"),
+    nodeType,
+    (match) => ({ level: match[1].length }),
+  );
+}
+
+// Typing `[ ] ` / `[x] ` at the start of a list item's first block turns the
+// item into a task (GFM only — gated on list_item having a `checked` attr).
+function taskListRule(listItem: NodeType) {
+  return new InputRule(/^\[([ xX])\]\s$/, (state, match, start, end) => {
+    const $start = state.doc.resolve(start);
+    let depth = $start.depth;
+    while (depth > 0 && $start.node(depth).type !== listItem) depth--;
+    // Only fire inside a list item, and only on the item's first block.
+    if (depth === 0 || $start.index(depth) !== 0) return null;
+    const item = $start.node(depth);
+    return state.tr
+      .delete(start, end)
+      .setNodeMarkup($start.before(depth), undefined, {
+        ...item.attrs,
+        checked: match[1] !== " ",
+      });
+  });
+}
+
+export function buildInputRules(schema: Schema): Plugin {
+  const rules = [...smartQuotes, ellipsis, emDash];
+  let type: NodeType | undefined;
+  if ((type = schema.nodes.blockquote)) rules.push(blockQuoteRule(type));
+  if ((type = schema.nodes.ordered_list)) rules.push(orderedListRule(type));
+  if ((type = schema.nodes.bullet_list)) rules.push(bulletListRule(type));
+  if ((type = schema.nodes.code_block)) rules.push(codeBlockRule(type));
+  if ((type = schema.nodes.heading)) rules.push(headingRule(type, 6));
+  if ((type = schema.nodes.list_item) && type.spec.attrs && "checked" in type.spec.attrs) {
+    rules.push(taskListRule(type));
+  }
+  return inputRules({ rules });
+}

package/app/vendor/markdown-editor/src/flavors/shared/keymap.ts

@@ -0,0 +1,89 @@
+import {
+  chainCommands,
+  exitCode,
+  setBlockType,
+  toggleMark,
+  wrapIn,
+} from "prosemirror-commands";
+import { redo, undo } from "prosemirror-history";
+import { undoInputRule } from "prosemirror-inputrules";
+import {
+  liftListItem,
+  sinkListItem,
+  splitListItem,
+  wrapInList,
+} from "prosemirror-schema-list";
+import type { Command } from "prosemirror-state";
+import type { Schema } from "prosemirror-model";
+
+// Editing keybindings derived from the flavor's schema — only bindings whose
+// nodes/marks exist are installed, so the same builder serves CommonMark and
+// GFM. Adapted from prosemirror-example-setup's buildKeymap.
+export function buildKeymap(schema: Schema): Record<string, Command> {
+  const keys: Record<string, Command> = {};
+  const bind = (key: string, cmd: Command) => {
+    keys[key] = cmd;
+  };
+
+  bind("Mod-z", undo);
+  bind("Shift-Mod-z", redo);
+  bind("Mod-y", redo);
+  bind("Backspace", undoInputRule);
+
+  if (schema.marks.strong) {
+    bind("Mod-b", toggleMark(schema.marks.strong));
+    bind("Mod-B", toggleMark(schema.marks.strong));
+  }
+  if (schema.marks.em) {
+    bind("Mod-i", toggleMark(schema.marks.em));
+    bind("Mod-I", toggleMark(schema.marks.em));
+  }
+  if (schema.marks.code) bind("Mod-`", toggleMark(schema.marks.code));
+  if (schema.marks.strikethrough) {
+    bind("Mod-Shift-x", toggleMark(schema.marks.strikethrough));
+    bind("Mod-Shift-X", toggleMark(schema.marks.strikethrough));
+  }
+
+  if (schema.nodes.bullet_list) bind("Shift-Ctrl-8", wrapInList(schema.nodes.bullet_list));
+  if (schema.nodes.ordered_list) bind("Shift-Ctrl-9", wrapInList(schema.nodes.ordered_list));
+  if (schema.nodes.blockquote) bind("Ctrl->", wrapIn(schema.nodes.blockquote));
+
+  if (schema.nodes.hard_break) {
+    const br = schema.nodes.hard_break;
+    const cmd = chainCommands(exitCode, (state, dispatch) => {
+      if (dispatch) dispatch(state.tr.replaceSelectionWith(br.create()).scrollIntoView());
+      return true;
+    });
+    bind("Mod-Enter", cmd);
+    bind("Shift-Enter", cmd);
+  }
+
+  if (schema.nodes.list_item) {
+    bind("Enter", splitListItem(schema.nodes.list_item));
+    bind("Mod-[", liftListItem(schema.nodes.list_item));
+    bind("Mod-]", sinkListItem(schema.nodes.list_item));
+    bind("Tab", sinkListItem(schema.nodes.list_item));
+    bind("Shift-Tab", liftListItem(schema.nodes.list_item));
+  }
+
+  if (schema.nodes.code_block) bind("Shift-Ctrl-\\", setBlockType(schema.nodes.code_block));
+  if (schema.nodes.paragraph) bind("Shift-Ctrl-0", setBlockType(schema.nodes.paragraph));
+  if (schema.nodes.heading) {
+    for (let i = 1; i <= 6; i++) {
+      bind("Shift-Ctrl-" + i, setBlockType(schema.nodes.heading, { level: i }));
+    }
+  }
+  if (schema.nodes.horizontal_rule) {
+    const hr = schema.nodes.horizontal_rule;
+    bind("Mod-_", (state, dispatch) => {
+      if (dispatch) dispatch(state.tr.replaceSelectionWith(hr.create()).scrollIntoView());
+      return true;
+    });
+  }
+
+  // Note: the defaults (Enter, Backspace, Delete, arrows, …) are NOT merged in
+  // here. basePlugins installs baseKeymap as a separate, lower-priority keymap
+  // so that when a binding above returns false (e.g. splitListItem outside a
+  // list, undoInputRule with nothing to undo), it falls through to baseKeymap.
+  return keys;
+}

package/app/vendor/markdown-editor/src/flavors/shared/placeholder.ts

@@ -0,0 +1,24 @@
+import { Plugin } from "prosemirror-state";
+import { Decoration, DecorationSet } from "prosemirror-view";
+
+// Shows `text` over an empty document (a single empty textblock). Rendered via
+// the `.cms-editor-placeholder::before` rule in theme.ts.
+export function placeholderPlugin(text: string): Plugin {
+  return new Plugin({
+    props: {
+      decorations(state) {
+        const doc = state.doc;
+        const only = doc.firstChild;
+        if (doc.childCount === 1 && only && only.isTextblock && only.content.size === 0) {
+          return DecorationSet.create(doc, [
+            Decoration.node(0, only.nodeSize, {
+              class: "cms-editor-placeholder",
+              "data-placeholder": text,
+            }),
+          ]);
+        }
+        return null;
+      },
+    },
+  });
+}

package/app/vendor/markdown-editor/src/flavors/shared/plugins.ts

@@ -0,0 +1,58 @@
+import { baseKeymap } from "prosemirror-commands";
+import { dropCursor } from "prosemirror-dropcursor";
+import { gapCursor } from "prosemirror-gapcursor";
+import { history } from "prosemirror-history";
+import { keymap } from "prosemirror-keymap";
+import type { Plugin } from "prosemirror-state";
+import type { Schema } from "prosemirror-model";
+import type { XmlFragment } from "yjs";
+import type { Awareness } from "y-protocols/awareness";
+import { ySyncPlugin, yUndoPlugin, undo as yUndo, redo as yRedo } from "y-prosemirror";
+import { buildInputRules } from "./inputrules";
+import { buildKeymap } from "./keymap";
+
+// Collaborative binding for the editor: the shared XML fragment the document is
+// mirrored to, plus the awareness instance (reserved for future in-editor
+// cursors; presence is currently shown as a border + labels around the whole
+// editor, consistent with the other fields).
+export type EditorCollabBinding = {
+  fragment: XmlFragment;
+  awareness: Awareness;
+};
+
+// The editing plugins shared by every flavor: markdown input rules, the
+// schema-derived keymap, drop/gap cursors, and history. `extra` lets a flavor
+// prepend/append its own plugins (e.g. GFM's tableEditing).
+//
+// When `collab` is given, the local history plugin is replaced by y-prosemirror's
+// sync/cursor/undo plugins (per-client undo), and Mod-z/Mod-y are rebound to the
+// collaborative undo manager — a higher-priority keymap that shadows the
+// history-based bindings still present in buildKeymap (those become no-ops with
+// no history plugin installed).
+export function basePlugins(schema: Schema, extra: Plugin[] = [], collab?: EditorCollabBinding): Plugin[] {
+  const plugins: Plugin[] = [];
+  if (collab) {
+    plugins.push(
+      keymap({ "Mod-z": yUndo, "Mod-y": yRedo, "Shift-Mod-z": yRedo }),
+    );
+  }
+  plugins.push(
+    buildInputRules(schema),
+    // Flavor-specific bindings first; baseKeymap second so unhandled keys
+    // (Enter/Backspace/Delete/arrows/…) fall through to the ProseMirror defaults.
+    keymap(buildKeymap(schema)),
+    keymap(baseKeymap),
+    dropCursor(),
+    gapCursor(),
+  );
+  if (collab) {
+    // ySyncPlugin mirrors the doc to the shared fragment; yUndoPlugin gives
+    // per-client undo. Remote cursors (yCursorPlugin) are intentionally omitted —
+    // presence is shown as a border + labels around the editor by the host.
+    plugins.push(ySyncPlugin(collab.fragment), yUndoPlugin());
+  } else {
+    plugins.push(history());
+  }
+  plugins.push(...extra);
+  return plugins;
+}

package/app/vendor/markdown-editor/src/flavors/types.ts

@@ -0,0 +1,22 @@
+import type { Node as PMNode, Schema } from "prosemirror-model";
+import type { Plugin } from "prosemirror-state";
+import type { EditorCollabBinding } from "./shared/plugins";
+
+// A Flavor is a self-contained ProseMirror configuration: schema, the
+// markdown<->doc conversion, and the editing plugins (keymap, history, input
+// rules, …). Each markdown dialect (CommonMark, GFM) is one Flavor; adding a
+// new dialect is a new module plus a registry entry and nothing else.
+export interface Flavor {
+  id: string;
+  label: string;
+  schema: Schema;
+  // Parse a markdown string into a ProseMirror document.
+  parse(markdown: string): PMNode;
+  // Serialize a ProseMirror document back to a markdown string.
+  serialize(doc: PMNode): string;
+  // Editing plugins for this flavor. The `reactKeys` plugin (required by
+  // @handlewithcare/react-prosemirror) is added by the editor component, not
+  // here, so flavors never depend on the React binding. When `collab` is given,
+  // the flavor swaps local history for the collaborative (Yjs) plugins.
+  plugins(collab?: EditorCollabBinding): Plugin[];
+}

package/app/vendor/markdown-editor/src/formats/registry.ts

@@ -0,0 +1,45 @@
+// The set of editable *formats* and, for each, the file extensions it can drive
+// as a document body. This is the single TS source of truth for extension
+// gating; the Go schema validator mirrors these lists (keep them in sync).
+//
+// Frontmatter fields are always plain strings and are never gated by extension —
+// only the file-body binding consults `extensions`.
+
+export type EditorFormat = "markdown";
+
+export type MarkdownFlavor = "commonmark" | "gfm";
+
+export type FormatMeta = {
+  id: EditorFormat;
+  label: string;
+  // Lower-cased file extensions (leading dot) whose body may be edited in this
+  // format. `.mdx` is intentionally excluded — it needs a different parser.
+  extensions: string[];
+  flavors: readonly string[];
+  defaultFlavor: string;
+};
+
+export const FORMATS: Record<EditorFormat, FormatMeta> = {
+  markdown: {
+    id: "markdown",
+    label: "Markdown",
+    extensions: [".md", ".markdown"],
+    flavors: ["commonmark", "gfm"] as const,
+    defaultFlavor: "commonmark",
+  },
+};
+
+// Normalize a path or filename to its lower-cased extension (with dot), e.g.
+// "content/posts/hello.MD" -> ".md". Returns "" when there is no extension.
+export function extensionOf(pathOrName: string): string {
+  const base = pathOrName.split(/[\\/]/).pop() ?? "";
+  const dot = base.lastIndexOf(".");
+  return dot <= 0 ? "" : base.slice(dot).toLowerCase();
+}
+
+// Whether the given file path may be edited as a body in the given format.
+export function supportsFileBody(format: EditorFormat, pathOrName: string): boolean {
+  const meta = FORMATS[format];
+  if (!meta) return false;
+  return meta.extensions.includes(extensionOf(pathOrName));
+}

package/app/vendor/markdown-editor/src/icons.tsx

@@ -0,0 +1,120 @@
+import React from "react";
+
+// Small stroked icons (Lucide-style) for the formatting toolbar. 24px viewBox,
+// currentColor stroke so they inherit button color.
+type IconProps = { size?: number };
+
+const Svg = ({ size = 16, children }: IconProps & { children: React.ReactNode }) => (
+  <svg
+    width={size}
+    height={size}
+    viewBox="0 0 24 24"
+    fill="none"
+    stroke="currentColor"
+    strokeWidth={2}
+    strokeLinecap="round"
+    strokeLinejoin="round"
+    aria-hidden="true"
+  >
+    {children}
+  </svg>
+);
+
+export const BoldIcon = (p: IconProps) => (
+  <Svg {...p}>
+    <path d="M6 4h8a4 4 0 0 1 0 8H6z" />
+    <path d="M6 12h9a4 4 0 0 1 0 8H6z" />
+  </Svg>
+);
+
+export const ItalicIcon = (p: IconProps) => (
+  <Svg {...p}>
+    <line x1="19" y1="4" x2="10" y2="4" />
+    <line x1="14" y1="20" x2="5" y2="20" />
+    <line x1="15" y1="4" x2="9" y2="20" />
+  </Svg>
+);
+
+export const StrikethroughIcon = (p: IconProps) => (
+  <Svg {...p}>
+    <path d="M16 4H9a3 3 0 0 0-2.83 4" />
+    <path d="M14 12a4 4 0 0 1 0 8H6" />
+    <line x1="4" y1="12" x2="20" y2="12" />
+  </Svg>
+);
+
+export const CodeIcon = (p: IconProps) => (
+  <Svg {...p}>
+    <polyline points="16 18 22 12 16 6" />
+    <polyline points="8 6 2 12 8 18" />
+  </Svg>
+);
+
+export const H1Icon = (p: IconProps) => (
+  <Svg {...p}>
+    <path d="M4 12h8" />
+    <path d="M4 18V6" />
+    <path d="M12 18V6" />
+    <path d="m17 12 3-2v8" />
+  </Svg>
+);
+
+export const H2Icon = (p: IconProps) => (
+  <Svg {...p}>
+    <path d="M4 12h8" />
+    <path d="M4 18V6" />
+    <path d="M12 18V6" />
+    <path d="M21 18h-4c0-4 4-3 4-6 0-1.5-2-2.5-4-1" />
+  </Svg>
+);
+
+export const BulletListIcon = (p: IconProps) => (
+  <Svg {...p}>
+    <line x1="8" y1="6" x2="21" y2="6" />
+    <line x1="8" y1="12" x2="21" y2="12" />
+    <line x1="8" y1="18" x2="21" y2="18" />
+    <line x1="3" y1="6" x2="3.01" y2="6" />
+    <line x1="3" y1="12" x2="3.01" y2="12" />
+    <line x1="3" y1="18" x2="3.01" y2="18" />
+  </Svg>
+);
+
+export const OrderedListIcon = (p: IconProps) => (
+  <Svg {...p}>
+    <line x1="10" y1="6" x2="21" y2="6" />
+    <line x1="10" y1="12" x2="21" y2="12" />
+    <line x1="10" y1="18" x2="21" y2="18" />
+    <path d="M4 6h1v4" />
+    <path d="M4 10h2" />
+    <path d="M6 18H4c0-1 2-2 2-3s-1-1.5-2-1" />
+  </Svg>
+);
+
+export const QuoteIcon = (p: IconProps) => (
+  <Svg {...p}>
+    <path d="M17 6H3" />
+    <path d="M21 12H8" />
+    <path d="M21 18H8" />
+    <path d="M3 12v6" />
+  </Svg>
+);
+
+export const ExpandIcon = ({ expanded, size = 15 }: IconProps & { expanded: boolean }) => (
+  <Svg size={size}>
+    {expanded ? (
+      <>
+        <polyline points="4 14 10 14 10 20" />
+        <polyline points="20 10 14 10 14 4" />
+        <line x1="14" y1="10" x2="21" y2="3" />
+        <line x1="3" y1="21" x2="10" y2="14" />
+      </>
+    ) : (
+      <>
+        <polyline points="15 3 21 3 21 9" />
+        <polyline points="9 21 3 21 3 15" />
+        <line x1="21" y1="3" x2="14" y2="10" />
+        <line x1="3" y1="21" x2="10" y2="14" />
+      </>
+    )}
+  </Svg>
+);

package/app/vendor/markdown-editor/src/index.ts

@@ -0,0 +1,23 @@
+// Public API for @gogitcms/markdown-editor.
+export { default as MarkdownEditor } from "./MarkdownEditor";
+export { createMarkdownRenderField } from "./field";
+export type { MarkdownFieldArgs, MarkdownFieldOptions } from "./field";
+export type {
+  MarkdownEditorProps,
+  EditorFormat,
+  MarkdownFlavor,
+  EditorSource,
+  EditorTheme,
+} from "./types";
+
+// Format metadata + extension gating (shared with the schema layer).
+export {
+  FORMATS,
+  extensionOf,
+  supportsFileBody,
+} from "./formats/registry";
+export type { FormatMeta } from "./formats/registry";
+
+// Flavor registry + type, for hosts that want to introspect available dialects.
+export { FLAVORS, resolveFlavor } from "./flavors/registry";
+export type { Flavor } from "./flavors/types";