@rescript/webapi 0.1.0-alpha-b1d58f9

package/src/file/FileSystemWritableFileStream.res

@@ -0,0 +1,65 @@
+external asWritableStream: FileTypes.fileSystemWritableFileStream => FileTypes.writableStream<'w> =
+  "%identity"
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/WritableStream/abort)
+*/
+@send
+external abort: (FileTypes.fileSystemWritableFileStream, ~reason: JSON.t=?) => promise<unit> =
+  "abort"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/WritableStream/close)
+*/
+@send
+external close: FileTypes.fileSystemWritableFileStream => promise<unit> = "close"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/WritableStream/getWriter)
+*/
+@throws(JsExn) @send
+external getWriter: FileTypes.fileSystemWritableFileStream => FileTypes.writableStreamDefaultWriter<
+  'w,
+> = "getWriter"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/FileSystemWritableFileStream/write)
+*/
+@send
+external write: (FileTypes.fileSystemWritableFileStream, DataView.t) => promise<unit> = "write"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/FileSystemWritableFileStream/write)
+*/
+@send
+external write2: (FileTypes.fileSystemWritableFileStream, ArrayBuffer.t) => promise<unit> = "write"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/FileSystemWritableFileStream/write)
+*/
+@send
+external write3: (FileTypes.fileSystemWritableFileStream, FileTypes.blob) => promise<unit> = "write"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/FileSystemWritableFileStream/write)
+*/
+@send
+external write4: (FileTypes.fileSystemWritableFileStream, string) => promise<unit> = "write"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/FileSystemWritableFileStream/write)
+*/
+@send
+external write5: (FileTypes.fileSystemWritableFileStream, FileTypes.writeParams) => promise<unit> =
+  "write"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/FileSystemWritableFileStream/seek)
+*/
+@send
+external seek: (FileTypes.fileSystemWritableFileStream, int) => promise<unit> = "seek"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/FileSystemWritableFileStream/truncate)
+*/
+@send
+external truncate: (FileTypes.fileSystemWritableFileStream, int) => promise<unit> = "truncate"

package/src/file/FileTypes.res

