fix: partial/required on tuple sequences (#1480)

ark/schema/structure/sequence.ts

@@ -1,6 +1,7 @@
 import {
 	append,
 	conflatenate,
+	conflatenateAll,
 	printable,
 	throwInternalError,
 	throwParseError,
@@ -481,6 +482,36 @@ export class SequenceNode extends BaseConstraint<Sequence.Declaration> {
 		return result
 	}
 
+	optionalize(): SequenceNode {
+		if (this.postfix) return this
+		if (!this.prefix?.length && !this.defaultables?.length) return this
+
+		const { prefix, defaultables, ...inner } = this.inner
+		return this.$.node("sequence", {
+			...inner,
+			optionals: conflatenateAll(
+				prefix,
+				defaultables?.map(d => d[0]),
+				inner.optionals
+			)
+		})
+	}
+
+	require(): SequenceNode {
+		if (this.postfix) return this
+		if (!this.optionals?.length && !this.defaultables?.length) return this
+
+		const { optionals, defaultables, ...inner } = this.inner
+		return this.$.node("sequence", {
+			...inner,
+			prefix: conflatenateAll(
+				inner.prefix,
+				defaultables?.map(d => d[0]),
+				optionals
+			)
+		})
+	}
+
 	// this depends on tuple so needs to come after it
 	expression: string = this.description
 

ark/schema/structure/structure.ts

@@ -564,19 +564,21 @@ export class StructureNode extends BaseConstraint<Structure.Declaration> {
 	}
 
 	optionalize(): StructureNode {
-		const { required, ...inner } = this.inner
+		const { required: _, sequence, ...inner } = this.inner
 		return this.$.node("structure", {
 			...inner,
+			...(sequence ? { sequence: sequence.optionalize() } : {}),
 			optional: this.props.map(prop =>
 				prop.hasKind("required") ? this.$.node("optional", prop.inner) : prop
 			)
 		})
 	}
 
 	require(): StructureNode {
-		const { optional, ...inner } = this.inner
+		const { optional: _, sequence, ...inner } = this.inner
 		return this.$.node("structure", {
 			...inner,
+			...(sequence ? { sequence: sequence.require() } : {}),
 			required: this.props.map(prop =>
 				prop.hasKind("optional") ?
 					{

ark/type/__tests__/keywords/partial.test.ts

@@ -35,4 +35,39 @@ contextualize(() => {
 
 		attest(T.expression).snap("{ [string]: number, bar?: 1, foo?: 1 }")
 	})
+
+	// https://github.com/arktypeio/arktype/issues/1480
+	it("tuple literal", () => {
+		const T = type(["'foo'", "'bar'"]).partial()
+		const Expected = type(["'foo'?", "'bar'?"])
+
+		attest<typeof Expected.t>(T.t)
+		attest<["foo"?, "bar"?]>(T.infer)
+		attest(T([])).equals([])
+		attest(T(["foo"])).equals(["foo"])
+		attest(T(["foo", "bar"])).equals(["foo", "bar"])
+	})
+
+	it("string syntax tuple", () => {
+		const tupleScope = scope({
+			tuple: ["'foo'", "'bar'"]
+		})
+
+		const T = tupleScope.type("Partial<tuple>")
+		const Expected = type(["'foo'?", "'bar'?"])
+
+		attest<typeof Expected.t>(T.t)
+		attest<["foo"?, "bar"?]>(T.infer)
+		attest(T.expression).equals(Expected.expression)
+	})
+
+	it("tuple with defaultable", () => {
+		const T = type(["string", "number = 5"]).partial()
+		const Expected = type(["string?", "number?"])
+
+		// https://github.com/arktypeio/arktype/issues/1160
+		// attest<typeof Expected.t>(T.t)
+		attest(T.expression).equals(Expected.expression)
+		attest(T([])).equals([])
+	})
 })

ark/type/__tests__/keywords/required.test.ts

@@ -48,4 +48,37 @@ contextualize(() => {
 
 		attest(T.expression).equals(Expected.expression)
 	})
+
+	// reverse of https://github.com/arktypeio/arktype/issues/1480
+	it("tuple literal", () => {
+		const T = type(["'foo'?", "'bar'?"]).required()
+		const Expected = type(["'foo'", "'bar'"])
+
+		attest<typeof Expected.t>(T.t)
+		attest<["foo", "bar"]>(T.infer)
+		attest(T.expression).equals(Expected.expression)
+		attest(T(["foo", "bar"])).equals(["foo", "bar"])
+	})
+
+	it("string syntax tuple", () => {
+		const tupleScope = scope({
+			tuple: ["'foo'?", "'bar'?"]
+		})
+		const T = tupleScope.type("Required<tuple>")
+		const Expected = type(["'foo'", "'bar'"])
+
+		attest<typeof Expected.t>(T.t)
+		attest<["foo", "bar"]>(T.infer)
+		attest(T.expression).equals(Expected.expression)
+		attest(T(["foo", "bar"])).equals(["foo", "bar"])
+	})
+
+	it("tuple with defaultable", () => {
+		const T = type(["string", "number = 5"]).required()
+		const Expected = type(["string", "number"])
+
+		// https://github.com/arktypeio/arktype/issues/1160
+		// attest<typeof Expected.t>(T.t)
+		attest(T.expression).equals(Expected.expression)
+	})
 })