feat(parser): support SpreadElement in array literals (#2269)

* add IdentifierNodeParser to resolve const-bound identifiers
* add SpreadElementNodeParser to translate `...expr` to RestType
* register both parsers in factory chain
* add tests: array-literal-spread, array-rest-only

Author: alexchexes

factory/parser.ts

@@ -59,6 +59,8 @@ import type { SubNodeParser } from "../src/SubNodeParser.js";
 import { TopRefNodeParser } from "../src/TopRefNodeParser.js";
 import { SatisfiesNodeParser } from "../src/NodeParser/SatisfiesNodeParser.js";
 import { PromiseNodeParser } from "../src/NodeParser/PromiseNodeParser.js";
+import { SpreadElementNodeParser } from "../src/NodeParser/SpreadElementNodeParser.js";
+import { IdentifierNodeParser } from "../src/NodeParser/IdentifierNodeParser.js";
 
 export type ParserAugmentor = (parser: MutableParser) => void;
 
@@ -138,6 +140,8 @@ export function createParser(program: ts.Program, config: CompletedConfig, augme
         .addNodeParser(new NamedTupleMemberNodeParser(chainNodeParser))
         .addNodeParser(new OptionalTypeNodeParser(chainNodeParser))
         .addNodeParser(new RestTypeNodeParser(chainNodeParser))
+        .addNodeParser(new IdentifierNodeParser(chainNodeParser, typeChecker))
+        .addNodeParser(new SpreadElementNodeParser(chainNodeParser))
 
         .addNodeParser(new CallExpressionParser(typeChecker, chainNodeParser))
         .addNodeParser(new PropertyAccessExpressionParser(typeChecker, chainNodeParser))

src/NodeParser/IdentifierNodeParser.ts

@@ -0,0 +1,38 @@
+import ts from "typescript";
+import type { Context, NodeParser } from "../NodeParser.js";
+import type { SubNodeParser } from "../SubNodeParser.js";
+import type { BaseType } from "../Type/BaseType.js";
+import { UnknownNodeError } from "../Error/Errors.js";
+
+/**
+ * Resolves identifiers whose value is a compile-time constant
+ */
+export class IdentifierNodeParser implements SubNodeParser {
+    constructor(
+        private readonly childNodeParser: NodeParser,
+        private readonly checker: ts.TypeChecker,
+    ) {}
+
+    supportsNode(node: ts.Identifier): boolean {
+        return node.kind === ts.SyntaxKind.Identifier;
+    }
+
+    createType(node: ts.Identifier, context: Context): BaseType {
+        const symbol = this.checker.getSymbolAtLocation(node);
+        if (!symbol) {
+            throw new UnknownNodeError(node);
+        }
+
+        const decl = symbol.valueDeclaration;
+        if (
+            decl &&
+            ts.isVariableDeclaration(decl) &&
+            decl.initializer &&
+            ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const
+        ) {
+            return this.childNodeParser.createType(decl.initializer, context);
+        }
+
+        throw new UnknownNodeError(node);
+    }
+}

src/NodeParser/SpreadElementNodeParser.ts

@@ -0,0 +1,25 @@
+import ts from "typescript";
+import type { Context, NodeParser } from "../NodeParser.js";
+import type { SubNodeParser } from "../SubNodeParser.js";
+import type { ArrayType } from "../Type/ArrayType.js";
+import type { InferType } from "../Type/InferType.js";
+import type { TupleType } from "../Type/TupleType.js";
+import { RestType } from "../Type/RestType.js";
+
+/**
+ * Handles `...expr` inside an ArrayLiteralExpression.
+ * Turns it into RestType so TupleTypeFormatter can emit correct JSON-Schema.
+ */
+export class SpreadElementNodeParser implements SubNodeParser {
+    constructor(private readonly childNodeParser: NodeParser) {}
+
+    supportsNode(node: ts.SpreadElement): boolean {
+        return node.kind === ts.SyntaxKind.SpreadElement;
+    }
+
+    createType(node: ts.SpreadElement, context: Context) {
+        const inner = this.childNodeParser.createType(node.expression, context) as ArrayType | InferType | TupleType;
+
+        return new RestType(inner);
+    }
+}

test/valid-data-other.test.ts

@@ -83,6 +83,8 @@ describe("valid-data-other", () => {
     it("array-min-max-items-optional", assertValidSchema("array-min-max-items-optional", "MyType"));
     it("array-function-generics", assertValidSchema("array-function-generics", "*"));
     it("array-max-items-optional", assertValidSchema("array-max-items-optional", "MyType"));
+    it("array-literal-spread", assertValidSchema("array-literal-spread", "MyType"));
+    it("array-rest-only", assertValidSchema("array-rest-only", "MyType"));
     it("shorthand-array", assertValidSchema("shorthand-array", "MyType"));
     it("function-generic", assertValidSchema("function-generic", "MyType"));
 

test/valid-data/array-literal-spread/main.ts

@@ -0,0 +1,4 @@
+const BASE = ["foo", "bar"] as const;
+
+export const ALL = [...BASE, "baz"] as const;
+export type MyType = typeof ALL;

test/valid-data/array-literal-spread/schema.json

@@ -0,0 +1,25 @@
+{
+  "$ref": "#/definitions/MyType",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "MyType": {
+      "items": [
+        {
+          "const": "foo",
+          "type": "string"
+        },
+        {
+          "const": "bar",
+          "type": "string"
+        },
+        {
+          "const": "baz",
+          "type": "string"
+        }
+      ],
+      "maxItems": 3,
+      "minItems": 3,
+      "type": "array"
+    }
+  }
+}

test/valid-data/array-rest-only/main.ts

@@ -0,0 +1 @@
+export type MyType = [...string[]];

test/valid-data/array-rest-only/schema.json

@@ -0,0 +1,13 @@
+{
+  "$ref": "#/definitions/MyType",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "MyType": {
+      "items": {
+        "type": "string"
+      },
+      "minItems": 0,
+      "type": "array"
+    }
+  }
+}