@@ -0,0 +1,225 @@
+@@warning("-30")
+
+type endingType =
+  | @as("native") Native
+  | @as("transparent") Transparent
+
+type readableStreamReaderMode = | @as("byob") Byob
+
+type fileSystemHandleKind =
+  | @as("directory") Directory
+  | @as("file") File
+
+type writeCommandType =
+  | @as("seek") Seek
+  | @as("truncate") Truncate
+  | @as("write") Write
+
+/**
+A file-like object of immutable, raw data. Blobs represent data that isn't necessarily in a JavaScript-native format. The WebApiFile interface is based on Blob, inheriting blob functionality and expanding it to support files on the user's system.
+[See Blob on MDN](https://developer.mozilla.org/docs/Web/API/Blob)
+*/
+@editor.completeFrom(Blob)
+type blob = DOM.blob = private {
+  /**
+    [Read more on MDN](https://developer.mozilla.org/docs/Web/API/Blob/size)
+    */
+  size: int,
+  /**
+    [Read more on MDN](https://developer.mozilla.org/docs/Web/API/Blob/type)
+    */
+  @as("type")
+  type_: string,
+}
+
+/**
+This Streams API interface represents a readable stream of byte data. The WebApiFetch API offers a concrete instance of a ReadableStream through the body property of a Response object.
+[See ReadableStream on MDN](https://developer.mozilla.org/docs/Web/API/ReadableStream)
+*/
+@editor.completeFrom(ReadableStream)
+type readableStream<'r> = {
+  /**
+    [Read more on MDN](https://developer.mozilla.org/docs/Web/API/ReadableStream/locked)
+    */
+  locked: bool,
+}
+
+/**
+This Streams API interface provides a standard abstraction for writing streaming data to a destination, known as a sink. This object comes with built-in backpressure and queuing.
+[See WritableStream on MDN](https://developer.mozilla.org/docs/Web/API/WritableStream)
+*/
+type writableStream<'w> = {
+  /**
+    [Read more on MDN](https://developer.mozilla.org/docs/Web/API/WritableStream/locked)
+    */
+  locked: bool,
+}
+
+/**
+This Streams API interface represents a controller allowing control of a WritableStream's state. When constructing a WritableStream, the underlying sink is given a corresponding WritableStreamDefaultController instance to manipulate.
+[See WritableStreamDefaultController on MDN](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultController)
+*/
+@editor.completeFrom(WritableStreamDefaultController)
+type writableStreamDefaultController = private {
+  /**
+    [Read more on MDN](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultController/signal)
+    */
+  signal: DOM.abortSignal,
+}
+
+/**
+Provides information about files and allows JavaScript in a web page to access their content.
+[See WebApiFile on MDN](https://developer.mozilla.org/docs/Web/API/File)
+*/
+@editor.completeFrom(File)
+type file = DOM.file = private {
+  ...blob,
+  /**
+    [Read more on MDN](https://developer.mozilla.org/docs/Web/API/File/name)
+    */
+  name: string,
+  /**
+    [Read more on MDN](https://developer.mozilla.org/docs/Web/API/File/lastModified)
+    */
+  lastModified: int,
+  /**
+    [Read more on MDN](https://developer.mozilla.org/docs/Web/API/File/webkitRelativePath)
+    */
+  webkitRelativePath: string,
+}
+
+/**
+[See FileSystemHandle on MDN](https://developer.mozilla.org/docs/Web/API/FileSystemHandle)
+*/
+@editor.completeFrom(FileSystemHandle)
+type fileSystemHandle = private {
+  /**
+    [Read more on MDN](https://developer.mozilla.org/docs/Web/API/FileSystemHandle/kind)
+    */
+  kind: fileSystemHandleKind,
+  /**
+    [Read more on MDN](https://developer.mozilla.org/docs/Web/API/FileSystemHandle/name)
+    */
+  name: string,
+}
+
+/**
+[See FileSystemDirectoryHandle on MDN](https://developer.mozilla.org/docs/Web/API/FileSystemDirectoryHandle)
+*/
+@editor.completeFrom(FileSystemDirectoryHandle)
+type fileSystemDirectoryHandle = private {
+  ...fileSystemHandle,
+}
+
+/**
+[See FileSystemFileHandle on MDN](https://developer.mozilla.org/docs/Web/API/FileSystemFileHandle)
+*/
+@editor.completeFrom(FileSystemFileHandle)
+type fileSystemFileHandle = private {
+  ...fileSystemHandle,
+}
+
+/**
+[See FileSystemWritableFileStream on MDN](https://developer.mozilla.org/docs/Web/API/FileSystemWritableFileStream)
+*/
+@editor.completeFrom(FileSystemWritableFileStream)
+type fileSystemWritableFileStream = private {
+  ...writableStream<unknown>,
+}
+
+@unboxed
+type blobPart =
+  | String(string)
+  | Blob(blob)
+// | ArrayBuffer(ArrayBuffer.t)
+// | TypedArray(TypedArray.t<int>)
+
+type queuingStrategy<'t> = unknown
+
+type underlyingSink<'t> = unknown
+
+type underlyingSource<'t> = unknown
+
+type readableStreamReader<'t> = unknown
+
+type writableStreamDefaultWriter<'t> = unknown
+
+type fileSystemWriteChunkType = unknown
+
+type underlyingSourceCancelCallback = JSON.t => promise<unit>
+
+type blobPropertyBag = {
+  @as("type") mutable type_?: string,
+  mutable endings?: endingType,
+}
+
+type underlyingByteSource = {
+  @as("type") mutable type_: unknown,
+  mutable autoAllocateChunkSize?: int,
+  mutable start?: unknown,
+  mutable pull?: unknown,
+  mutable cancel?: underlyingSourceCancelCallback,
+}
+
+type readableStreamGetReaderOptions = {
+  /**
+    Creates a ReadableStreamBYOBReader and locks the stream to the new reader.
+
+This call behaves the same way as the no-argument variant, except that it only works on readable byte streams, i.e. streams which were constructed specifically with the ability to handle "bring your own buffer" reading. The returned BYOB reader provides the ability to directly read individual chunks from the stream via its read() method, into developer-supplied buffers, allowing more precise control over allocation.
+    */
+  mutable mode?: readableStreamReaderMode,
+}
+
+type readableWritablePair<'r, 'w> = {
+  mutable readable: readableStream<'r>,
+  /**
+    Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
+
+Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
+    */
+  mutable writable: writableStream<'w>,
+}
+
+type streamPipeOptions = {
+  /**
+    Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
+
+Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
+
+Errors and closures of the source and destination streams propagate as follows:
+
+An error in this source readable stream will abort destination, unless preventAbort is truthy. The returned promise will be rejected with the source's error, or with any error that occurs during aborting the destination.
+
+An error in destination will cancel this source readable stream, unless preventCancel is truthy. The returned promise will be rejected with the destination's error, or with any error that occurs during canceling the source.
+
+When this source readable stream closes, destination will be closed, unless preventClose is truthy. The returned promise will be fulfilled once this process completes, unless an error is encountered while closing the destination, in which case it will be rejected with that error.
+
+If destination starts out closed or closing, this source readable stream will be canceled, unless preventCancel is true. The returned promise will be rejected with an error indicating piping to a closed stream failed, or with any error that occurs during canceling the source.
+
+The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding Event.AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
+    */
+  mutable preventClose?: bool,
+  mutable preventAbort?: bool,
+  mutable preventCancel?: bool,
+  mutable signal?: DOM.abortSignal,
+}
+
+type filePropertyBag = {
+  ...blobPropertyBag,
+  mutable lastModified?: int,
+}
+
+type fileSystemGetFileOptions = {mutable create?: bool}
+
+type fileSystemGetDirectoryOptions = {mutable create?: bool}
+
+type fileSystemRemoveOptions = {mutable recursive?: bool}
+
+type fileSystemCreateWritableOptions = {mutable keepExistingData?: bool}
+
+type writeParams = {
+  @as("type") mutable type_: writeCommandType,
+  mutable size?: Nullable.t<int>,
+  mutable position?: Nullable.t<int>,
+  mutable data?: Nullable.t<unknown>,
+}

