migration.toml

## These migrations cover moving from the Js namespace to the new stdlib.
## Each job runs in alphabetical order, hence the slightly weird naming scheme.
## You're encouraged to pick and choose as you'd like from these migrations. You don't have to run them all.
[array-a-reduce]
match="Js.Array2.reduce(:[mapper], :[init])"
rewrite="Array.reduce(:[init], :[mapper])"

[array-a-push]
match="let _ = :[varName]->Js.Array2.push(:value)"
rewrite=":[varName]->Array.push(:value)"

[array-a-push-ignore]
match="Js.Array2.push(:value)->ignore"
rewrite="Array.push(:value)"

[array-a-unshift]
match="let _ = :[varName]->Js.Array2.unshift(:value)"
rewrite=":[varName]->Array.unshift(:value)"

[array-a-unshift-ignore]
match="Js.Array2.unshift(:value)->ignore"
rewrite="Array.unshift(:value)"

[array-c-unsafe_get]
match="Array.unsafe_get"
rewrite="Array.getUnsafe"

[array-a-sliceFrom]
match="Js.Array2.sliceFrom(:[from])"
rewrite="Array.sliceToEnd(~start=:[from])"

[array-a-slice]
match="Js.Array2.slice(~start=:[from], ~end_=:[to])"
rewrite="Array.slice(~start=:[from], ~end=:[to])"

[array-filteri]
match="Js.Array2.filteri"
rewrite="Array.filterWithIndex"

[array-findi]
match="Js.Array2.findi"
rewrite="Array.findWithIndex"

[array-mapi]
match="Js.Array2.mapi"
rewrite="Array.mapWithIndex"

[array-forEachi]
match="Js.Array2.forEachi"
rewrite="Array.forEachWithIndex"

[array-splice]
match="Js.Array2.spliceInPlace(~pos=:[pos], ~remove=:[remove], ~add=:[add])->ignore"
rewrite="Array.splice(~start=:[pos], ~remove=:[remove], ~insert=:[add])"

[array-z]
match="Js.Array2"
rewrite="Array"

[js-option]
match="Js.Option"
rewrite="Option"

[string-a-slice]
match="Js.String2.slice(~from=:[from], ~to_=:[to])"
rewrite="String.slice(~start=:[from], ~end=:[to])"

[string-a-slice-to-end]
match="Js.String2.sliceToEnd(~from=:[from])"
rewrite="String.sliceToEnd(~start=:[from])"

[string-a-replace]
match="Js.String2.replace"
rewrite="String.replaceString"

[string-a-substring]
match="Js.String2.substring(~from=:[from], ~to_=:[to])"
rewrite="String.substring(~start=:[from], ~end=:[to])"

[string-a-substringToEnd]
match="Js.String2.substringToEnd(~from=:[from])"
rewrite="String.substringToEnd(~start=:[from])"

[string-replaceStringByRe]
match="Js.String2.replaceStringByRe"
rewrite="String.replaceRegExp"

[string-z]
match="Js.String2"
rewrite="String"

[promise-a-then-pipe]
match="Js.Promise.then_(:[cont], _)"
rewrite="Promise.then(:[cont])"

[promise-a-catch-pipe]
match="Js.Promise.catch(:[cont], _)"
rewrite="Promise.catch(:[cont])"

[promise-z]
match="Js.Promise"
rewrite="Promise"

[promise-z-type]
match="Promise.t<:[typeArg]>"
rewrite="promise<:[typeArg]>"

[js-dict-a-entries]
match="Js.Dict.entries"
rewrite="Dict.toArray"

[js-dict-a-make]
match="Js.Dict.empty"
rewrite="Dict.make"

[js-dict-a-keys]
match="Js.Dict.keys"
rewrite="Dict.keysToArray"

[js-dict-a-get-unsafe]
match="Js.Dict.unsafeGet"
rewrite="Dict.getUnsafe"

[js-dict-z]
match="Js.Dict"
rewrite="Dict"

[js-dict-t-z]
match="Js.Dict.t"
rewrite="Dict.t"

[js-null-make]
match="Js.Null.return"
rewrite="Null.make"

[js-null-z]
match="Js.Null"
rewrite="Null"

[js-nullable-make]
match="Js.Nullable.return"
rewrite="Nullable.make"

[js-nullable-z]
match="Js.Nullable"
rewrite="Nullable"

[js-null-undefined-make]
match="Js.Null_undefined.return"
rewrite="Nullable.make"

[js-null-undefined-z]
match="Js.Null_undefined"
rewrite="Nullable"

[js-log-z]
match="Js.log"
rewrite="Console.log"

[js-exn-z]
match="Js.Exn"
rewrite="Exn"

[js-re-a-test]
match="Js.Re.test_"
rewrite="RegExp.test"

[json-t-a]
match="Js.Json.t"
rewrite="JSON.t"

[json-stringify]
match="Js.Json.stringify"
rewrite="JSON.stringify"

[json-enc-null]
match="Js.Json.null"
rewrite="JSON.Encode.null"

[json-enc-object]
match="Js.Json.object_"
rewrite="JSON.Encode.object"

[json-enc-string]
match="Js.Json.string"
rewrite="JSON.Encode.string"

[json-enc-bool]
match="Js.Json.boolean"
rewrite="JSON.Encode.bool"

[json-enc-int]
match="Js.Json.int"
rewrite="JSON.Encode.int"

[json-enc-float]
match="Js.Json.number"
rewrite="JSON.Encode.float"

