@c9up/ream 0.2.13 → 0.2.15

package/src/testing/TestClient.ts

@@ -368,15 +368,15 @@ export function parseHttpResponse(raw: string | Buffer): TestResponse {
 
   const lines = headerSection.split('\r\n')
   const statusLine = lines[0] ?? ''
-  const statusMatch = statusLine.match(/HTTP\/\d+\.\d+ (\d+)/)
-  const status = statusMatch ? Number.parseInt(statusMatch[1], 10) : 0
+  const [, statusDigits] = statusLine.match(/HTTP\/\d+\.\d+ (\d+)/) ?? []
+  const status = statusDigits === undefined ? 0 : Number.parseInt(statusDigits, 10)
 
   const headers: Dict = {}
-  for (let i = 1; i < lines.length; i++) {
-    const colonIdx = lines[i].indexOf(':')
+  for (const line of lines.slice(1)) {
+    const colonIdx = line.indexOf(':')
     if (colonIdx === -1) continue
-    const key = lines[i].slice(0, colonIdx).trim().toLowerCase()
-    const value = lines[i].slice(colonIdx + 1).trim()
+    const key = line.slice(0, colonIdx).trim().toLowerCase()
+    const value = line.slice(colonIdx + 1).trim()
     headers[key] = value
   }
 

package/src/utils/Macroable.ts

@@ -38,7 +38,11 @@ export class Macroable {
    * `HttpContext`, and two subclasses declaring the same name clobbered each
    * other silently.
    */
-  static macro(this: typeof Macroable, name: string, fn: MacroFn): void {
+  // `{ prototype: object }`, not `typeof Macroable`: a subclass whose
+  // constructor takes arguments — `Request`, say — has a different static side,
+  // so `Request.macro(...)` was "the 'this' context of type 'typeof Request' is
+  // not assignable". What this needs from `this` is the prototype it defines on.
+  static macro(this: { prototype: object }, name: string, fn: MacroFn): void {
     Object.defineProperty(this.prototype, name, {
       value: fn,
       writable: true,
@@ -51,7 +55,7 @@ export class Macroable {
    * `getter`). With `singleton`, the value is computed once per instance and
    * cached.
    */
-  static getter(this: typeof Macroable, name: string, fn: GetterFn, singleton = false): void {
+  static getter(this: { prototype: object }, name: string, fn: GetterFn, singleton = false): void {
     if (!singleton) {
       Object.defineProperty(this.prototype, name, { get: fn, configurable: true })
       return

package/src/utils/objectPath.ts

@@ -77,9 +77,13 @@ export function hasPath(source: unknown, path: string): boolean {
  */
 export function setPath(target: UnknownRecord, path: string, value: unknown): UnknownRecord {
   const segments = toSegments(path)
+  // The last segment is the one written; everything before it is walked. Split
+  // off by name rather than by index, so neither has to be read back out of
+  // the array afterwards and re-checked for existence.
+  const last = segments.pop()
+  if (last === undefined) return target
   let current: UnknownRecord = target
-  for (let i = 0; i < segments.length - 1; i += 1) {
-    const key = segments[i]
+  for (const key of segments) {
     const next = current[key]
     if (!isIndexable(next)) {
       const created: UnknownRecord = {}
@@ -89,7 +93,7 @@ export function setPath(target: UnknownRecord, path: string, value: unknown): Un
       current = next
     }
   }
-  current[segments[segments.length - 1]] = value
+  current[last] = value
   return target
 }
 
@@ -115,12 +119,14 @@ export function omitPaths(source: UnknownRecord, paths: string[]): UnknownRecord
   const result = structuredClone(source)
   for (const path of paths) {
     const segments = toSegments(path)
+    const last = segments.pop()
+    if (last === undefined) continue
     let current: unknown = result
-    for (let i = 0; i < segments.length - 1; i += 1) {
+    for (const key of segments) {
       if (!isIndexable(current)) break
-      current = current[segments[i]]
+      current = current[key]
     }
-    if (isIndexable(current)) delete current[segments[segments.length - 1]]
+    if (isIndexable(current)) delete current[last]
   }
   return result
 }