package/src/file/ReadableStream.res

@@ -0,0 +1,79 @@
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/ReadableStream)
+*/
+type t<'r> = FileTypes.readableStream<'r>
+
+/**
+`make()`
+
+Creates a new empty `ReadableStream`.
+
+```res
+let stream: ReadableStream.t<string> = ReadableStream.make()
+```
+
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/ReadableStream)
+*/
+@new
+external make: unit => t<'t> = "ReadableStream"
+
+/**
+`fromUnderlyingSource(underlyingSource<'t>, ~strategy: queuingStrategy<'t>=?)`
+
+Creates a new `ReadableStream` from an `underlyingSource`, with an optional queuing strategy.
+
+```res
+let stream = ReadableStream.fromUnderlyingSource(myUnderlyingSource)
+
+let streamWithStrategy =
+  ReadableStream.fromUnderlyingSource(myUnderlyingSource, ~strategy=myQueuingStrategy)
+```
+
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/ReadableStream)
+*/
+@throws(JsExn) @new
+external fromUnderlyingSource: (
+  FileTypes.underlyingSource<'t>,
+  ~strategy: FileTypes.queuingStrategy<'t>=?,
+) => t<'t> = "ReadableStream"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/ReadableStream/cancel)
+*/
+@send
+external cancel: (t<'r>, ~reason: JSON.t=?) => promise<unit> = "cancel"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/ReadableStream/getReader)
+*/
+@throws(JsExn) @send
+external getReader: (
+  t<'r>,
+  ~options: FileTypes.readableStreamGetReaderOptions=?,
+) => FileTypes.readableStreamReader<'r> = "getReader"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/ReadableStream/pipeThrough)
+*/
+@throws(JsExn) @send
+external pipeThrough: (
+  t<'r>,
+  ~transform: FileTypes.readableWritablePair<'t, 'r>,
+  ~options: FileTypes.streamPipeOptions=?,
+) => t<'t> = "pipeThrough"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/ReadableStream/pipeTo)
+*/
+@send
+external pipeTo: (
+  t<'r>,
+  ~destination: FileTypes.writableStream<'r>,
+  ~options: FileTypes.streamPipeOptions=?,
+) => promise<unit> = "pipeTo"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/ReadableStream/tee)
+*/
+@throws(JsExn) @send
+external tee: t<'r> => array<t<unit>> = "tee"

