tickets

5.6 KB

1. // lib/util.hl — small helpers every topic shares (env, storage path, URLs, lists, text checks, Vienna time).
2. // Statics only; no topic logic here.
3. import { env } from 'hl:proc'
4. import { timestamp } from 'hl:time'
6. // ---- env and storage -----------------------------------------------------------------------
7. static envOr = (name, fallback) => {
8. v = env(name)
9. return v != null && v.trim() != '' ? v.trim() : fallback
10. }
12. // THE TABLE DIRECTORY of every hl:mpackdb table (storage/mpackdb/; TICKETS_STORAGE moves it — the gate runs on its
13. // own). Relative paths resolve against the ENTRY SCRIPT's directory (project.hl's) — tools must pass an absolute one.
14. static storageDir = env('TICKETS_STORAGE') != null ? env('TICKETS_STORAGE') : './storage/mpackdb'
16. // ---- the URLs a person uses ------------------------------------------------------------------
17. // ticket #25: a project's page is /<slug>, a ticket's /<slug>/<number> (the old /projects/… forms answer 301);
18. // the API keeps its /api/projects/… paths
19. static ticketHref = (project, number) => { return '/' + project + '/' + number }
20. static ticketApiHref = (project, number) => { return '/api/projects/' + project + '/tickets/' + number }
21. static projectHrefOf = (project) => { return '/' + project }
22. static settingsHrefOf = (project) => { return '/projects/' + project + '/settings' }
24. // ---- lists and records -----------------------------------------------------------------------
25. // an empty list written to hl:mpackdb comes back as an empty hybrid (`.length` null):
26. // every read of a found list goes through here
27. static countOf = (list) => {
28. if (list == null) { return 0 }
29. n = list.length
30. return n == null ? 0 : n
31. }
32. static first = (list) => { return countOf(list) > 0 ? list[0] : null }
34. // every record is written as a whole (hl:mpackdb's update replaces it)
35. static merged = (rec, changes) => {
36. out = {}
37. for (k of rec.keys()) { out[k] = rec[k] }
38. for (k of changes.keys()) { out[k] = changes[k] }
39. return out
40. }
42. // insertion sorts (no list sort() in the language, hybriel #6) — stable; they sort their copy and return it
43. static oldestFirst = (rows, field) => {
44. let i = 1
45. while (i < rows.length) {
46. let cur = rows[i]
47. let j = i - 1
48. while (j >= 0 && rows[j][field] > cur[field]) {
49. rows[j + 1] = rows[j]
50. j = j - 1
51. }
52. rows[j + 1] = cur
53. i = i + 1
54. }
55. return rows
56. }
57. static newestFirst = (rows, field) => {
58. let i = 1
59. while (i < rows.length) {
60. let cur = rows[i]
61. let j = i - 1
62. while (j >= 0 && rows[j][field] < cur[field]) {
63. rows[j + 1] = rows[j]
64. j = j - 1
65. }
66. rows[j + 1] = cur
67. i = i + 1
68. }
69. return rows
70. }
72. // ---- text ---------------------------------------------------------------------------------------
73. static clean = (s) => { return s == null ? '' : ('' + s).trim() }
75. // a query value, percent-encoded (encodeURIComponent is a global, hybriel#14)
76. static encode = (s) => { return encodeURIComponent('' + s) }
78. // a string of ASCII digits only (a ticket number in a URL); '' is not
79. static isDigits = (s) => {
80. if (s == null) { return false }
81. t = '' + s
82. if (t.length == 0 || t.length > 12) { return false }
83. let i = 0
84. while (i < t.length) {
85. let c = t.charCodeAt(i)
86. if (c < 48 || c > 57) { return false }
87. i = i + 1
88. }
89. return true
90. }
92. // only lowercase hex (ident's one-time codes are 48 hex)
93. static isHex = (s, max) => {
94. if (s == null || hlTypeName(s) != 'String' || s.length == 0 || s.length > max) { return false }
95. let i = 0
96. while (i < s.length) {
97. let c = s.charCodeAt(i)
98. if (!((c >= 48 && c <= 57) || (c >= 97 && c <= 102))) { return false }
99. i = i + 1
100. }
101. return true
102. }
104. // a short one-line text: trimmed, at most `max` characters, no control characters
105. static plainError = (s, max, what) => {
106. if (s == null || hlTypeName(s) != 'String') { return what + ' must be text' }
107. t = s.trim()
108. if (t.length > max) { return what + ' is too long (at most ' + max + ' characters)' }
109. let i = 0
110. while (i < t.length) {
111. let c = t.charCodeAt(i)
112. if (c < 32 || c == 127) { return what + ' must be one line without control characters' }
113. i = i + 1
114. }
115. return null
116. }
118. // ---- time: epoch ms → "YYYY-MM-DD HH:MM" in Europe/Vienna (ticket #10) ---------------------------
119. // hl:time has no time zones (now() + a UTC timestamp() only; "timezones are a userland
120. // concern" — its header). This is the smallest correct userland rule for Vienna: the EU
121. // rule in force since 1996 — CEST (UTC+2) from the last Sunday of March 01:00 UTC to the
122. // last Sunday of October 01:00 UTC, CET (UTC+1) otherwise. Storage stays epoch ms (UTC);
123. // only the rendering shifts. Checked against node's Intl (tests/localtime.hl + the gate).
124. static DAY = 86400000
125. static HOUR = 3600000
127. // integer division for a >= 0 (the language has `%` but no floor in the core)
128. static idiv = (a, b) => { return (a - a % b) / b }
130. // days since 1970-01-01 of a civil date (H. Hinnant's days_from_civil, years >= 1970)
131. static daysFromCivil = (y, m, d) => {
132. yy = m <= 2 ? y - 1 : y
133. era = idiv(yy, 400)
134. yoe = yy - era * 400
135. mp = m > 2 ? m - 3 : m + 9
136. doy = idiv(153 * mp + 2, 5) + d - 1
137. doe = yoe * 365 + idiv(yoe, 4) - idiv(yoe, 100) + doy
138. return era * 146097 + doe - 719468
139. }
141. // the last Sunday of a 31-day month (March, October), 01:00 UTC, as epoch ms
142. static lastSundayAt1 = (y, m) => {
143. days = daysFromCivil(y, m, 31)
144. wd = (days + 4) % 7 // 0 = Sunday: 1970-01-01 was a Thursday
145. return (days - wd) * DAY + HOUR
146. }
148. static viennaOffset = (ms) => {
149. y = toNumber(timestamp(ms).slice(0, 4))
150. return ms >= lastSundayAt1(y, 3) && ms < lastSundayAt1(y, 10) ? 2 * HOUR : HOUR
151. }
153. // "YYYY-MM-DD HH:MM", Vienna wall time — what a person reads
154. static localStamp = (ms) => {
155. t = timestamp(ms + viennaOffset(ms))
156. return t.slice(0, 10) + ' ' + t.slice(11, 16)
157. }