tracker

5.3 KB

1. // THE ROUTER — realm-neutral, like view.hl: the same matcher runs on the server
2. // (which route answers a request) and in the browser (is this link a route of
3. // this app, and which). Ported from hl:web v1's client/router.hl, itself the port
4. // of the server matcher: one algorithm, one file, both realms.
5. //
6. // A route table is a list of hybrids. The PATTERN is the URLPattern `pathname`
7. // subset; the second key names the route's KIND (hybrilior 0.3.0's types):
8. // { pattern = "/posts/:id" component = "./components/post.hl" } a page (SSR + client)
9. // { pattern = "/health" function = (route, req) => { … } } server code answers
10. // { pattern = "/robots.txt" direct = "User-agent: *" } a fixed body
11. // { pattern = "/favicon.ico" file = "./assets/favicon.ico" } one file
12. // { pattern = "/assets/*" directory = "./assets" } a directory, `*` is the rest
13. // First match wins: authored order IS priority.
14. //
15. // PATTERN SYNTAX: `/a/b` literal segments, `:name` one segment into params.name,
16. // `:name?` optional (absent ⇒ null), `*` the rest into params["0"], and `*name` the
17. // rest into params.name (ticket #81): a page component reads it as its member `name`,
18. // the way it reads a `:name` group — "0" is no name a member can have.
20. routes = [] // bound by `new Router(routes = …)`
22. // the route's kind, by which key it carries
23. kindOf(r) {
24. if (r.component != null) { return 'component' }
25. if (r.function != null) { return 'function' }
26. if (r.direct != null) { return 'direct' }
27. if (r.file != null) { return 'file' }
28. if (r.directory != null) { return 'directory' }
29. return null
30. }
32. // Split a URL path into its non-empty segments:
33. // "/" -> [] ; "/notes/42" -> ["notes","42"] ; "/notes/42/" -> ["notes","42"].
34. segments(path) {
35. let raw = path.split("/")
36. let out = []
37. for (s of raw) {
38. if (s.length > 0) { out[] = s }
39. }
40. return out
41. }
43. // Strip a query string / hash off a URL path before matching ("/a?b=1" -> "/a").
44. cleanPath(path) {
45. let p = "" + path
46. let q = p.indexOf("?")
47. if (q >= 0) { p = p.slice(0, q) }
48. let h = p.indexOf("#")
49. if (h >= 0) { p = p.slice(0, h) }
50. if (p.length == 0) { return "/" }
51. return p
52. }
54. // Match ONE pattern's segments against the path's. On success the captured
55. // groups (possibly empty, which is still a MATCH); null on failure. `trailing`
56. // says the path ended in a slash — segmentation drops the empty tail, and a `*`
57. // at the end must still match "/files/" with { "0": "" } as the standard does.
58. matchPattern(pattern, segs, trailing) {
59. let psegs = segments(pattern)
60. let groups = {}
61. let i = 0
62. while (i < psegs.length) {
63. let p = psegs[i]
64. if (p.startsWith("*")) {
65. let wild = p == "*" ? "0" : p.slice(1)
66. if (i >= segs.length) {
67. if (trailing) {
68. groups[wild] = ""
69. return groups
70. }
71. return null
72. }
73. let rest = ""
74. let j = i
75. while (j < segs.length) {
76. if (rest.length > 0) { rest = rest + "/" }
77. rest = rest + segs[j]
78. j = j + 1
79. }
80. groups[wild] = rest
81. return groups
82. }
83. if (p.startsWith(":")) {
84. let name = p.slice(1)
85. let optional = false
86. if (name.endsWith("?")) {
87. optional = true
88. name = name.slice(0, name.length - 1)
89. }
90. if (i < segs.length) {
91. groups[name] = segs[i]
92. } else {
93. if (optional == false) { return null }
94. groups[name] = null // an ABSENT optional group is null
95. }
96. } else {
97. if (i >= segs.length) { return null }
98. if (p != segs[i]) { return null }
99. }
100. i = i + 1
101. }
102. if (segs.length > psegs.length) { return null }
103. return groups
104. }
106. // the params key a pattern's `*` fills: "0" for a bare one, the name after it
107. // otherwise, "" when the pattern has none (no group has that key: `rest` is null)
108. wildOf(pattern) {
109. for (p of segments(pattern)) {
110. if (p.startsWith("*")) { return p == "*" ? "0" : p.slice(1) }
111. }
112. return ""
113. }
115. // Match a path against the WHOLE table. `rest` is what the `*` took, named or not. Answers { route, kind, params, path } or
116. // null — in the browser a null is a real navigation, on the server a 404.
117. // `start` is the index to resume at: a static mount that holds no file for the url
118. // does not consume it (COMPONENTS §11, D20), so the server asks again past it
119. match(path, Number start = 0) {
120. let clean = cleanPath(path)
121. let segs = segments(clean)
122. let trailing = false
123. if (clean.length > 1 && clean.endsWith("/")) { trailing = true }
124. let i = 0
125. for (r of routes) {
126. if (i >= start) {
127. let groups = matchPattern(r.pattern, segs, trailing)
128. if (groups != null) {
129. return { route = r; kind = kindOf(r); params = groups; path = clean; index = i; rest = groups[wildOf(r.pattern)]; }
130. }
131. }
132. i = i + 1
133. }
134. return null
135. }
137. // The table the BROWSER may hold: the routes it can show itself. A function is
138. // server code and does not travel; direct, file and directory answers are the
139. // server's too — the browser reaches those with a plain request, so it only
140. // needs to know they are not pages.
141. clientTable() {
142. let out = []
143. for (r of routes) {
144. let k = kindOf(r)
145. // the client needs only "a page": the component may be a CLASS value, which
146. // does not survive the wire — the page's module rides the navigation's ack
147. if (k == 'component') { out.push({ pattern = r.pattern; component = true; }) }
148. else if (k != 'function') { out.push({ pattern = r.pattern; kind = k; }) }
149. else { out.push({ pattern = r.pattern; kind = 'function'; }) }
150. }
151. return out
152. }