fix: drop labels from single-source constructors

Update DOMMatrix, DOMMatrixReadOnly, Path2D, and ReadableStream single-source constructor overloads to take direct unlabeled arguments.

Refresh compile-coverage tests and contributor documentation to match the constructor naming convention.

Author: jderochervlk

docs/content/docs/contributing/api-modelling.mdx

@@ -88,12 +88,14 @@ And if a constructor really does have a default form, split it instead of hiding
 external make: unit => domMatrix = "DOMMatrix"
 
 @new
-external fromString: (~init: string) => domMatrix = "DOMMatrix"
+external fromString: string => domMatrix = "DOMMatrix"
 
 @new
-external fromArray: (~init: array<float>) => domMatrix = "DOMMatrix"
+external fromArray: array<float> => domMatrix = "DOMMatrix"
 ```
 
+Single-source constructor variants should take the source value directly without a label.
+
 Keep `makeWith*` names for non-default convenience constructors that are not part of a source-type overload family.
 
 Constructor naming is currently verified with compile-coverage tests. Runtime verification for these constructor families will be added later when the Vitest and happy-dom harness lands.

docs/content/docs/contributing/documentation.mdx

@@ -48,24 +48,25 @@ external fetch: (window, string, ~init: requestInit=?)
 
 Constructor overloads should use the same structure, but make the differentiating input shape explicit.
 Link ReScript stdlib types such as `string`, `array<'a>`, `ArrayBuffer.t`, and `DataView.t`, and link project-local records or aliases when the constructor takes one of those shapes.
+If a constructor variant has a single source input, show it as a direct unlabeled argument in both the signature and example.
 
 ````ReScript
 /*
-`fromArray(~init: array<float>)`
+`fromArray(array<float>)`
 
 The DOMMatrix() constructor creates a new DOMMatrix from an array of matrix component values.
 
 Source shape:
-- `init`: ReScript [array](https://rescript-lang.org/docs/manual/api/stdlib/array) of numeric values accepted by MDN [DOMMatrix()](https://developer.mozilla.org/docs/Web/API/DOMMatrix/DOMMatrix).
+- ReScript [array](https://rescript-lang.org/docs/manual/api/stdlib/array) of numeric values accepted by MDN [DOMMatrix()](https://developer.mozilla.org/docs/Web/API/DOMMatrix/DOMMatrix).
 
 ```res
-let matrix = DOMMatrix.fromArray(~init=[1., 0., 0., 1., 0., 0.])
+let matrix = DOMMatrix.fromArray([1., 0., 0., 1., 0., 0.])
 ```
 
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/DOMMatrix)
 */
 @new
-external fromArray: (~init: array<float>) => domMatrix = "DOMMatrix"
+external fromArray: array<float> => domMatrix = "DOMMatrix"
 ````
 
 For now, these examples stay compile-coverage oriented. Runtime verification of constructor behavior will be handled later via Vitest and happy-dom.

packages/Canvas/src/Path2D.res

@@ -18,38 +18,38 @@ let path = Path2D.make()
 external make: unit => Types.path2D = "Path2D"
 
 /**
-`fromPath2D(~path: Path2D.t)`
+`fromPath2D(path2D)`
 
 The Path2D() constructor creates a new Path2D object by copying another Path2D source.
 
 Source shape:
 - local [`Path2D.t`](#t) mapped to MDN [Path2D](https://developer.mozilla.org/docs/Web/API/Path2D).
 
 ```res
-let copiedPath = Path2D.fromPath2D(~path=existingPath)
+let copiedPath = Path2D.fromPath2D(existingPath)
 ```
 
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/Path2D)
 */
 @new
-external fromPath2D: (~path: Types.path2D) => Types.path2D = "Path2D"
+external fromPath2D: Types.path2D => Types.path2D = "Path2D"
 
 /**
-`fromString(~path: string)`
+`fromString(string)`
 
 The Path2D() constructor creates a new Path2D object from SVG path data text.
 
 Source shape:
-- `path`: ReScript [string](https://rescript-lang.org/docs/manual/primitive-types/#string) containing SVG path data accepted by MDN [Path2D()](https://developer.mozilla.org/docs/Web/API/Path2D/Path2D).
+- ReScript [string](https://rescript-lang.org/docs/manual/primitive-types/#string) containing SVG path data accepted by MDN [Path2D()](https://developer.mozilla.org/docs/Web/API/Path2D/Path2D).
 
 ```res
-let path = Path2D.fromString(~path="M0 0 L10 10")
+let path = Path2D.fromString("M0 0 L10 10")
 ```
 
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/Path2D)
 */
 @new
