RescriptReactRouter.res

@scope("globalThis")
externalwindow: option<Dom.window> ="window"

@scope("globalThis")
externalhistory: option<Dom.history> ="history"

@getexternallocation: Dom.window=>Dom.location="location"

/* actually the cb is Dom.event => unit, but let's restrict the access for now */
@send
externaladdEventListener: (Dom.window, string, unit=>unit) =>unit="addEventListener"

@send
externalremoveEventListener: (Dom.window, string, unit=>unit) =>unit="removeEventListener"

@send
externaldispatchEvent: (Dom.window, Dom.event) =>unit="dispatchEvent"

@getexternalpathname: Dom.location=>string="pathname"

@getexternalhash: Dom.location=>string="hash"

@getexternalsearch: Dom.location=>string="search"

@send
externalpushState: (Dom.history, @as(json`null`) _, @as("") _, ~href: string) =>unit="pushState"

@send
externalreplaceState: (Dom.history, @as(json`null`) _, @as("") _, ~href: string) =>unit=
"replaceState"

@valexternalevent: 'a="Event"

@newexternalmakeEventIE11Compatible: string=>Dom.event="Event"

@val @scope("document")
externalcreateEventNonIEBrowsers: string=>Dom.event="createEvent"

@send
externalinitEventNonIEBrowsers: (Dom.event, string, bool, bool) =>unit="initEvent"

letsafeMakeEvent=eventName=>
ifJs.typeof(event) =="function" {
makeEventIE11Compatible(eventName)
 } else {
letevent=createEventNonIEBrowsers("Event")
initEventNonIEBrowsers(event, eventName, true, true)
event
 }

/* This is copied from array.ml. We want to cut dependencies for rescript-react so
 that it's friendlier to use in size-constrained codebases */
letarrayToList=a=> {
letrectolist= (i, res) =>
ifi < 0 {
res
 } else {
tolist(i-1, list{a->Js.Array2.unsafe_get(i), ...res})
 }
tolist(a->Js.Array2.length-1, list{})
}
/* if we ever roll our own parser in the future, make sure you test all url combinations
 e.g. foo.com/?#bar
 */
/* sigh URLSearchParams doesn't work on IE11, edge16, etc. */
/* actually you know what, not gonna provide search for now. It's a mess.
 We'll let users roll their own solution/data structure for now */
letpathParse=str=>
switchstr {
 | ""
 | "/"=>
list{}
 | raw=>
/* remove the preceeding /, which every pathname seems to have */
letraw=raw->Js.String2.sliceToEnd(~from=1)
/* remove the trailing /, which some pathnames might have. Ugh */
letraw=switchraw->Js.String2.get(raw->Js.String2.length-1) {
 | "/"=>raw->Js.String2.slice(~from=0, ~to_=-1)
 | _=>raw
 }
/* remove search portion if present in string */
letraw=switchraw->Js.String2.splitAtMost("?", ~limit=2) {
 | [path, _] =>path
 | _=>raw
 }

raw->Js.String2.split("/")->Js.Array2.filter(item=>item->Js.String2.length!=0)->arrayToList
 }
letpath= (~serverUrlString=?, ()) =>
switch (serverUrlString, window) {
 | (None, None) =>list{}
 | (Some(serverUrlString), _) =>pathParse(serverUrlString)
 | (_, Some(window: Dom.window)) =>pathParse(window->location->pathname)
 }
lethash= () =>
switchwindow {
 | None=>""
 | Some(window: Dom.window) =>
switchwindow->location->hash {
 | ""
 | "#"=>""
 | raw=>
/* remove the preceeding #, which every hash seems to have.
 Why is this even included in location.hash?? */
raw->Js.String2.sliceToEnd(~from=1)
 }
 }
letsearchParse=str=>
switchstr {
 | ""
 | "?"=>""
 | raw=>
switchraw->Js.String2.splitAtMost("?", ~limit=2) {
 | [_, search] =>search
 | _=>""
 }
 }

letsearch= (~serverUrlString=?, ()) =>
switch (serverUrlString, window) {
 | (None, None) =>""
 | (Some(serverUrlString), _) =>searchParse(serverUrlString)
 | (_, Some(window: Dom.window)) =>searchParse(window->location->search)
 }

letpush=path=>
switch (history, window) {
 | (None, _)
 | (_, None) => ()
 | (Some(history: Dom.history), Some(window: Dom.window)) =>
pushState(history, ~href=path)
dispatchEvent(window, safeMakeEvent("popstate"))
 }

letreplace=path=>
switch (history, window) {
 | (None, _)
 | (_, None) => ()
 | (Some(history: Dom.history), Some(window: Dom.window)) =>
replaceState(history, ~href=path)
dispatchEvent(window, safeMakeEvent("popstate"))
 }

typeurl= {
path: list<string>,
hash: string,
search: string,
}

leturlNotEqual= (a, b) => {
letreclistNotEqual= (aList, bList) =>
switch (aList, bList) {
 | (list{}, list{}) =>false
 | (list{}, list{_, ..._})
 | (list{_, ..._}, list{}) =>true
 | (list{aHead, ...aRest}, list{bHead, ...bRest}) =>
ifaHead!==bHead {
true
 } else {
listNotEqual(aRest, bRest)
 }
 }
a.hash!==b.hash|| (a.search!==b.search||listNotEqual(a.path, b.path))
}

typewatcherID=unit=>unit

leturl= (~serverUrlString=?, ()) => {
path: path(~serverUrlString?, ()),
hash: hash(),
search: search(~serverUrlString?, ()),
}

/* alias exposed publicly */
letdangerouslyGetInitialUrl=url

letwatchUrl=callback=>
switchwindow {
 | None=> () => ()
 | Some(window: Dom.window) =>
letwatcherID= () =>callback(url())
addEventListener(window, "popstate", watcherID)
watcherID
 }

letunwatchUrl=watcherID=>
switchwindow {
 | None=> ()
 | Some(window: Dom.window) =>removeEventListener(window, "popstate", watcherID)
 }

letuseUrl= (~serverUrl=?, ()) => {
let (url, setUrl) =React.useState(() =>
switchserverUrl {
 | Some(url) =>url
 | None=>dangerouslyGetInitialUrl()
 }
 )

React.useEffect(() => {
letwatcherId=watchUrl(url=>setUrl(_=>url))

// check for updates that may have occured between the initial state and
// the subscribe above
letnewUrl=dangerouslyGetInitialUrl()
ifurlNotEqual(newUrl, url) {
setUrl(_=>newUrl)
 }

Some(() =>unwatchUrl(watcherId))
 }, [])

url
}