skir-codemirror-plugin 0.9.0

package/src/codemirror/status_bar.ts

@@ -0,0 +1,137 @@
+import { EditorView, Panel, showPanel } from "@codemirror/view";
+import { Path, TypeHint } from "../json/types";
+import { jsonStateField } from "./json_state";
+
+function createStatusBarPanel(view: EditorView): Panel {
+  const dom = document.createElement("div");
+  dom.className = "cm-status-bar";
+
+  function updateCursor(): void {
+    const pos = view.state.selection.main.head;
+
+    const jsonState = view.state.field(jsonStateField, false);
+    const validationResult = jsonState?.validationResult;
+    const rootTypeHint = validationResult?.rootTypeHint;
+    const nodes: Node[] = [];
+    if (rootTypeHint) {
+      const typeHint = findTypeHint(pos, rootTypeHint);
+      if (typeHint) {
+        const { pathToTypeHint } = validationResult;
+        const builder = new NavigatorNodesBuilder(pathToTypeHint, view);
+        builder.appendNodesForPath(typeHint.valueContext.path);
+        nodes.push(...builder.nodes);
+        nodes.reverse();
+      }
+    }
+    dom.replaceChildren(...nodes);
+  }
+
+  updateCursor();
+
+  return {
+    dom,
+    update(update): void {
+      if (update.selectionSet) {
+        updateCursor();
+      }
+    },
+    top: false,
+  };
+}
+
+export function statusBar(): ReturnType<typeof showPanel.of> {
+  return showPanel.of(createStatusBarPanel);
+}
+
+function findTypeHint(pos: number, root: TypeHint): TypeHint | undefined {
+  // Check if pos is within the root's segment
+  const segment = root.valueContext.value.segment;
+  if (pos < segment.start || pos > segment.end) {
+    return undefined;
+  }
+
+  // Binary search through childHints to find a child containing pos
+  let left = 0;
+  let right = root.childHints.length - 1;
+  let foundChild: TypeHint | undefined;
+
+  while (left <= right) {
+    const mid = Math.floor((left + right) / 2);
+    const child = root.childHints[mid];
+    const childSegment = child.valueContext.value.segment;
+
+    if (pos < childSegment.start) {
+      right = mid - 1;
+    } else if (pos > childSegment.end) {
+      left = mid + 1;
+    } else {
+      // pos is within this child's segment
+      foundChild = child;
+      break;
+    }
+  }
+
+  // If we found a child containing pos, recursively search deeper
+  if (foundChild) {
+    const deeperHint = findTypeHint(pos, foundChild);
+    return deeperHint !== undefined ? deeperHint : foundChild;
+  }
+
+  // No child contains pos, so root is the deepest match
+  return root;
+}
+
+class NavigatorNodesBuilder {
+  readonly nodes: Node[] = [];
+
+  constructor(
+    private readonly pathToTypeHint: ReadonlyMap<Path, TypeHint>,
+    private readonly view: EditorView,
+  ) {}
+
+  appendNodesForPath(path: Path): void {
+    const typeHint = this.pathToTypeHint.get(path)!;
+    const pos = typeHint.valueContext.value.segment.start;
+    const link = document.createElement("a");
+    link.className = "cm-status-bar-link";
+
+    link.addEventListener("click", (e) => {
+      e.preventDefault();
+      this.view.dispatch({
+        selection: { anchor: pos, head: pos },
+        scrollIntoView: true,
+      });
+      this.view.focus();
+    });
+
+    switch (path.kind) {
+      case "root": {
+        link.append("root");
+        this.nodes.push(link);
+        break;
+      }
+      case "array-item": {
+        this.appendNodesForPath(path.arrayPath);
+        if (path.key != null) {
+          link.append(`[${path.index}|${path.key}]`);
+        } else {
+          link.append(`[${path.index}]`);
+        }
+        this.nodes.push(link);
+        break;
+      }
+      case "field-value": {
+        this.appendNodesForPath(path.structPath);
+        link.append(`.${path.fieldName}`);
+        this.nodes.push(link);
+        break;
+      }
+      case "variant-value": {
+        this.appendNodesForPath(path.enumPath);
+        link.append(`.value("${path.variantName}")`);
+        this.nodes.push(link);
+        break;
+      }
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export { createEditorState } from "./codemirror/create_editor_state";
+export type {
+  CreateEditorStateParams,
+  CustomTheme,
+} from "./codemirror/create_editor_state";
+export type { Json } from "./json/types";

package/src/json/json_parser.test.ts

@@ -0,0 +1,360 @@
+import { expect } from "buckwheat";
+import { describe, it } from "mocha";
+import { parseJsonValue } from "./json_parser.js";
+
+describe("json_parser", () => {
+  it("parses true", () => {
+    expect(parseJsonValue("true")).toMatch({
+      value: {
+        kind: "literal",
+        jsonCode: "true",
+        type: "boolean",
+      },
+      errors: [],
+      edits: [],
+    });
+  });
+
+  it("parses false", () => {
+    expect(parseJsonValue("false")).toMatch({
+      value: {
+        kind: "literal",
+        jsonCode: "false",
+        type: "boolean",
+      },
+      errors: [],
+      edits: [],
+    });
+  });
+
+  it("parses null", () => {
+    expect(parseJsonValue("null")).toMatch({
+      value: {
+        kind: "literal",
+        jsonCode: "null",
+        type: "null",
+      },
+      errors: [],
+      edits: [],
+    });
+  });
+
+  it("parses number", () => {
+    expect(parseJsonValue("123.45")).toMatch({
+      value: {
+        kind: "literal",
+        jsonCode: "123.45",
+        type: "number",
+      },
+      errors: [],
+      edits: [],
+    });
+  });
+
+  it("parses string", () => {
+    expect(parseJsonValue('"hello"')).toMatch({
+      value: {
+        kind: "literal",
+        jsonCode: '"hello"',
+        type: "string",
+      },
+      errors: [],
+      edits: [],
+    });
+  });
+
+  it("parses empty array", () => {
+    expect(parseJsonValue("[]")).toMatch({
+      value: { kind: "array", values: [] },
+      errors: [],
+      edits: [],
+    });
+  });
+
+  it("parses array with values", () => {
+    expect(parseJsonValue("[1, true]")).toMatch({
+      value: {
+        kind: "array",
+        values: [
+          { kind: "literal", jsonCode: "1", type: "number" },
+          { kind: "literal", jsonCode: "true", type: "boolean" },
+        ],
+      },
+      errors: [],
+      edits: [
+        { segment: { start: 1, end: 1 }, replacement: "\n  " },
+        { segment: { start: 3, end: 4 }, replacement: "\n  " },
+        { segment: { start: 8, end: 8 }, replacement: "\n" },
+      ],
+    });
+  });
+
+  it("parses empty object", () => {
+    expect(parseJsonValue("{}")).toMatch({
+      value: {
+        kind: "object",
+        keyValues: {},
+      },
+      errors: [],
+      edits: [],
+    });
+  });
+
+  it("parses object with values", () => {
+    expect(parseJsonValue('{"a": 1}')).toMatch({
+      value: {
+        kind: "object",
+        keyValues: {
+          a: {
+            key: "a",
+            value: { kind: "literal", jsonCode: "1", type: "number" },
+          },
+        },
+      },
+      errors: [],
+      edits: [
+        { segment: { start: 1, end: 1 }, replacement: "\n  " },
+        { segment: { start: 7, end: 7 }, replacement: "\n" },
+      ],
+    });
+  });
+
+  it("parses arrays with whitespace", () => {
+    expect(parseJsonValue(" [ 1 ] ")).toMatch({
+      value: {
+        kind: "array",
+        values: [{ kind: "literal", jsonCode: "1" }],
+      },
+      errors: [],
+      edits: [
+        { segment: { start: 0, end: 1 }, replacement: "" },
+        { segment: { start: 2, end: 3 }, replacement: "\n  " },
+        { segment: { start: 4, end: 5 }, replacement: "\n" },
+        { segment: { start: 6, end: 7 }, replacement: "" },
+      ],
+    });
+  });
+
+  it("reports error for invalid token", () => {
+    expect(parseJsonValue("@")).toMatch({
+      value: undefined,
+      errors: [
+        {
+          kind: "error",
+          message: "not a token",
+          segment: { start: 0, end: 1 },
+        },
+      ],
+      edits: [],
+    });
+  });
+
+  it("reports error for unclosed array", () => {
+    expect(parseJsonValue("[")).toMatch({
+      value: { kind: "array", values: [] },
+      errors: [
+        {
+          kind: "error",
+          message: "expected: ']'",
+          segment: { start: 1, end: 1 },
+        },
+      ],
+      edits: [{ segment: { start: 1, end: 1 }, replacement: "\n  " }],
+    });
+  });
+
+  it("parses object with missing value (lenient)", () => {
+    expect(
+      parseJsonValue(`{
+      "foo": true,
+      "bar"
+    }`),
+    ).toMatch({
+      value: {
+        kind: "object",
+        keyValues: {
+          foo: {
+            key: "foo",
+            value: { kind: "literal", jsonCode: "true", type: "boolean" },
+          },
+        },
+      },
+      errors: [
+        {
+          kind: "error",
+          message: "expected: ':'",
+          segment: { start: 37, end: 38 },
+        },
+      ],
+    });
+  });
+
+  it("parses object with trailing comma (lenient)", () => {
+    expect(
+      parseJsonValue(`{
+      "a": 1,
+      "b": 2,
+    }`),
+    ).toMatch({
+      value: {
+        kind: "object",
+        keyValues: {
+          a: {
+            key: "a",
+            value: { kind: "literal", jsonCode: "1", type: "number" },
+          },
+          b: {
+            key: "b",
+            value: { kind: "literal", jsonCode: "2", type: "number" },
+          },
+        },
+      },
+      errors: [],
+      edits: [
+        { segment: { start: 1, end: 8 }, replacement: "\n  " },
+        { segment: { start: 15, end: 22 }, replacement: "\n  " },
+        { segment: { start: 28, end: 29 }, replacement: "" },
+        { segment: { start: 29, end: 34 }, replacement: "\n" },
+      ],
+    });
+  });
+
+  it("parses array with trailing comma (lenient)", () => {
+    expect(parseJsonValue(`[1, 2,]`)).toMatch({
+      value: {
+        kind: "array",
+        values: [
+          { kind: "literal", jsonCode: "1", type: "number" },
+          { kind: "literal", jsonCode: "2", type: "number" },
+        ],
+      },
+      errors: [],
+      edits: [
+        { segment: { start: 1, end: 1 }, replacement: "\n  " },
+        { segment: { start: 3, end: 4 }, replacement: "\n  " },
+        { segment: { start: 5, end: 6 }, replacement: "" },
+        { segment: { start: 6, end: 6 }, replacement: "\n" },
+      ],
+    });
+  });
+
+  it("parses array without commas (adds commas via edits)", () => {
+    expect(parseJsonValue("[1 2 3]")).toMatch({
+      value: {
+        kind: "array",
+        values: [
+          { kind: "literal", jsonCode: "1", type: "number" },
+          { kind: "literal", jsonCode: "2", type: "number" },
+          { kind: "literal", jsonCode: "3", type: "number" },
+        ],
+      },
+      errors: [],
+      edits: [
+        { segment: { start: 1, end: 1 }, replacement: "\n  " },
+        { segment: { start: 2, end: 3 }, replacement: ",\n  " },
+        { segment: { start: 4, end: 5 }, replacement: ",\n  " },
+        { segment: { start: 6, end: 6 }, replacement: "\n" },
+      ],
+    });
+  });
+
+  it("parses object without commas (adds commas via edits)", () => {
+    expect(parseJsonValue('{"a": 1 "b": 2}')).toMatch({
+      value: {
+        kind: "object",
+        keyValues: {
+          a: {
+            key: "a",
+            value: { kind: "literal", jsonCode: "1", type: "number" },
+          },
+          b: {
+            key: "b",
+            value: { kind: "literal", jsonCode: "2", type: "number" },
+          },
+        },
+      },
+      errors: [],
+      edits: [
+        { segment: { start: 1, end: 1 }, replacement: "\n  " },
+        { segment: { start: 7, end: 8 }, replacement: ",\n  " },
+        { segment: { start: 14, end: 14 }, replacement: "\n" },
+      ],
+    });
+  });
+
+  it("parses object with key missing colon (no infinite loop)", () => {
+    const result = parseJsonValue(`
+      {
+        "x": 0,
+        ""
+        "y": 0
+      }`);
+    // Should parse without hanging
+    // Note: The empty key without colon causes skip() to consume "y": 0
+    expect(result).toMatch({
+      value: {
+        kind: "object",
+        keyValues: {
+          x: {
+            key: "x",
+            value: { kind: "literal", jsonCode: "0", type: "number" },
+          },
+        },
+        allKeys: [
+          {
+            key: "x",
+          },
+          {
+            key: "",
+          },
+          {
+            key: "y",
+          },
+        ],
+      },
+      errors: [
+        {
+          kind: "error",
+          message: "expected: ':'",
+        },
+      ],
+    });
+  });
+
+  it("parses object with double comma (no infinite loop)", () => {
+    const result = parseJsonValue('{"x": 1, , "y": 2}');
+    // Should parse without hanging - the double comma should be handled
+    expect(result.value).toMatch({
+      kind: "object",
+      keyValues: {
+        x: {
+          key: "x",
+          value: { kind: "literal", jsonCode: "1", type: "number" },
+        },
+        y: {
+          key: "y",
+          value: { kind: "literal", jsonCode: "2", type: "number" },
+        },
+      },
+    });
+    // Should have error for the unexpected comma
+    expect(result.errors.length > 0).toBe(true);
+  });
+
+  it("parses array with invalid element followed by comma (no infinite loop)", () => {
+    const result = parseJsonValue(`[
+  1,
+  @
+  2
+]`);
+    // Invalid token @ causes tokenization error
+    expect(result.value).toBe(undefined);
+    // Should have error for invalid token
+    expect(result.errors).toMatch([
+      {
+        kind: "error",
+        message: "not a token",
+      },
+    ]);
+  });
+});