-external fromString: (~path: string) => Types.path2D = "Path2D"
+external fromString: string => Types.path2D = "Path2D"
 
 /**
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/CanvasRenderingContext2D/closePath)

packages/DOM/src/DOMMatrix.res

@@ -16,38 +16,38 @@ let matrix = DOMMatrix.make()
 external make: unit => Types.domMatrix = "DOMMatrix"
 
 /**
-`fromString(~init: string)`
+`fromString(string)`
 
 The DOMMatrix() constructor creates a new DOMMatrix from a transform string.
 
 Source shape:
-- `init`: ReScript [string](https://rescript-lang.org/docs/manual/primitive-types/#string) accepted by MDN [DOMMatrix()](https://developer.mozilla.org/docs/Web/API/DOMMatrix/DOMMatrix).
+- ReScript [string](https://rescript-lang.org/docs/manual/primitive-types/#string) accepted by MDN [DOMMatrix()](https://developer.mozilla.org/docs/Web/API/DOMMatrix/DOMMatrix).
 
 ```res
-let matrix = DOMMatrix.fromString(~init="matrix(1, 0, 0, 1, 0, 0)")
+let matrix = DOMMatrix.fromString("matrix(1, 0, 0, 1, 0, 0)")
 ```
 
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/DOMMatrix)
 */
 @new
-external fromString: (~init: string) => Types.domMatrix = "DOMMatrix"
+external fromString: string => Types.domMatrix = "DOMMatrix"
 
 /**
-`fromArray(~init: array<float>)`
+`fromArray(array<float>)`
 
 The DOMMatrix() constructor creates a new DOMMatrix from an array of matrix component values.
 
 Source shape:
-- `init`: ReScript [array](https://rescript-lang.org/docs/manual/api/stdlib/array) of numeric values accepted by MDN [DOMMatrix()](https://developer.mozilla.org/docs/Web/API/DOMMatrix/DOMMatrix).
+- ReScript [array](https://rescript-lang.org/docs/manual/api/stdlib/array) of numeric values accepted by MDN [DOMMatrix()](https://developer.mozilla.org/docs/Web/API/DOMMatrix/DOMMatrix).
 
 ```res
-let matrix = DOMMatrix.fromArray(~init=[1., 0., 0., 1., 0., 0.])
+let matrix = DOMMatrix.fromArray([1., 0., 0., 1., 0., 0.])
 ```
 
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/DOMMatrix)
 */
 @new
-external fromArray: (~init: array<float>) => Types.domMatrix = "DOMMatrix"
+external fromArray: array<float> => Types.domMatrix = "DOMMatrix"
 
 external asDOMMatrixReadOnly: Types.domMatrix => Types.domMatrixReadOnly = "%identity"
 @scope("DOMMatrix")

packages/DOM/src/DOMMatrixReadOnly.res

@@ -16,38 +16,38 @@ let matrix = DOMMatrixReadOnly.make()
 external make: unit => Types.domMatrixReadOnly = "DOMMatrixReadOnly"
 
 /**
-`fromString(~init: string)`
+`fromString(string)`
 
 The DOMMatrixReadOnly() constructor creates a new DOMMatrixReadOnly value from a transform string.
 
 Source shape:
-- `init`: ReScript [string](https://rescript-lang.org/docs/manual/primitive-types/#string) accepted by MDN [DOMMatrixReadOnly()](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/DOMMatrixReadOnly).
+- ReScript [string](https://rescript-lang.org/docs/manual/primitive-types/#string) accepted by MDN [DOMMatrixReadOnly()](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/DOMMatrixReadOnly).
 
 ```res
-let matrix = DOMMatrixReadOnly.fromString(~init="matrix(1, 0, 0, 1, 0, 0)")
+let matrix = DOMMatrixReadOnly.fromString("matrix(1, 0, 0, 1, 0, 0)")
 ```
 
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly)
 */
 @new
-external fromString: (~init: string) => Types.domMatrixReadOnly = "DOMMatrixReadOnly"
+external fromString: string => Types.domMatrixReadOnly = "DOMMatrixReadOnly"
 
 /**
-`fromArray(~init: array<float>)`
+`fromArray(array<float>)`
 
 The DOMMatrixReadOnly() constructor creates a new DOMMatrixReadOnly value from an array of matrix component values.
 
 Source shape:
-- `init`: ReScript [array](https://rescript-lang.org/docs/manual/api/stdlib/array) of numeric values accepted by MDN [DOMMatrixReadOnly()](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/DOMMatrixReadOnly).
+- ReScript [array](https://rescript-lang.org/docs/manual/api/stdlib/array) of numeric values accepted by MDN [DOMMatrixReadOnly()](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/DOMMatrixReadOnly).
 
 ```res
-let matrix = DOMMatrixReadOnly.fromArray(~init=[1., 0., 0., 1., 0., 0.])
+let matrix = DOMMatrixReadOnly.fromArray([1., 0., 0., 1., 0., 0.])
 ```
 
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly)
 */
 @new