[json-enc-array]
match="Js.Json.array"
rewrite="JSON.Encode.array"

[json-dec-bool]
match="Js.Json.decodeBoolean"
rewrite="JSON.Decode.bool"

[json-dec-null]
match="Js.Json.decodeNull"
rewrite="JSON.Decode.null"

[json-dec-string]
match="Js.Json.decodeString"
rewrite="JSON.Decode.string"

[json-dec-float]
match="Js.Json.decodeNumber"
rewrite="JSON.Decode.float"

[json-dec-obj]
match="Js.Json.decodeObject"
rewrite="JSON.Decode.object"

[json-dec-array]
match="Js.Json.decodeArray"
rewrite="JSON.Decode.array"

[json-classify]
match="Js.Json.classify"
rewrite="JSON.Classify.classify"

[json-classify-False]
match="JSONFalse"
rewrite="Bool(false)"

[json-classify-True]
match="JSONTrue"
rewrite="Bool(true)"

[json-classify-Null]
match="JSONNull"
rewrite="Null"

[json-classify-String]
match="JSONString(:[string])"
rewrite="String(:[string])"

[json-classify-Number]
match="JSONNumber(:[float])"
rewrite="Number(:[float])"

[json-classify-Object]
match="JSONObject(:[dict])"
rewrite="Object(:[dict])"

[json-classify-Array]
match="JSONArray(:[array])"
rewrite="Array(:[array])"

[json-t-rest]
match="Js.Json"
rewrite="JSON"

[float-a]
match="Js.Float"
rewrite="Float"

[int-a]
match="Js.Int"
rewrite="Int"

[math-a]
match="Js.Math"
rewrite="Math"

[math-a-a]
match="Math.minMany_float"
rewrite="Math.minMany"

[math-a-b]
match="Math.maxMany_float"
rewrite="Math.maxMany"

[math-a-c]
match="Math.max_int"
rewrite="Math.Int.max"

[math-a-d]
match="Math.min_int"
rewrite="Math.Int.min"

[math-a-e]
match="Math.max_float"
rewrite="Math.max"

[math-a-f]
match="Math.min_float"
rewrite="Math.min"

## BELT
## Below are migrations that cover moving from Belt to equivalents
## available in the new stdlib.
[belt-option]
match="Belt.Option"
rewrite="Option"

[belt-result]
match="Belt.Result"
rewrite="Result"

[belt-list-a-keep]
match="Belt.List.keep"
rewrite="List.filter"

[belt-list-a-keepMap]
match="Belt.List.keepMap"
rewrite="List.filterMap"

[belt-list-z]
match="Belt.List"
rewrite="List"

[belt-array-a-reverse]
match="Belt.Array.reverse"
rewrite="Array.reverse"

[belt-array-a-keep-map]
match="Belt.Array.keepMap"
rewrite="Array.filterMap"

[belt-array-a-shuffle]
match="Belt.Array.shuffle"
rewrite="Array.toShuffled"

[belt-array-a-shuffle-in-place]
match="Belt.Array.shuffleInPlace"
rewrite="Array.shuffle"

[belt-array-a-flat-map]
match="Belt.Array.flatMap"
rewrite="Array.flatMap"

[belt-array-b-map]
match="Belt.Array.map"
rewrite="Array.map"

[belt-array-a-copy]
match="Belt.Array.copy"
rewrite="Array.copy"

[belt-array-a-concat]
match="Belt.Array.concat"
rewrite="Array.concat"

[belt-array-a-some]
match="Belt.Array.some"
rewrite="Array.some"

[belt-array-a-length]
match="Belt.Array.length"
rewrite="Array.length"

[belt-array-a-forEach]
match="Belt.Array.forEach"
rewrite="Array.forEach"

[belt-array-a-forEachWithIndex]
match="Belt.Array.forEachWithIndex"
rewrite="Array.forEachWithIndex"

[belt-array-a-sliceToEnd]
match="Belt.Array.sliceToEnd(:[from])"
rewrite="Array.sliceToEnd(~start=:[from])"

[belt-array-a-reduce]
match="Belt.Array.reduce"
rewrite="Array.reduce"

[belt-array-a-mapWithIndex]
match="Belt.Array.mapWithIndex((:[index], :[fn]) => :[fnBody])"
rewrite="Array.mapWithIndex((:[fn], :[index]) => :[fnBody])"

[belt-array-b-mapWithIndex]
match="Belt.Array.mapWithIndex((:[index], :[fn]) => :[fnBody])"
rewrite="Array.mapWithIndex((:[fn], :[index]) => :[fnBody])"

[belt-array-a-filter]
match="Belt.Array.keep"
rewrite="Array.filter"

[belt-array-b-get]
match="Belt.Array.get"
rewrite="Array.get"

[belt-array-a-getBy]
match="Belt.Array.getBy"
rewrite="Array.find"

[belt-array-a-getIndexBy]
match="Belt.Array.getIndexBy"
rewrite="Array.findIndexOpt"

[belt-float-z]
match="Belt.Float"
rewrite="Float"

[belt-int-a-applied-from-string]
match="(Belt.Int.fromString)"
rewrite="(Int.fromString(~radix=10))"

[belt-int-z]
match="Belt.Int"
rewrite="Int"

[date-t-a]
match="Js.Date.fromFloat"
rewrite="Date.fromTime"

[date-t-rest]
match="Js.Date"
rewrite="Date"

[js-global-a]
match="Js.Global."
rewrite=""