skir-codemirror-plugin 1.0.2 → 1.0.4

package/src/codemirror/json_state.ts

@@ -9,6 +9,7 @@ import { parseJsonValue } from "../json/json_parser";
 import { validateSchema } from "../json/schema_validator";
 import type {
   JsonParseResult,
+  RecordDefinition,
   TypeDefinition,
   ValidationResult,
 } from "../json/types";
@@ -17,6 +18,8 @@ export interface JsonState {
   readonly parseResult: JsonParseResult;
   readonly validationResult?: ValidationResult;
   readonly source: string;
+  readonly schema: TypeDefinition;
+  readonly recordIdToDefinition: { [id: string]: RecordDefinition };
 }
 
 const updateJsonState = StateEffect.define<JsonState>();
@@ -58,7 +61,15 @@ export function ensureJsonState(
     validationResult = validateSchema(parseResult.value, schema);
   }
 
-  const newState: JsonState = { parseResult, validationResult, source };
+  const recordIdToDefinition = indexRecordDefinitions(schema, currentState);
+
+  const newState: JsonState = {
+    parseResult,
+    validationResult,
+    source,
+    schema,
+    recordIdToDefinition,
+  };
 
   // Update the state if it's different
   if (!currentState || currentState !== newState) {
@@ -139,21 +150,37 @@ export function debouncedJsonParser(schema: TypeDefinition): Extension[] {
               insert: edit.replacement,
             }));
 
+            const oldState = this.view.state.field(jsonStateField, false);
+            const recordIdToDefinition = indexRecordDefinitions(
+              schema,
+              oldState,
+            );
+
             this.view.dispatch({
               changes,
               effects: updateJsonState.of({
                 parseResult,
                 validationResult,
                 source,
+                schema,
+                recordIdToDefinition,
               }),
               scrollIntoView: true,
             });
           } else {
+            const oldState = this.view.state.field(jsonStateField, false);
+            const recordIdToDefinition = indexRecordDefinitions(
+              schema,
+              oldState,
+            );
+
             this.view.dispatch({
               effects: updateJsonState.of({
                 parseResult,
                 validationResult,
                 source,
+                schema,
+                recordIdToDefinition,
               }),
             });
           }
@@ -168,3 +195,19 @@ export function debouncedJsonParser(schema: TypeDefinition): Extension[] {
     ),
   ];
 }
+
+function indexRecordDefinitions(
+  schema: TypeDefinition,
+  oldState: JsonState | null | undefined,
+): {
+  [id: string]: RecordDefinition;
+} {
+  if (schema === oldState?.schema) {
+    return oldState.recordIdToDefinition;
+  }
+  const idToRecordDef: { [id: string]: RecordDefinition } = {};
+  for (const recordDef of schema.records) {
+    idToRecordDef[recordDef.id] = recordDef;
+  }
+  return idToRecordDef;
+}

package/src/index.ts

@@ -1,5 +1,6 @@
 export { createEditorState } from "./codemirror/create_editor_state";
 export type {
+  BuiltinThemeName,
   CreateEditorStateParams,
   CustomTheme,
 } from "./codemirror/create_editor_state";

package/src/json/json_parser.test.ts

@@ -63,6 +63,18 @@ describe("json_parser", () => {
     });
   });
 