-external fromArray: (~init: array<float>) => Types.domMatrixReadOnly = "DOMMatrixReadOnly"
+external fromArray: array<float> => Types.domMatrixReadOnly = "DOMMatrixReadOnly"
 
 @scope("DOMMatrixReadOnly")
 external fromMatrix: (~other: Types.domMatrixInit=?) => Types.domMatrixReadOnly = "fromMatrix"

packages/File/src/ReadableStream.res

@@ -21,23 +21,21 @@ let stream: ReadableStream.t<string> = ReadableStream.make()
 external make: unit => t<'t> = "ReadableStream"
 
 /**
-`fromUnderlyingSource(~underlyingSource: underlyingSource<'t>)`
+`fromUnderlyingSource(underlyingSource<'t>)`
 
 The ReadableStream() constructor creates a new ReadableStream from an underlying source definition.
 
 Source shape:
 - local [`underlyingSource<'t>`](../#underlyingSource) values accepted by MDN [ReadableStream()](https://developer.mozilla.org/docs/Web/API/ReadableStream/ReadableStream).
 
 ```res
-let stream =
-  ReadableStream.fromUnderlyingSource(~underlyingSource=myUnderlyingSource)
+let stream = ReadableStream.fromUnderlyingSource(myUnderlyingSource)
 ```
 
 [Read more on MDN](https://developer.mozilla.org/docs/Web/API/ReadableStream)
 */
 @new
-external fromUnderlyingSource: (~underlyingSource: Types.underlyingSource<'t>) => t<'t> =
-  "ReadableStream"
+external fromUnderlyingSource: Types.underlyingSource<'t> => t<'t> = "ReadableStream"
 
 /**
 `fromUnderlyingSourceWithStrategy(~underlyingSource: underlyingSource<'t>, ~strategy: queuingStrategy<'t>)`

tests/CanvasAPI/Path2D__test.res

@@ -1,5 +1,5 @@
 let path2D: WebApiCanvas.Types.path2D = Obj.magic()
 
 let _make = WebApiCanvas.Path2D.make()
-let _fromPath2D = WebApiCanvas.Path2D.fromPath2D(~path=path2D)
-let _fromString = WebApiCanvas.Path2D.fromString(~path="M0 0 L10 10")
+let _fromPath2D = WebApiCanvas.Path2D.fromPath2D(path2D)
+let _fromString = WebApiCanvas.Path2D.fromString("M0 0 L10 10")

tests/DOMAPI/DOMMatrixReadOnly__test.res

@@ -1,5 +1,5 @@
 let _make = WebApiDOM.DOMMatrixReadOnly.make()
 
-let _fromString = WebApiDOM.DOMMatrixReadOnly.fromString(~init="matrix(1, 0, 0, 1, 0, 0)")
+let _fromString = WebApiDOM.DOMMatrixReadOnly.fromString("matrix(1, 0, 0, 1, 0, 0)")
 
-let _fromArray = WebApiDOM.DOMMatrixReadOnly.fromArray(~init=[1., 0., 0., 1., 0., 0.])
+let _fromArray = WebApiDOM.DOMMatrixReadOnly.fromArray([1., 0., 0., 1., 0., 0.])

tests/DOMAPI/DOMMatrix__test.res

@@ -1,3 +1,3 @@
 let _make = WebApiDOM.DOMMatrix.make()
-let _fromString = WebApiDOM.DOMMatrix.fromString(~init="matrix(1, 0, 0, 1, 0, 0)")
-let _fromArray = WebApiDOM.DOMMatrix.fromArray(~init=[1., 0., 0., 1., 0., 0.])
+let _fromString = WebApiDOM.DOMMatrix.fromString("matrix(1, 0, 0, 1, 0, 0)")
+let _fromArray = WebApiDOM.DOMMatrix.fromArray([1., 0., 0., 1., 0., 0.])

tests/FileAPI/ReadableStream__test.res

@@ -3,7 +3,7 @@ let strategy: WebApiFile.Types.queuingStrategy<string> = Obj.magic()
 
 let _make: WebApiFile.ReadableStream.t<string> = WebApiFile.ReadableStream.make()
 
-let _fromUnderlyingSource = WebApiFile.ReadableStream.fromUnderlyingSource(~underlyingSource)
+let _fromUnderlyingSource = WebApiFile.ReadableStream.fromUnderlyingSource(underlyingSource)
 
 let _fromUnderlyingSourceWithStrategy = WebApiFile.ReadableStream.fromUnderlyingSourceWithStrategy(
   ~underlyingSource,