package/src/file/WritableStream.res

@@ -0,0 +1,27 @@
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/WritableStream)
+*/
+@throws(JsExn) @new
+external make: (
+  ~underlyingSink: FileTypes.underlyingSink<'w>=?,
+  ~strategy: FileTypes.queuingStrategy<'w>=?,
+) => FileTypes.writableStream<'w> = "WritableStream"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/WritableStream/abort)
+*/
+@send
+external abort: (FileTypes.writableStream<'w>, ~reason: JSON.t=?) => promise<unit> = "abort"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/WritableStream/close)
+*/
+@send
+external close: FileTypes.writableStream<'w> => promise<unit> = "close"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/WritableStream/getWriter)
+*/
+@throws(JsExn) @send
+external getWriter: FileTypes.writableStream<'w> => FileTypes.writableStreamDefaultWriter<'w> =
+  "getWriter"

package/src/file/WritableStreamDefaultController.res

@@ -0,0 +1,5 @@
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultController/error)
+*/
+@send
+external error: (FileTypes.writableStreamDefaultController, ~e: JSON.t=?) => unit = "error"

package/src/geometry/DOMMatrix.res

@@ -0,0 +1,206 @@
+/**
+`make()`
+
+Creates a new identity `DOMMatrix`.
+
+```res
+let matrix = DOMMatrix.make()
+```
+
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/DOMMatrix)
+*/
+@new
+external make: unit => DOM.domMatrix = "DOMMatrix"
+
+/**
+`fromString(string)`
+
+Creates a new `DOMMatrix` from a transform string.
+
+```res
+let matrix = DOMMatrix.fromString("matrix(1, 0, 0, 1, 0, 0)")
+```
+
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/DOMMatrix)
+*/
+@throws(JsExn) @new
+external fromString: string => DOM.domMatrix = "DOMMatrix"
+
+/**
+`fromArray(array<float>)`
+
+Creates a new `DOMMatrix` from an array of matrix component values.
+
+```res
+let matrix = DOMMatrix.fromArray([1., 0., 0., 1., 0., 0.])
+```
+
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/DOMMatrix)
+*/
+@throws(JsExn) @new
+external fromArray: array<float> => DOM.domMatrix = "DOMMatrix"
+
+external asDOMMatrixReadOnly: DOM.domMatrix => DOM.domMatrixReadOnly = "%identity"
+@scope("DOMMatrix")
+external fromMatrix: (~other: DOM.domMatrixInit=?) => DOM.domMatrixReadOnly = "fromMatrix"
+
+@throws(JsExn) @scope("DOMMatrix")
+external fromFloat32Array: array<float> => DOM.domMatrixReadOnly = "fromFloat32Array"
+
+@throws(JsExn) @scope("DOMMatrix")
+external fromFloat64Array: Float64Array.t => DOM.domMatrixReadOnly = "fromFloat64Array"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/translate)
+*/
+@send
+external translate: (DOM.domMatrix, ~tx: float=?, ~ty: float=?, ~tz: float=?) => DOM.domMatrix =
+  "translate"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/scale)
+*/
+@send
+external scale: (
+  DOM.domMatrix,
+  ~scaleX: float=?,
+  ~scaleY: float=?,
+  ~scaleZ: float=?,
+  ~originX: float=?,
+  ~originY: float=?,
+  ~originZ: float=?,
+) => DOM.domMatrix = "scale"
+
+@send
+external scale3d: (
+  DOM.domMatrix,
+  ~scale: float=?,
+  ~originX: float=?,
+  ~originY: float=?,
+  ~originZ: float=?,
+) => DOM.domMatrix = "scale3d"
+
+@send
+external rotate: (DOM.domMatrix, ~rotX: float=?, ~rotY: float=?, ~rotZ: float=?) => DOM.domMatrix =
+  "rotate"
+
+@send
+external rotateFromVector: (DOM.domMatrix, ~x: float=?, ~y: float=?) => DOM.domMatrix =
+  "rotateFromVector"
+
+@send
+external rotateAxisAngle: (
+  DOM.domMatrix,
+  ~x: float=?,
+  ~y: float=?,
+  ~z: float=?,
+  ~angle: float=?,
+) => DOM.domMatrix = "rotateAxisAngle"
+
+@send
+external skewX: (DOM.domMatrix, ~sx: float=?) => DOM.domMatrix = "skewX"
+
+@send
+external skewY: (DOM.domMatrix, ~sy: float=?) => DOM.domMatrix = "skewY"
+
+@send
+external multiply: (DOM.domMatrix, ~other: DOM.domMatrixInit=?) => DOM.domMatrix = "multiply"
+
+/**
+[Read more on MDN](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/flipX)
+*/
+@send
+external flipX: DOM.domMatrix => DOM.domMatrix = "flipX"
+
+@send
+external flipY: DOM.domMatrix => DOM.domMatrix = "flipY"
+
+@send
+external inverse: DOM.domMatrix => DOM.domMatrix = "inverse"
+
+@send
+external transformPoint: (DOM.domMatrix, ~point: DOM.domPointInit=?) => DOM.domPoint =
+  "transformPoint"
+
+@send
+external toFloat32Array: DOM.domMatrix => array<float> = "toFloat32Array"
+
+@send
+external toFloat64Array: DOM.domMatrix => Float64Array.t = "toFloat64Array"
+
+@send
+external toJSON: DOM.domMatrix => Dict.t<string> = "toJSON"
+
+@scope("DOMMatrix")
+external fromMatrixD: (~other: DOM.domMatrixInit=?) => DOM.domMatrix = "fromMatrix"
+
+@throws(JsExn) @scope("DOMMatrix")
+external fromFloat32ArrayD: array<float> => DOM.domMatrix = "fromFloat32Array"
+
+@throws(JsExn) @scope("DOMMatrix")
+external fromFloat64ArrayD: Float64Array.t => DOM.domMatrix = "fromFloat64Array"
+
+@send
+external multiplySelf: (DOM.domMatrix, ~other: DOM.domMatrixInit=?) => DOM.domMatrix =
+  "multiplySelf"
+
+@send
+external preMultiplySelf: (DOM.domMatrix, ~other: DOM.domMatrixInit=?) => DOM.domMatrix =
+  "preMultiplySelf"
+
+@send
+external translateSelf: (DOM.domMatrix, ~tx: float=?, ~ty: float=?, ~tz: float=?) => DOM.domMatrix =
+  "translateSelf"
+
+@send
+external scaleSelf: (
+  DOM.domMatrix,
+  ~scaleX: float=?,
+  ~scaleY: float=?,
+  ~scaleZ: float=?,
+  ~originX: float=?,
+  ~originY: float=?,
+  ~originZ: float=?,
+) => DOM.domMatrix = "scaleSelf"
+
+@send
+external scale3dSelf: (
+  DOM.domMatrix,
+  ~scale: float=?,
+  ~originX: float=?,
+  ~originY: float=?,
+  ~originZ: float=?,
+) => DOM.domMatrix = "scale3dSelf"
+
+@send
+external rotateSelf: (
+  DOM.domMatrix,
+  ~rotX: float=?,
+  ~rotY: float=?,
+  ~rotZ: float=?,
+) => DOM.domMatrix = "rotateSelf"
+
+@send
+external rotateFromVectorSelf: (DOM.domMatrix, ~x: float=?, ~y: float=?) => DOM.domMatrix =
+  "rotateFromVectorSelf"
+
+@send
+external rotateAxisAngleSelf: (
+  DOM.domMatrix,
+  ~x: float=?,
+  ~y: float=?,
+  ~z: float=?,
+  ~angle: float=?,
+) => DOM.domMatrix = "rotateAxisAngleSelf"
+
+@send
+external skewXSelf: (DOM.domMatrix, ~sx: float=?) => DOM.domMatrix = "skewXSelf"
+
+@send
+external skewYSelf: (DOM.domMatrix, ~sy: float=?) => DOM.domMatrix = "skewYSelf"
+
+@send
+external invertSelf: DOM.domMatrix => DOM.domMatrix = "invertSelf"
+
+@throws(JsExn) @send
+external setMatrixValue: (DOM.domMatrix, string) => DOM.domMatrix = "setMatrixValue"