@nxtedition/lib 26.8.8 → 27.0.0

package/util/template/javascript.js

@@ -1,692 +0,0 @@
-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 fp from 'lodash/fp.js'
-import moment from 'moment-timezone'
-import Timecode from 'smpte-timecode'
-import transform from './transform.js'
-import { doYield } from '../../yield.js'
-
-const SEP = String.fromCharCode(30) // ASCII 1E
-
-const kSuspend = Symbol('kSuspend')
-const kEmpty = Symbol('kEmpty')
-const maxInt = 2147483647
-
-class TimerEntry {
-  constructor(key, refresh, delay) {
-    this.key = key
-    this.counter = -1
-
-    this.timer = setTimeout(refresh, delay)
-  }
-
-  dispose() {
-    clearTimeout(this.timer)
-    this.timer = null
-  }
-}
-
-class FetchEntry {
-  constructor(key, refresh, { resource, options, fetch }) {
-    this.key = key
-    this.counter = -1
-    this.ac = new AbortController()
-
-    this.refresh = refresh
-    this.body = null
-    this.status = null
-    this.error = null
-
-    let { headers, body, method } = options ?? {}
-
-    if (fp.isPlainObject(body) || fp.isArray(body)) {
-      headers = { 'content-type': 'application/json', ...headers }
-      body = JSON.stringify(body)
-    }
-
-    if (!method && body) {
-      method = 'POST'
-    }
-
-    try {
-      fetch(resource, {
-        ...options,
-        headers,
-        body,
-        signal: this.ac.signal,
-      })
-        .then(async (res) => {
-          // TODO (fix): Check cache-control and invalidate entry...
-          const body = await res.body.text()
-          if (this.refresh) {
-            // TODO (fix): max size...
-            this.status = res.statusCode
-            this.headers = res.headers
-            this.body = body
-            this.refresh()
-          }
-        })
-        .catch((err) => {
-          if (this.refresh) {
-            this.error = Object.assign(new Error('fetch failed'), {
-              data: { resource },
-              cause: err,
-            })
-            this.refresh()
-          }
-        })
-    } catch (err) {
-      this.error = Object.assign(new Error('fetch failed'), { data: { resource }, cause: err })
-      this.refresh()
-    }
-  }
-
-  dispose() {
-    this.refresh = null
-
-    this.ac.abort()
-    this.ac = null
-  }
-}
-
-class RecordEntry {
-  constructor(key, refresh, { name, path, ds, state }) {
-    if (state == null) {
-      state =
-        name.startsWith('{') || name.includes('?')
-          ? ds.record.STATE.PROVIDER
-          : ds.record.STATE.SERVER
-    } else if (typeof state === 'string') {
-      state = ds.record.STATE[state.toUpperCase()] ?? ds.record.STATE.SERVER
-    }
-
-    this.key = key
-    this.counter = -1
-
-    this.record = ds.record.getRecord(name)
-
-    this.data = this.record.get(path)
-    this.ready = this.record.state >= state
-    this.refresh = () => {
-      const data = this.record.get(path)
-      const ready = this.record.state >= state
-
-      if (data !== this.data || ready !== this.ready) {
-        this.data = data
-        this.ready = ready
-        refresh()
-      }
-    }
-
-    if (this.record.subscribe) {
-      this.record.subscribe(this.refresh)
-    } else {
-      this.record.on('update', this.refresh)
-    }
-  }
-
-  dispose() {
-    this.record.unref()
-    if (this.record.unsubscribe) {
-      this.record.unsubscribe(this.refresh)
-    } else {
-      this.record.off('update', this.refresh)
-    }
-
-    this.record = null
-    this.refresh = null
-    this.data = null
-    this.ready = false
-  }
-}
-
-class ObservableEntry {
-  constructor(key, refresh, observable) {
-    this.key = key
-    this.counter = -1
-    this.value = kEmpty
-    this.error = null
-    this.refresh = refresh
-    this.sync = true
-    this.subscription = observable.subscribe({
-      next: (value) => {
-        this.value = value
-        if (!this.sync) {
-          this.refresh()
-        }
-      },
-      error: (err) => {
-        this.error = err
-        if (!this.sync) {
-          this.refresh()
-        }
-      },
-    })
-    this.sync = false
-  }
-
-  dispose() {
-    this.subscription.unsubscribe()
-    this.subscription = null
-    this.refresh = null
-  }
-}
-
-class PromiseEntry {
-  constructor(key, refresh, promise) {
-    this.key = key
-    this.counter = -1
-    this.value = kEmpty
-    this.error = null
-    this.refresh = refresh
-
-    promise.then(
-      (value) => {
-        if (this.refresh) {
-          this.value = value
-          this.refresh()
-        }
-      },
-      (err) => {
-        if (this.refresh) {
-          this.error = err
-          this.refresh()
-        }
-      },
-    )
-  }
-
-  dispose() {
-    this.refresh = null
-  }
-}
-
-function proxify(value, expression, handler, suspend = true) {
-  if (!expression) {
-    throw new Error('expression is not defined')
-  }
-  if (!handler) {
-    throw new Error('handler is not defined')
-  }
-
-  if (!value) {
-    return value
-  } else if (rxjs.isObservable(value)) {
-    return proxify(expression.observe(value, suspend), expression, handler, suspend)
-  } else if (typeof value?.then === 'function') {
-    return proxify(expression.wait(value, suspend), expression, handler, suspend)
-  } else if (typeof value === 'object') {
-    return new Proxy(value, handler)
-  } else {
-    return value
-  }
-}
-
-function makeWrapper(expression) {
-  const handler = {
-    get: (target, prop) => proxify(target[prop], expression, handler),
-  }
-  return (value, suspend = true) => proxify(value, expression, handler, suspend)
-}
-
-export default function ({ ds, proxify, compiler, logger, platform }) {
-  const schedule = platform?.schedule ?? doYield
-
-  class Expression {
-    constructor(script, expression, args, observer) {
-      this._expression = expression
-      this._observer = observer
-      this._script = script
-
-      // TODO (perf): This could be faster by using an array + indices.
-      // A bit similar to how react-hooks works.
-      this._entries = new Map()
-      this._refreshing = false
-      this._counter = 0
-      this._value = kEmpty
-      this._disposing = false
-      this._destroyed = false
-      this._subscription = null
-      this._args = kEmpty
-      this._wrap = null
-      this._suspended = false
-      this._errored = false
-      this._globalThis = {
-        fp: null,
-        moment: null,
-        Timecode: null,
-        datefns: null,
-        JSON5: null,
-        $: null,
-        nxt: null,
-      }
-
-      if (rxjs.isObservable(args)) {
-        this._subscription = args.subscribe({
-          next: (args) => {
-            this._args = proxify ? this.wrap(args) : args
-            this._refresh()
-          },
-          error: (err) => {
-            this._observer.error(err)
-          },
-        })
-      } else {
-        this._args = proxify ? this.wrap(args) : args
-        this._refresh()
-      }
-    }
-
-    wrap(value, suspend = true) {
-      this._wrap ??= makeWrapper(this)
-      return this._wrap(value, suspend)
-    }
-
-    suspend() {
-      throw kSuspend
-    }
-
-    fetch(resource, options, suspend) {
-      return this._getFetch(resource, options, suspend)
-    }
-
-    observe(observable, suspend) {
-      return this._getObservable(observable, suspend)
-    }
-
-    then(promise, suspend) {
-      return this._getPromise(promise, suspend)
-    }
-
-    /** @deprecated */
-    ds(name, state, suspend) {
-      return !name || typeof name !== 'string'
-        ? ds.record.JSON.EMPTY_OBJ
-        : this._getRecord(name, null, state, suspend)
-    }
-
-    get(name, path, state, suspend) {
-      return !name || typeof name !== 'string'
-        ? path
-          ? undefined
-          : ds.record.JSON.EMPTY_OBJ
-        : this._getRecord(name, path, state, suspend)
-    }
-
-    timer(dueTime, dueValue = dueTime, suspend) {
-      return this._getTimer(dueTime, dueValue, suspend)
-    }
-
-    asset(id, type, state, suspend) {
-      return this._getHasRawAssetType(id, type, state, suspend)
-    }
-
-    hash(value) {
-      return objectHash(value)
-    }
-
-    /** @deprecated */
-    _ds(name, postfix, state, suspend) {
-      return !name || typeof name !== 'string'
-        ? ds.record.JSON.EMPTY_OBJ
-        : this._getRecord(postfix ? name + postfix : name, null, state, suspend)
-    }
-
-    _get(name, postfix, path, state, suspend) {
-      return !name || typeof name !== 'string'
-        ? path
-          ? undefined
-          : ds.record.JSON.EMPTY_OBJ
-        : this._getRecord(postfix ? name + postfix : name, path, state, suspend)
-    }
-
-    _asset(id, type, state, suspend) {
-      if (!type || typeof type !== 'string') {
-        throw new Error(`invalid argument: type (${type})`)
-      }
-
-      return !id || typeof id !== 'string'
-        ? null
-        : this._getHasRawAssetType(id, type, state, suspend)
-    }
-
-    _destroy() {
-      this._destroyed = true
-      this._subscription?.unsubscribe()
-
-      for (const entry of this._entries.values()) {
-        entry.dispose()
-      }
-      this._entries.clear()
-    }
-
-    _refreshImpl = () => {
-      this._refreshing = false
-
-      if (this._destroyed || this._disposing || this._args === kEmpty) {
-        return
-      }
-
-      this._counter = (this._counter + 1) & maxInt
-
-      const previous = compiler.current
-      compiler.current = this
-
-      try {
-        if (this._suspended !== false) {
-          throw new Error('expression is already suspended')
-        }
-
-        this._globalThis.fp = globalThis.fp
-        this._globalThis.moment = globalThis.moment
-        this._globalThis.Timecode = globalThis.Timecode
-        this._globalThis.datefns = globalThis.datefns
-        this._globalThis.JSON5 = globalThis.JSON5
-        this._globalThis.$ = globalThis.$
-        this._globalThis.nxt = globalThis.nxt
-
-        let value
-        try {
-          globalThis.fp = fp
-          globalThis.moment = moment
-          globalThis.Timecode = Timecode
-          globalThis.datefns = datefns
-          globalThis.JSON5 = JSON5
-          globalThis.$ = this._args
-          globalThis.nxt = this
-
-          // TODO (fix): This should be sandboxed somehow...
-          // - Use a webworker?
-          // - Use vm for Node only?
-          // - Use https://github.com/tc39/proposal-shadowrealm?
-          value = this._script()
-        } finally {
-          globalThis.fp = this._globalThis.fp
-          globalThis.moment = this._globalThis.moment
-          globalThis.Timecode = this._globalThis.Timecode
-          globalThis.datefns = this._globalThis.datefns
-          globalThis.JSON5 = this._globalThis.JSON5
-          globalThis.$ = this._globalThis.$
-          globalThis.nxt = this._globalThis.nxt
-        }
-
-        this._errored = false
-        if (this._suspended) {
-          return
-        }
-
-        if (value !== this._value) {
-          this._value = value
-          this._observer.next(value)
-        }
-      } catch (err) {
-        if (err === kSuspend) {
-          return
-        }
-
-        this._errored = true
-
-        const error = Object.assign(new Error('expression failed'), {
-          cause: err,
-          data: { expression: this._expression, data: this._args },
-        })
-
-        if (this._suspended) {
-          if (logger) {
-            logger.error({ err: error })
-          } else {
-            process.emitWarning(error)
-          }
-        } else {
-          this._observer.error(error)
-        }
-      } finally {
-        compiler.current = previous
-
-        this._suspended = false
-        this._disposing = true
-
-        for (const entry of this._entries.values()) {
-          if (entry.counter !== this._counter) {
-            entry.dispose()
-            this._entries.delete(entry.key)
-          }
-        }
-
-        // TODO (perf): Make this work.
-        // if (!this._entries) {
-        //   this._args = null
-        // }
-
-        this._disposing = false
-      }
-    }
-
-    _refresh = () => {
-      if (this._refreshing || this._destroyed || this._disposing || this._args === kEmpty) {
-        return
-      }
-
-      this._refreshing = true
-      schedule(this._refreshImpl)
-    }
-
-    _getEntry(key, Entry, opaque) {
-      let entry = this._entries.get(key)
-      if (!entry) {
-        entry = new Entry(key, this._refresh, opaque)
-        this._entries.set(key, entry)
-      }
-      entry.counter = this._counter
-      return entry
-    }
-
-    _getFetch(resource, options, suspend) {
-      const key = JSON.stringify({ resource, options })
-      const entry = this._getEntry(key, FetchEntry, { resource, options, fetch: platform.fetch })
-
-      if (entry.refresh === null) {
-        return null
-      }
-
-      if (entry.error) {
-        throw entry.error
-      }
-
-      if (!entry.status) {
-        this._suspended = true
-        if (suspend ?? this._errored) {
-          throw kSuspend
-        } else {
-          return null
-        }
-      }
-
-      return { status: entry.status, headers: entry.headers, body: entry.body }
-    }
-
-    _getObservable(observable, suspend) {
-      if (!rxjs.isObservable(observable)) {
-        throw new Error(`invalid argument: observable (${observable})`)
-      }
-
-      const entry = this._getEntry(observable, ObservableEntry, observable)
-
-      if (entry.refresh === null) {
-        return null
-      }
-
-      if (entry.error) {
-        throw entry.error
-      }
-
-      if (entry.value === kEmpty) {
-        this._suspended = true
-        if (suspend ?? this._errored) {
-          throw kSuspend
-        } else {
-          return null
-        }
-      }
-
-      return entry.value
-    }
-
-    _getPromise(promise, suspend) {
-      if (typeof promise?.then !== 'function') {
-        throw new Error(`invalid argument: Promise (${promise})`)
-      }
-
-      const entry = this._getEntry(promise, PromiseEntry, promise)
-
-      if (entry.refresh === null) {
-        return null
-      }
-
-      if (entry.error) {
-        throw entry.error
-      }
-
-      if (entry.value === kEmpty) {
-        this._suspended = true
-        if (suspend ?? this._errored) {
-          throw kSuspend
-        } else {
-          return null
-        }
-      }
-
-      return entry.value
-    }
-
-    _getTimer(dueTime, dueValue = dueTime, suspend) {
-      const key = JSON.stringify({ dueTime, dueValue })
-
-      dueTime = Number.isFinite(dueTime) ? dueTime : new Date(dueTime).valueOf()
-
-      const delay = dueTime - Date.now()
-
-      if (Number.isFinite(dueTime) && delay > 0 && delay < 2 ** 31 - 1) {
-        this._getEntry(key, TimerEntry, delay)
-        if (suspend ?? this._errored) {
-          throw kSuspend
-        } else {
-          return null
-        }
-      }
-
-      return dueValue
-    }
-
-    _getRecord(name, path, state, suspend) {
-      if (name != null && typeof name !== 'string') {
-        throw new Error(`invalid argument: key (${name})`)
-      }
-
-      if (path != null && typeof path !== 'string') {
-        throw new Error(`invalid argument: path (${path})`)
-      }
-
-      if (state != null && typeof state !== 'string' && typeof state !== 'number') {
-        throw new Error(`invalid argument: state (${state})`)
-      }
-
-      if (typeof state === 'string') {
-        state = ds.record.STATE[state.toUpperCase()]
-      } else if (state == null) {
-        state = ds.record.STATE.SERVER
-      }
-
-      const key = '' + (name ?? '') + SEP + (path ?? '') + SEP + (state ?? '')
-      const entry = this._getEntry(key, RecordEntry, { ds, name, path, state })
-
-      if (!entry.ready) {
-        this._suspended = true
-        if (suspend ?? this._errored) {
-          throw kSuspend
-        } else {
-          return entry.data
-        }
-      }
-
-      return entry.data
-    }
-
-    _getHasRawAssetType(id, type, state, suspend) {
-      if (!id || typeof id !== 'string') {
-        throw new Error(`invalid argument: id (${id})`)
-      }
-
-      if (!type || typeof type !== 'string') {
-        throw new Error(`invalid argument: type (${type})`)
-      }
-
-      const rawTypes = this._getRecord(
-        id + ':asset.rawTypes?',
-        'value',
-        state ?? ds.record.PROVIDER,
-        suspend,
-      )
-      return Array.isArray(rawTypes) && rawTypes.includes(type) ? id : null
-    }
-  }
-
-  return makeWeakCache((expression) => {
-    let script
-    try {
-      script = new Function(
-        transform(`
-        const _ = (value, ...fns) => {
-          if (value == null) {
-            return value
-          }
-
-          for (const fn of fns) {
-            value = fn(value)
-            if (value == null) {
-              return value
-            }
-          }
-
-          return value
-        };
-
-        const fp = globalThis.fp
-        const moment = globalThis.moment
-        const Timecode = globalThis.Timecode
-        const datefns = globalThis.datefns
-        const JSON5 = globalThis.JSON5
-        const $ = globalThis.$
-        const nxt = globalThis.nxt
-
-        _.asset = (type, state, suspend) => (name) => nxt._asset(name, type, state, suspend);
-        _.ds = (postfix, state, suspend) => (name) => nxt._ds(name, postfix, state, suspend);
-        _.get = (postfix, path, state, suspend) => (name) => nxt._get(name, postfix, path, state, suspend);
-        _.timer = (dueTime) => (dueValue) => nxt.timer(dueTime, dueValue);
-        _.fetch = (options, suspend) => (resource) => nxt.fetch(resource, options, suspend);
-        ${expression}
-    `),
-      )
-    } catch (err) {
-      return () =>
-        rxjs.throwError(
-          Object.assign(new Error(`failed to parse expression ${expression}`), { cause: err }),
-        )
-    }
-
-    return (args) =>
-      new rxjs.Observable((o) => {
-        try {
-          const exp = new Expression(script, expression, args, o)
-          return () => {
-            exp._destroy()
-          }
-        } catch (err) {
-          o.error(err)
-        }
-      })
-  })
-}