@nxtedition/lib 23.10.5 → 23.11.0

package/app.js

@@ -480,13 +480,13 @@ export function makeApp(appConfig, onTerminate) {
     compiler = makeTemplateCompiler({ ds, logger, ...appConfig.compiler })
   }
 
-  const undiciDefaults = {
+  const undiciDefaults = Object.freeze({
     connected: 0,
     disconnected: 0,
     connections: 0,
-  }
+  })
 
-  const undici$ = new rxjs.BehaviorSubject(undiciDefaults)
+  const undici$ = new rxjs.BehaviorSubject({ ...undiciDefaults })
   {
     function onConnect(origin, targets) {
       const stats = { ...undici$.value }
@@ -517,7 +517,7 @@ export function makeApp(appConfig, onTerminate) {
         currentDispatcher = null
       }
 
-      undici$.next(undiciDefaults)
+      undici$.next({ ...undiciDefaults })
 
       nextDispatcher.on('connect', onConnect).on('disconnect', onDisconnect)
 

package/http.js

@@ -24,7 +24,7 @@ const maxInt = 2147483647
 let nextReqId = Math.floor(Math.random() * maxInt)
 export function genReqId() {
   nextReqId = (nextReqId + 1) & maxInt
-  return nextReqId.toString(36)
+  return 'req-' + nextReqId.toString(36)
 }
 
 let timeoutError

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "23.10.5",
+  "version": "23.11.0",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",

package/util/template/index-common.d.ts

@@ -0,0 +1,65 @@
+import type { FirstValueFromConfig } from 'rxjs/internal/firstValueFrom'
+import type * as rx from 'rxjs'
+import { DeepstreamClient } from '@nxtedition/deepstream.io-client-js'
+
+export interface MakeTemplateCompilerParams {
+  ds?: DeepstreamClient
+  proxify?: unknown
+  logger?: unknown
+}
+
+export function makeTemplateCompiler(params: MakeTemplateCompilerParams): TemplateCompiler
+
+export interface TemplateCompiler {
+  current: null
+
+  resolveTemplate: <ReturnValue, Context>(
+    template: Nxtpression<ReturnValue, Context> | string,
+    args$?: Context | rx.Observable<Context>,
+    options?: FirstValueFromConfig,
+  ) => Promise<ResolveNxtpressionDeep<Nxtpression<ReturnValue, Context>>>
+
+  onResolveTemplate: <ReturnValue, Context>(
+    template: Nxtpression<ReturnValue, Context> | string,
+    args$?: Context | rx.Observable<Context>,
+  ) => rx.Observable<ResolveNxtpressionDeep<Nxtpression<ReturnValue, Context>>>
+
+  compileTemplate: <ReturnValue, Context>(
+    template: Nxtpression<ReturnValue, Context> | string,
+  ) => null | ((args$?: Context | rx.Observable<Context>) => rx.Observable<ReturnValue>)
+
+  isTemplate: (value: unknown) => value is Nxtpression
+}
+
+export type Nxtpression<ReturnValue = string, Context extends object = object> =
+  // eslint-disable-next-line @typescript-eslint/no-wrapper-object-types
+  | (String & {
+      /**
+       * TS-HACK: this property doesn't really exist on the nxtpression string,
+       * it is only here to make sure the generic Context won't get stripped.
+       */
+      __context: Context
+
+      /**
+       * TS-HACK: this property doesn't really exist on the nxtpression string,
+       * it is only here to make sure the generic Context won't get stripped.
+       */
+      __returnValue: ReturnValue
+    })
+  | string
+  | ReturnValue
+
+export type ResolveNxtpressionDeep<T> =
+  ExtractReturn<T> extends never
+    ? T extends Array<infer U>
+      ? ResolveNxtpressionDeep<U>
+      : T extends object
+        ? {
+            [K in keyof T]: ResolveNxtpressionDeep<T[K]>
+          }
+        : T
+    : ExtractReturn<T>
+type TypeWithReturn<X> = {
+  __returnValue: X
+}
+type ExtractReturn<Type> = Type extends TypeWithReturn<infer X> ? X : never

package/util/template/index-common.js

@@ -0,0 +1,253 @@
+import * as rxjs from 'rxjs'
+import fp from 'lodash/fp.js'
+import getNxtpressionsCompiler from './nextpressions.js'
+import getJavascriptCompiler from './javascript.js'
+import JSON5 from 'json5'
+import objectHash from 'object-hash'
+import { makeWeakCache } from '../../weakCache.js'
+import firstValueFrom from '../../rxjs/firstValueFrom.js'
+
+export function makeTemplateCompiler({ ds, proxify, logger, sha512, fetch }) {
+  const compiler = {
+    current: null,
+    resolveTemplate,
+    onResolveTemplate,
+    compileTemplate,
+    isTemplate,
+  }
+
+  const compilers = {
+    nxt: getNxtpressionsCompiler({ ds, logger, sha512 }),
+    js: getJavascriptCompiler({ ds, proxify, compiler, logger, fetch }),
+  }
+
+  function inner(str) {
+    const templateStart = str.lastIndexOf('{{')
+    if (templateStart === -1) {
+      return null
+    }
+    let bodyStart = templateStart + 2
+
+    let templateEnd = str.indexOf('}}', templateStart + 2)
+    if (templateEnd === -1) {
+      return null
+    }
+    const bodyEnd = templateEnd
+    templateEnd += 2
+
+    let type = 'nxt'
+    if (str[bodyStart] === '#') {
+      type = str.slice(bodyStart + 1).match(/^([a-z]*)/)[1]
+      bodyStart += type.length + 1
+    }
+
+    return {
+      input: str,
+      pre: str.slice(0, templateStart),
+      type,
+      body: str.slice(bodyStart, bodyEnd),
+      post: str.slice(templateEnd),
+    }
+  }
+
+  const hashTemplate = (template, prefix) => {
+    if (typeof template === 'string') {
+      return isTemplate(template) ? objectHash([prefix, template]) : ''
+    } else if (fp.isPlainObject(template)) {
+      let hashes
+      for (const key of Object.keys(template)) {
+        const hash = hashTemplate(template[key], key)
+        if (hash) {
+          hashes ??= []
+          hashes.push(hash)
+        }
+      }
+      return hashes ? objectHash([prefix, hashes]) : ''
+    } else if (fp.isArray(template)) {
+      let hashes
+      for (let idx = 0; idx < template.length; idx++) {
+        const hash = hashTemplate(template[idx], idx)
+        if (hash) {
+          hashes ??= []
+          hashes.push(hash)
+        }
+      }
+      return hashes ? objectHash([prefix, hashes]) : ''
+    } else {
+      return ''
+    }
+  }
+
+  function compileArrayTemplate(template) {
+    let resolvers
+    let indices
+
+    for (let i = 0; i < template.length; i++) {
+      const resolver = _compileTemplate(template[i])
+      if (resolver) {
+        resolvers ??= []
+        resolvers.push(resolver)
+        indices ??= []
+        indices.push(i)
+      }
+    }
+
+    return resolvers
+      ? (arr, args$) => {
+          const len = resolvers.length
+          const values = new Array(len)
+          for (let n = 0; n < len; n++) {
+            values[n] = resolvers[n](arr[indices[n]], args$)
+          }
+
+          return rxjs.combineLatest(values).pipe(
+            rxjs.map((values) => {
+              const ret = [...arr]
+              for (let n = 0; n < values.length; n++) {
+                ret[indices[n]] = values[n]
+              }
+              return ret
+            }),
+          )
+        }
+      : null
+  }
+
+  function compileObjectTemplate(template) {
+    let resolvers
+    let indices
+
+    const keys = Object.keys(template)
+
+    for (let i = 0; i < keys.length; i++) {
+      const resolver = _compileTemplate(template[keys[i]])
+      if (resolver) {
+        resolvers ??= []
+        resolvers.push(resolver)
+        indices ??= []
+        indices.push(keys[i])
+      }
+    }
+
+    return resolvers
+      ? (obj, args$) => {
+          const len = resolvers.length
+          const values = new Array(len)
+          for (let n = 0; n < len; n++) {
+            values[n] = resolvers[n](obj[indices[n]], args$)
+          }
+
+          return rxjs.combineLatest(values).pipe(
+            rxjs.map((values) => {
+              const ret = { ...obj }
+              for (let n = 0; n < values.length; n++) {
+                ret[indices[n]] = values[n]
+              }
+              return ret
+            }),
+          )
+        }
+      : null
+  }
+
+  function compileStringTemplate(template) {
+    const match = inner(template)
+    if (!match) {
+      return null
+    }
+
+    const { pre, type, body, post } = match
+
+    if (type === 'js') {
+      const expr = compilers.js(body)
+
+      if (!pre && !post) {
+        return (str, args$) => expr(args$)
+      }
+
+      return (str, args$) =>
+        rxjs
+          .combineLatest([
+            compileStringTemplate(pre)?.(str, args$) ?? rxjs.of(pre),
+            expr(args$),
+            compileStringTemplate(post)?.(str, args$) ?? rxjs.of(post),
+          ])
+          .pipe(
+            rxjs.map(([pre, body, post]) =>
+              pre || post ? `${pre}${stringify(body)}${post}` : body,
+            ),
+          )
+    } else if (type === 'nxt') {
+      const expr = compilers.nxt(body)
+
+      if (!pre && !post) {
+        return (str, args$) => expr(args$)
+      }
+
+      return (str, args$) =>
+        expr(args$).pipe(
+          rxjs.switchMap((body) =>
+            onResolveTemplate(`${pre}${stringify(body, true)}${post}`, args$),
+          ),
+        )
+    } else {
+      throw new Error('unknown expression type: ' + type)
+    }
+  }
+
+  function stringify(value, escape) {
+    if (value == null) {
+      return ''
+    } else if (fp.isArray(value) || fp.isPlainObject(value)) {
+      return JSON5.stringify(value)
+    } else if (fp.isString(value) && escape) {
+      return value.replace(/"/g, '\\"')
+    }
+    return value
+  }
+
+  function isTemplate(val) {
+    return typeof val === 'string' && val.indexOf('{{') !== -1
+  }
+
+  const _compileTemplateCache = makeWeakCache(
+    (template) => {
+      if (fp.isPlainObject(template)) {
+        return compileObjectTemplate(template)
+      } else if (fp.isArray(template)) {
+        return compileArrayTemplate(template)
+      } else if (isTemplate(template)) {
+        return compileStringTemplate(template)
+      } else {
+        return null
+      }
+    },
+    (template, hash) => hash,
+  )
+
+  function _compileTemplate(template) {
+    const hash = hashTemplate(template)
+    const resolver = hash ? _compileTemplateCache(template, hash) : null
+    return resolver // ? (args$) => resolver(template, args$) : null
+  }
+
+  function compileTemplate(template) {
+    const resolver = _compileTemplate(template)
+    return resolver ? (args$) => resolver(template, args$) : null
+  }
+
+  function resolveTemplate(template, args$, options) {
+    const expr = _compileTemplate(template)
+    return expr ? firstValueFrom(expr(template, args$), options) : template
+  }
+
+  function onResolveTemplate(template, args$) {
+    try {
+      return _compileTemplate(template)?.(template, args$) ?? rxjs.of(template)
+    } catch (err) {
+      return rxjs.throwError(() => err)
+    }
+  }
+
+  return compiler
+}

package/util/template/index-web.d.ts

@@ -0,0 +1 @@
+export * from './index-common.d.ts'

package/util/template/index-web.js

@@ -0,0 +1,28 @@
+import init from '@swc/wasm-web'
+import { makeTemplateCompiler as commonMakeTemplateCompiler } from './index-common.js'
+
+await init()
+
+export function makeTemplateCompiler({ ds, proxify, logger = console }) {
+  return commonMakeTemplateCompiler({
+    ds,
+    proxify,
+    logger,
+    sha512: (data) => {
+      throw new Error('sha512 is not supported')
+    },
+    fetch: async (resource, options) => {
+      // eslint-disable-next-line no-undef
+      const res = await window.fetch(resource, options)
+      return {
+        statusCode: res.status,
+        headers: Object.fromEntries(res.headers.entries()),
+        body: {
+          text: async () => {
+            return await res.text()
+          },
+        },
+      }
+    },
+  })
+}

package/util/template/index.d.ts

@@ -1,58 +1 @@
-import type { FirstValueFromConfig } from 'rxjs/internal/firstValueFrom'
-import type * as rx from 'rxjs'
-
-export function makeTemplateCompiler(params: MakeTemplateCompilerParams): TemplateCompiler
-
-export interface TemplateCompiler {
-  current: null
-
-  resolveTemplate: <ReturnValue, Context>(
-    template: Nxtpression<ReturnValue, Context> | string,
-    args$?: Context | rx.Observable<Context>,
-    options?: FirstValueFromConfig,
-  ) => Promise<ResolveNxtpressionDeep<Nxtpression<ReturnValue, Context>>>
-
-  onResolveTemplate: <ReturnValue, Context>(
-    template: Nxtpression<ReturnValue, Context> | string,
-    args$?: Context | rx.Observable<Context>,
-  ) => rx.Observable<ResolveNxtpressionDeep<Nxtpression<ReturnValue, Context>>>
-
-  compileTemplate: <ReturnValue, Context>(
-    template: Nxtpression<ReturnValue, Context> | string,
-  ) => null | ((args$?: Context | rx.Observable<Context>) => rx.Observable<ReturnValue>)
-
-  isTemplate: (value: unknown) => value is Nxtpression
-}
-
-export type Nxtpression<ReturnValue = string, Context extends object = object> =
-  // eslint-disable-next-line @typescript-eslint/no-wrapper-object-types
-  | (String & {
-      /**
-       * TS-HACK: this property doesn't really exist on the nxtpression string,
-       * it is only here to make sure the generic Context won't get stripped.
-       */
-      __context: Context
-
-      /**
-       * TS-HACK: this property doesn't really exist on the nxtpression string,
-       * it is only here to make sure the generic Context won't get stripped.
-       */
-      __returnValue: ReturnValue
-    })
-  | string
-  | ReturnValue
-
-export type ResolveNxtpressionDeep<T> =
-  ExtractReturn<T> extends never
-    ? T extends Array<infer U>
-      ? ResolveNxtpressionDeep<U>
-      : T extends object
-        ? {
-            [K in keyof T]: ResolveNxtpressionDeep<T[K]>
-          }
-        : T
-    : ExtractReturn<T>
-type TypeWithReturn<X> = {
-  __returnValue: X
-}
-type ExtractReturn<Type> = Type extends TypeWithReturn<infer X> ? X : never
+export * from './index-common.d.ts'

package/util/template/index.js

@@ -1,253 +1,34 @@
-import * as rxjs from 'rxjs'
-import fp from 'lodash/fp.js'
-import getNxtpressionsCompiler from './nextpressions.js'
-import getJavascriptCompiler from './javascript.js'
-import JSON5 from 'json5'
-import objectHash from 'object-hash'
-import { makeWeakCache } from '../../weakCache.js'
-import firstValueFrom from '../../rxjs/firstValueFrom.js'
-
-export function makeTemplateCompiler({ ds, proxify, logger = globalThis.__nxt_lib_app?.logger }) {
-  const compiler = {
-    current: null,
-    resolveTemplate,
-    onResolveTemplate,
-    compileTemplate,
-    isTemplate,
-  }
-
-  const compilers = {
-    nxt: getNxtpressionsCompiler({ ds, logger }),
-    js: getJavascriptCompiler({ ds, proxify, compiler, logger }),
-  }
-
-  function inner(str) {
-    const templateStart = str.lastIndexOf('{{')
-    if (templateStart === -1) {
-      return null
-    }
-    let bodyStart = templateStart + 2
-
-    let templateEnd = str.indexOf('}}', templateStart + 2)
-    if (templateEnd === -1) {
-      return null
-    }
-    const bodyEnd = templateEnd
-    templateEnd += 2
-
-    let type = 'nxt'
-    if (str[bodyStart] === '#') {
-      type = str.slice(bodyStart + 1).match(/^([a-z]*)/)[1]
-      bodyStart += type.length + 1
-    }
-
-    return {
-      input: str,
-      pre: str.slice(0, templateStart),
-      type,
-      body: str.slice(bodyStart, bodyEnd),
-      post: str.slice(templateEnd),
-    }
-  }
-
-  const hashTemplate = (template, prefix) => {
-    if (typeof template === 'string') {
-      return isTemplate(template) ? objectHash([prefix, template]) : ''
-    } else if (fp.isPlainObject(template)) {
-      let hashes
-      for (const key of Object.keys(template)) {
-        const hash = hashTemplate(template[key], key)
-        if (hash) {
-          hashes ??= []
-          hashes.push(hash)
-        }
-      }
-      return hashes ? objectHash([prefix, hashes]) : ''
-    } else if (fp.isArray(template)) {
-      let hashes
-      for (let idx = 0; idx < template.length; idx++) {
-        const hash = hashTemplate(template[idx], idx)
-        if (hash) {
-          hashes ??= []
-          hashes.push(hash)
-        }
-      }
-      return hashes ? objectHash([prefix, hashes]) : ''
-    } else {
-      return ''
-    }
-  }
-
-  function compileArrayTemplate(template) {
-    let resolvers
-    let indices
-
-    for (let i = 0; i < template.length; i++) {
-      const resolver = _compileTemplate(template[i])
-      if (resolver) {
-        resolvers ??= []
-        resolvers.push(resolver)
-        indices ??= []
-        indices.push(i)
-      }
-    }
-
-    return resolvers
-      ? (arr, args$) => {
-          const len = resolvers.length
-          const values = new Array(len)
-          for (let n = 0; n < len; n++) {
-            values[n] = resolvers[n](arr[indices[n]], args$)
-          }
-
-          return rxjs.combineLatest(values).pipe(
-            rxjs.map((values) => {
-              const ret = [...arr]
-              for (let n = 0; n < values.length; n++) {
-                ret[indices[n]] = values[n]
-              }
-              return ret
-            }),
-          )
-        }
-      : null
-  }
-
-  function compileObjectTemplate(template) {
-    let resolvers
-    let indices
-
-    const keys = Object.keys(template)
-
-    for (let i = 0; i < keys.length; i++) {
-      const resolver = _compileTemplate(template[keys[i]])
-      if (resolver) {
-        resolvers ??= []
-        resolvers.push(resolver)
-        indices ??= []
-        indices.push(keys[i])
-      }
-    }
-
-    return resolvers
-      ? (obj, args$) => {
-          const len = resolvers.length
-          const values = new Array(len)
-          for (let n = 0; n < len; n++) {
-            values[n] = resolvers[n](obj[indices[n]], args$)
-          }
-
-          return rxjs.combineLatest(values).pipe(
-            rxjs.map((values) => {
-              const ret = { ...obj }
-              for (let n = 0; n < values.length; n++) {
-                ret[indices[n]] = values[n]
-              }
-              return ret
-            }),
-          )
-        }
-      : null
-  }
-
-  function compileStringTemplate(template) {
-    const match = inner(template)
-    if (!match) {
-      return null
-    }
-
-    const { pre, type, body, post } = match
-
-    if (type === 'js') {
-      const expr = compilers.js(body)
-
-      if (!pre && !post) {
-        return (str, args$) => expr(args$)
-      }
-
-      return (str, args$) =>
-        rxjs
-          .combineLatest([
-            compileStringTemplate(pre)?.(str, args$) ?? rxjs.of(pre),
-            expr(args$),
-            compileStringTemplate(post)?.(str, args$) ?? rxjs.of(post),
-          ])
-          .pipe(
-            rxjs.map(([pre, body, post]) =>
-              pre || post ? `${pre}${stringify(body)}${post}` : body,
-            ),
-          )
-    } else if (type === 'nxt') {
-      const expr = compilers.nxt(body)
-
-      if (!pre && !post) {
-        return (str, args$) => expr(args$)
-      }
-
-      return (str, args$) =>
-        expr(args$).pipe(
-          rxjs.switchMap((body) =>
-            onResolveTemplate(`${pre}${stringify(body, true)}${post}`, args$),
-          ),
-        )
-    } else {
-      throw new Error('unknown expression type: ' + type)
-    }
-  }
-
-  function stringify(value, escape) {
-    if (value == null) {
-      return ''
-    } else if (fp.isArray(value) || fp.isPlainObject(value)) {
-      return JSON5.stringify(value)
-    } else if (fp.isString(value) && escape) {
-      return value.replace(/"/g, '\\"')
-    }
-    return value
-  }
-
-  function isTemplate(val) {
-    return typeof val === 'string' && val.indexOf('{{') !== -1
-  }
-
-  const _compileTemplateCache = makeWeakCache(
-    (template) => {
-      if (fp.isPlainObject(template)) {
-        return compileObjectTemplate(template)
-      } else if (fp.isArray(template)) {
-        return compileArrayTemplate(template)
-      } else if (isTemplate(template)) {
-        return compileStringTemplate(template)
-      } else {
-        return null
-      }
-    },
-    (template, hash) => hash,
-  )
-
-  function _compileTemplate(template) {
-    const hash = hashTemplate(template)
-    const resolver = hash ? _compileTemplateCache(template, hash) : null
-    return resolver // ? (args$) => resolver(template, args$) : null
-  }
-
-  function compileTemplate(template) {
-    const resolver = _compileTemplate(template)
-    return resolver ? (args$) => resolver(template, args$) : null
-  }
-
-  function resolveTemplate(template, args$, options) {
-    const expr = _compileTemplate(template)
-    return expr ? firstValueFrom(expr(template, args$), options) : template
-  }
+import { createRequire } from 'node:module'
+import { readFileSync } from 'node:fs'
+import { initSync } from '@swc/wasm-web'
+import { makeTemplateCompiler as commonMakeTemplateCompiler } from './index-common.js'
+import { hashSync } from 'hasha'
+import { request, Agent } from '@nxtedition/nxt-undici'
+
+export * from './index-common.js'
+
+const require = createRequire(import.meta.url)
+const wasmPath = require.resolve('@swc/wasm-web').replace('wasm.js', 'wasm_bg.wasm')
+const wasmBuffer = readFileSync(wasmPath)
+
+initSync({ module: wasmBuffer })
+
+export function makeTemplateCompiler({ logger = globalThis.__nxt_lib_app?.logger, ...args }) {
+  return commonMakeTemplateCompiler({
+    ...args,
+    logger,
+    sha256: (data) => hashSync(data),
+    fetch,
+  })
+}
 
-  function onResolveTemplate(template, args$) {
-    try {
-      return _compileTemplate(template)?.(template, args$) ?? rxjs.of(template)
-    } catch (err) {
-      return rxjs.throwError(() => err)
-    }
-  }
+const fetchClient = new Agent({
+  connections: 128,
+})
 
-  return compiler
+function fetch(resource, options) {
+  return request(resource, {
+    ...options,
+    dispatcher: fetchClient,
+  })
 }

package/util/template/javascript.js

@@ -1,10 +1,8 @@
-import assert from 'node:assert'
 import { makeWeakCache } from '../../weakCache.js'
 import * as rxjs from 'rxjs'
 import objectHash from 'object-hash'
 import * as datefns from 'date-fns'
 import JSON5 from 'json5'
-import { request, Agent } from '@nxtedition/nxt-undici'
 import fp from 'lodash/fp.js'
 import moment from 'moment-timezone'
 import Timecode from 'smpte-timecode'
@@ -30,12 +28,8 @@ class TimerEntry {
   }
 }
 
-const fetchClient = new Agent({
-  connections: 128,
-})
-
 class FetchEntry {
-  constructor(key, refresh, { resource, options }) {
+  constructor(key, refresh, { resource, options, fetch }) {
     this.key = key
     this.counter = -1
     this.ac = new AbortController()
@@ -57,12 +51,11 @@ class FetchEntry {
     }
 
     try {
-      request(resource, {
+      fetch(resource, {
         ...options,
         headers,
         body,
         signal: this.ac.signal,
-        dispatcher: fetchClient,
       })
         .then(async (res) => {
           // TODO (fix): Check cache-control and invalidate entry...
@@ -202,8 +195,12 @@ class PromiseEntry {
 }
 
 function proxify(value, expression, handler, suspend = true) {
-  assert(expression)
-  assert(handler)
+  if (!expression) {
+    throw new Error('expression is not defined')
+  }
+  if (!handler) {
+    throw new Error('handler is not defined')
+  }
 
   if (!value) {
     return value
@@ -225,7 +222,7 @@ function makeWrapper(expression) {
   return (value, suspend = true) => proxify(value, expression, handler, suspend)
 }
 
-export default function ({ ds, proxify, compiler, logger }) {
+export default function ({ ds, proxify, compiler, logger, fetch: fetchFn }) {
   class Expression {
     constructor(script, expression, args, observer) {
       this._expression = expression
@@ -358,7 +355,9 @@ export default function ({ ds, proxify, compiler, logger }) {
       compiler.current = this
 
       try {
-        assert(this._suspended === false)
+        if (this._suspended !== false) {
+          throw new Error('expression is already suspended')
+        }
 
         const savedThis = {
           fp: globalThis.fp,
@@ -469,7 +468,7 @@ export default function ({ ds, proxify, compiler, logger }) {
 
     _getFetch(resource, options, suspend) {
       const key = JSON.stringify({ resource, options })
-      const entry = this._getEntry(key, FetchEntry, { resource, options })
+      const entry = this._getEntry(key, FetchEntry, { resource, options, fetch: fetchFn })
 
       if (entry.refresh === null) {
         return null

package/util/template/nextpressions.js

@@ -2,8 +2,6 @@ import moment from 'moment-timezone'
 import * as rxjs from 'rxjs'
 import JSON5 from 'json5'
 import fp from 'lodash/fp.js'
-import NestedError from 'nested-error-stacks'
-import { hashSync } from 'hasha'
 import split from 'split-string'
 import { makeWeakCache } from '../../weakCache.js'
 
@@ -27,7 +25,7 @@ function asFilter(transform, predicate, obj) {
   )
 }
 
-export default function ({ ds, logger } = {}) {
+export default function ({ ds, logger, sha512 } = {}) {
   const FILTERS = {
     // any
     ...asFilter(null, null, {
@@ -87,9 +85,9 @@ export default function ({ ds, logger } = {}) {
       isString: () => (value) => fp.isString(value),
       ternary: (a, b) => (value) => (value ? a : b),
       cond: (a, b) => (value) => (value ? a : b),
-      hasha: (options) => (value) => hashSync(JSON.stringify(value), options || {}),
+      hasha: (options) => (value) => sha512(JSON.stringify(value), options || {}),
       hashaint: (options) => (value) =>
-        parseInt(hashSync(JSON.stringify(value), options || {}).slice(-13), 16),
+        parseInt(sha512(JSON.stringify(value), options || {}).slice(-13), 16),
       return: () => (value) => value || RETURN,
       add:
         (...args) =>
@@ -522,7 +520,7 @@ export default function ({ ds, logger } = {}) {
         }
         return x ? JSON5.parse(x) : x
       } catch (err) {
-        throw new NestedError(`failed to parse token ${x}`, err)
+        throw new Error(`failed to parse token ${x}`, { cuase: err })
       }
     })
 
@@ -596,7 +594,7 @@ export default function ({ ds, logger } = {}) {
           }),
         )
     } catch (err) {
-      throw new NestedError(`failed to parse expression ${expression}`, err)
+      throw new Error(`failed to parse expression ${expression}`, { cause: err })
     }
   })
 }

package/util/template/transform.js

@@ -1,19 +1,4 @@
-import { createRequire } from 'node:module'
-import { readFileSync } from 'node:fs'
-import { parseSync, printSync, initSync } from '@swc/wasm-web'
-import init from '@swc/wasm-web'
-
-const isNode = typeof process !== 'undefined' && process.toString() === '[object process]'
-
-if (isNode) {
-  const require = createRequire(import.meta.url)
-  const wasmPath = require.resolve('@swc/wasm-web').replace('wasm.js', 'wasm_bg.wasm')
-  const wasmBuffer = readFileSync(wasmPath)
-
-  initSync({ module: wasmBuffer })
-} else {
-  await init()
-}
+import { parseSync, printSync } from '@swc/wasm-web'
 
 export default function (code) {
   const ast = parseSync(code, { syntax: 'ecmascript', script: true })

package/util/template/transform.test.js

@@ -1,6 +1,15 @@
 import { test } from 'node:test'
 import assert from 'node:assert'
 import transform from './transform.js'
+import { createRequire } from 'node:module'
+import { readFileSync } from 'node:fs'
+import { initSync } from '@swc/wasm-web'
+
+const require = createRequire(import.meta.url)
+const wasmPath = require.resolve('@swc/wasm-web').replace('wasm.js', 'wasm_bg.wasm')
+const wasmBuffer = readFileSync(wasmPath)
+
+initSync({ module: wasmBuffer })
 
 test('transform', function () {
   assert.strictEqual(transform('const x = 2; x;'), 'const x = 2;\nreturn x;\n')