+  it("tracks indent for top-level literal", () => {
+    expect(parseJsonValue("   true")).toMatch({
+      value: {
+        kind: "literal",
+        jsonCode: "true",
+        type: "boolean",
+        indent: 3,
+      },
+      errors: [],
+    });
+  });
+
   it("parses empty array", () => {
     expect(parseJsonValue("[]")).toMatch({
       value: { kind: "array", values: [] },
@@ -119,6 +131,45 @@ describe("json_parser", () => {
     });
   });
 
+  it("tracks indent from line leading spaces for field values", () => {
+    const result = parseJsonValue(`{
+  "a": 1,
+  "b": [
+    2
+  ]
+}`);
+
+    expect(result).toMatch({
+      value: {
+        kind: "object",
+        indent: 0,
+        keyValues: {
+          a: {
+            value: {
+              kind: "literal",
+              jsonCode: "1",
+              indent: 2,
+            },
+          },
+          b: {
+            value: {
+              kind: "array",
+              indent: 2,
+              values: [
+                {
+                  kind: "literal",
+                  jsonCode: "2",
+                  indent: 4,
+                },
+              ],
+            },
+          },
+        },
+      },
+      errors: [],
+    });
+  });
+
   it("parses arrays with whitespace", () => {
     expect(parseJsonValue(" [ 1 ] ")).toMatch({
       value: {

package/src/json/json_parser.ts

@@ -33,6 +33,7 @@ export function parseJsonValue(input: string): JsonParseResult {
 interface JsonToken {
   segment: Segment;
   jsonCode: string;
+  indent: number;
 }
 
 interface JsonTokens {
@@ -43,16 +44,29 @@ interface JsonTokens {
 function tokenize(input: string): JsonTokens | JsonError {
   const tokens: JsonToken[] = [];
   let pos = 0;
+  let lineIndent = 0;
+  let lineHasContent = false;
 
   const whitespaceRegex = /[ \t\r\n]*/y;
   const tokenRegex =
     /([[\]{}:,]|(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)|false|true|null|("(((?=\\)\\(["\\/ bfnrt]|u[0-9a-fA-F]{4}))|[^"\\\0-\x1F\x7F]+)*")|$)/y;
 
   while (true) {
+    const beforeWhitespacePos = pos;
     whitespaceRegex.lastIndex = pos;
     whitespaceRegex.exec(input);
     pos = whitespaceRegex.lastIndex;
 
+    for (let i = beforeWhitespacePos; i < pos; ++i) {
+      const ch = input[i];
+      if (ch === "\n") {
+        lineIndent = 0;
+        lineHasContent = false;
+      } else if (!lineHasContent && (ch === " " || ch === "\t")) {
+        lineIndent++;
+      }
+    }
+
     tokenRegex.lastIndex = pos;
     const tokenMatch = tokenRegex.exec(input);
     if (tokenMatch) {
@@ -61,9 +75,16 @@ function tokenize(input: string): JsonTokens | JsonError {
         start: pos,
         end: pos + tokenText.length,
       };
-      const token: JsonToken = { segment, jsonCode: tokenText };
+      const token: JsonToken = {
+        segment,
+        jsonCode: tokenText,
+        indent: lineIndent,
+      };
       pos = tokenRegex.lastIndex;
       tokens.push(token);
+      if (tokenText !== "") {
+        lineHasContent = true;
+      }
       if (tokenText === "") {
         return {
           kind: "tokens",
@@ -96,6 +117,8 @@ class JsonParser {
     const token = this.peekToken();
     const firstChar = token.jsonCode ? token.jsonCode[0] : "";
 
+    const { indent } = token;
+
     switch (firstChar) {
       case "[":
         return this.parseArray();
@@ -109,6 +132,7 @@ class JsonParser {
           segment: token.segment,
           jsonCode: "null",
           type: "null",
+          indent,
         };
       case "f":
         this.nextToken();
@@ -118,6 +142,7 @@ class JsonParser {
           segment: token.segment,
           jsonCode: "false",
           type: "boolean",
+          indent,
         };
       case "t":
         this.nextToken();
@@ -127,6 +152,7 @@ class JsonParser {
           segment: token.segment,
           jsonCode: "true",
           type: "boolean",
+          indent,
         };
       case '"':
         this.nextToken();
@@ -136,6 +162,7 @@ class JsonParser {
           segment: token.segment,
           jsonCode: token.jsonCode,
           type: "string",
+          indent,
         };
       case "0":
       case "1":
@@ -155,6 +182,7 @@ class JsonParser {
           segment: token.segment,
           jsonCode: token.jsonCode,
           type: "number",
+          indent,
         };
     }
 
@@ -169,6 +197,7 @@ class JsonParser {
 
   private parseArray(): JsonArray {
     const leftBracket = this.nextToken();
+    const { indent } = leftBracket;
     const values: JsonValue[] = [];
     while (true) {
       if (this.peekToken().jsonCode === "]") {
@@ -181,6 +210,7 @@ class JsonParser {
             end: rightBracket.segment.end,
           },
           values,
+          indent,
         };
       }
       if (this.peekToken().jsonCode === "}") {
@@ -198,6 +228,7 @@ class JsonParser {
             end: wrongBracket.segment.end,
           },
           values,
+          indent,
         };
       }
       if (this.peekToken().jsonCode === "") {
@@ -211,6 +242,7 @@ class JsonParser {
             end: this.peekToken().segment.start,
           },
           values,
+          indent,
         };
       }
       const value = this.parseValueOrSkip();
@@ -233,6 +265,7 @@ class JsonParser {
 
   private parseObject(): JsonObject {
     const leftBracket = this.nextToken();
+    const { indent } = leftBracket;
     const keyValues: { [key: string]: JsonKeyValue } = {};
     const allKeys: JsonKey[] = [];
     while (true) {
@@ -247,6 +280,7 @@ class JsonParser {
           },
           keyValues,
           allKeys,
+          indent,
         };
       }
       if (this.peekToken().jsonCode === "]") {
@@ -265,6 +299,7 @@ class JsonParser {
           },
           keyValues,
           allKeys,
+          indent,
         };
       }
       if (this.peekToken().jsonCode === "") {
@@ -279,6 +314,7 @@ class JsonParser {
           },
           keyValues,
           allKeys,
+          indent,
         };
       }
       const keyToken = this.peekToken();

package/src/json/schema_validator.test.ts

@@ -152,7 +152,7 @@ describe("schema_validator", () => {
     ]);
   });
 
-  it("validates enum (string literal)", () => {
+  it("validates enum (string literal accepts lower and upper)", () => {
     const schema: TypeDefinition = {
       type: { kind: "record", value: "MyEnum" },
       records: [
@@ -160,14 +160,100 @@ describe("schema_validator", () => {
           kind: "enum",
           id: "MyEnum",
           variants: [
-            { name: "First", number: 1 },
-            { name: "Second", number: 2 },
+            { name: "FOO", number: 1 },
+            { name: "BAR", number: 2 },
           ],
         },
       ],
     };
-    const result = validateSchema(parse('"First"'), schema);
-    expect(result).toMatch({ errors: [] });
+    const lowerResult = validateSchema(parse('"foo"'), schema);
+    expect(lowerResult).toMatch({ errors: [] });
+
+    const upperResult = validateSchema(parse('"FOO"'), schema);
+    expect(upperResult).toMatch({ errors: [] });
+  });
+
+  it("rejects mixed-case enum string literal", () => {
+    const schema: TypeDefinition = {
+      type: { kind: "record", value: "MyEnum" },
+      records: [
+        {
+          kind: "enum",
+          id: "MyEnum",
+          variants: [{ name: "FOO", number: 1 }],
+        },
+      ],
+    };
+
+    const result = validateSchema(parse('"Foo"'), schema);
+    expect(result.errors).toMatch([
+      {
+        message: "Unknown variant",
+      },
+    ]);
+  });
+
+  it("accepts UNKNOWN and unknown enum literals", () => {
+    const schema: TypeDefinition = {
+      type: { kind: "record", value: "MyEnum" },
+      records: [
+        {
+          kind: "enum",
+          id: "MyEnum",
+          variants: [{ name: "FOO", number: 1 }],
+        },
+      ],
+    };
+
+    expect(validateSchema(parse('"UNKNOWN"'), schema)).toMatch({ errors: [] });
+    expect(validateSchema(parse('"unknown"'), schema)).toMatch({ errors: [] });
+
+    const mixedCaseResult = validateSchema(parse('"Unknown"'), schema);
+    expect(mixedCaseResult.errors).toMatch([
+      {
+        message: "Unknown variant",
+      },
+    ]);
+  });
+
+  it("validates enum object kind in lower and upper", () => {
+    const schema: TypeDefinition = {
+      type: { kind: "record", value: "MyEnum" },
+      records: [
+        {
+          kind: "enum",
+          id: "MyEnum",
+          variants: [
+            {
+              name: "COMPLEX",
+              number: 1,
+              type: { kind: "primitive", value: "int32" },
+            },
+          ],
+        },
+      ],
+    };
+
+    expect(
+      validateSchema(parse('{"kind": "complex", "value": 123}'), schema),
+    ).toMatch({
+      errors: [],
+    });
+    expect(
+      validateSchema(parse('{"kind": "COMPLEX", "value": 123}'), schema),
+    ).toMatch({
+      errors: [],
+    });
+
+    const mixedCaseResult = validateSchema(
+      parse('{"kind": "Complex", "value": 123}'),
+      schema,
+    );
+    expect(mixedCaseResult.errors).toMatch([
+      {
+        message: "Expected: lowercase or uppercase variant name",
+      },
+    ]);
   });
 
   it("reports unknown enum variant", () => {
@@ -189,6 +275,81 @@ describe("schema_validator", () => {
     ]);
   });
 
+  it("stores enum definition in type hint for UNKNOWN enum literal", () => {
+    const schema: TypeDefinition = {
+      type: { kind: "record", value: "MyEnum" },
+      records: [
+        {
+          kind: "enum",
+          id: "MyEnum",
+          variants: [
+            { name: "First", number: 1 },
+            { name: "Second", number: 2 },
+          ],
+        },
+      ],
+    };
+
+    const result = validateSchema(parse('"UNKNOWN"'), schema);
+    expect(result.errors).toMatch([]);
+    if (!result.rootTypeHint) {
+      throw new Error("Expected root type hint");
+    }
+    expect(result.rootTypeHint.enumDefinition).toMatch({
+      kind: "enum",
+      id: "MyEnum",
+      variants: [
+        { name: "First", number: 1 },
+        { name: "Second", number: 2 },
+      ],
+    });
+  });
+
+  it("stores enum definition in nested UNKNOWN enum field hint", () => {
+    const schema: TypeDefinition = {
+      type: { kind: "record", value: "MyStruct" },
+      records: [
+        {
+          kind: "struct",
+          id: "MyStruct",
+          fields: [
+            {
+              name: "status",
+              number: 1,
+              type: { kind: "record", value: "MyEnum" },
+            },
+          ],
+        },
+        {
+          kind: "enum",
+          id: "MyEnum",
+          variants: [
+            { name: "First", number: 1 },
+            { name: "Second", number: 2 },
+          ],
+        },
+      ],
+    };
+
+    const result = validateSchema(parse('{"status": "UNKNOWN"}'), schema);
+    expect(result.errors).toMatch([]);
+    if (!result.rootTypeHint) {
+      throw new Error("Expected root type hint");
+    }
+    if (result.rootTypeHint.childHints.length !== 1) {
+      throw new Error("Expected one child type hint");
+    }
+    const statusHint = result.rootTypeHint.childHints[0];
+    expect(statusHint.enumDefinition).toMatch({
+      kind: "enum",
+      id: "MyEnum",
+      variants: [
+        { name: "First", number: 1 },
+        { name: "Second", number: 2 },
+      ],
+    });
+  });
+
   it("validates enum (object with kind)", () => {
     const schema: TypeDefinition = {
       type: { kind: "record", value: "MyEnum" },

package/src/json/schema_validator.ts

@@ -1,6 +1,7 @@
 import { primitiveSerializer } from "skir-client";
 import { toJson } from "./to_json";
 import type {
+  EnumDefinition,
   FieldDefinition,
   Hint,
   JsonError,
@@ -60,7 +61,9 @@ class SchemaValidator {
     const { idToRecordDef, typeHintStack } = this;
     value.expectedType = schema;
     // For every call to pushTypeHint() there emust be one call to typeHintStack.pop()
-    const pushTypeHint = (): void => {
+    const pushTypeHint = (options?: {
+      enumDefinition?: EnumDefinition;
+    }): void => {
       const typeDesc = getTypeDesc(optionalSchema ?? schema);
       const typeDoc = getTypeDoc(schema, idToRecordDef);
       const message = [typeDesc];
@@ -78,6 +81,7 @@ class SchemaValidator {
         message: message.length === 1 ? message[0] : message,
         valueContext: { value, path },
         childHints: [],
+        enumDefinition: options?.enumDefinition,
       };
       if (typeHintStack.length) {
         const topOfStack = typeHintStack[typeHintStack.length - 1];
@@ -187,7 +191,8 @@ class SchemaValidator {
           // Enum
           const nameToVariantDef: { [name: string]: VariantDefinition } = {};
           recordDef.variants.forEach((variant) => {
-            nameToVariantDef[variant.name] = variant;
+            nameToVariantDef[variant.name.toLowerCase()] = variant;
+            nameToVariantDef[variant.name.toUpperCase()] = variant;
           });
           if (value.kind === "object") {
             pushTypeHint();
@@ -196,8 +201,14 @@ class SchemaValidator {
           } else if (value.kind === "literal" && value.type === "string") {
             const name = JSON.parse(value.jsonCode);
             const fieldDef = nameToVariantDef[name];
-            if (name === "UNKNOWN" || fieldDef) {
-              pushTypeHint();
+            if (fieldDef && fieldDef.type) {
+              this.errors.push({
+                kind: "error",
+                segment: value.segment,
+                message: "Expected: uppercase variant name",
+              });
+            } else if (name === "unknown" || name === "UNKNOWN" || fieldDef) {
+              pushTypeHint({ enumDefinition: recordDef });
               typeHintStack.pop();
             } else {
               this.errors.push({
@@ -246,11 +257,13 @@ class SchemaValidator {
       return;
     }
     const kind: string = JSON.parse(kindKv.value.jsonCode);
-    if (kind !== kind.toLowerCase()) {
+    const isLowercase = kind === kind.toLowerCase();
+    const isUppercase = kind === kind.toUpperCase();
+    if (!isLowercase && !isUppercase) {
       this.errors.push({
         kind: "error",
         segment: kindKv.value.segment,
-        message: "Expected: lowercase variant name",
+        message: "Expected: lowercase or uppercase variant name",
       });
       return;
     }
@@ -492,13 +505,13 @@ function isFloat(value: JsonValue): boolean {
   }
   if (value.type === "number") {
     return true;
-  } else if (value.type === "string") {
-    try {
-      primitiveSerializer("float64").fromJsonCode(value.jsonCode);
-      return true;
-    } catch {
-      return false;
-    }
+  } else if (
+    value.type === "string" &&
+    (value.jsonCode === '"NaN"' ||
+      value.jsonCode === '"Infinity"' ||
+      value.jsonCode === '"-Infinity"')
+  ) {
+    return true;
   } else {
     return false;
   }

package/src/json/to_json.ts

@@ -22,7 +22,7 @@ export function toJson(value: JsonValue): Json {
 export function makeJsonTemplate(
   type: TypeSignature,
   idToRecordDef: { [id: string]: RecordDefinition },
-  depth?: "depth",
+  nested?: "nested",
 ): Json {
   switch (type.kind) {
     case "array": {
@@ -34,13 +34,13 @@ export function makeJsonTemplate(
     case "record": {
       const recordDef = idToRecordDef[type.value]!;
       if (recordDef.kind === "struct") {
-        if (depth) {
+        if (nested) {
           return {};
         }
         return Object.fromEntries(
           recordDef.fields.map((field) => [
             field.name,
-            makeJsonTemplate(field.type!, idToRecordDef, "depth"),
+            makeJsonTemplate(field.type!, idToRecordDef, "nested"),
           ]),
         );
       } else {

package/src/json/types.ts

@@ -39,6 +39,7 @@ export interface JsonArray {
   /// From '[' to ']' included.
   readonly segment: Segment;
   readonly values: JsonValue[];
+  readonly indent: number;
   expectedType?: TypeSignature;
 }
 
@@ -63,6 +64,7 @@ export interface JsonObject {
   readonly keyValues: { [key: string]: JsonKeyValue };
   /// Includes "broken" keys which produced a parsing error.
   readonly allKeys: readonly JsonKey[];
+  readonly indent: number;
   expectedType?: TypeSignature;
 }
 
@@ -73,6 +75,7 @@ export interface JsonLiteral {
   readonly segment: Segment;
   readonly jsonCode: string;
   readonly type: "boolean" | "null" | "number" | "string";
+  readonly indent: number;
   expectedType?: TypeSignature;
 }
 
@@ -223,6 +226,10 @@ export interface TypeHint {
   readonly valueContext: JsonValueContext;
   /// In order. All are included in 'valueContext.value.segment'.
   readonly childHints: readonly TypeHint[];
+  /// Set if the expected type is an enum and the value is a literal string.
+  /// In that case, the editor can show a dropdown with the possible variants
+  /// of the enum.
+  readonly enumDefinition?: EnumDefinition;
 }
 
 export type Hint =