@nxtedition/lib 26.8.8 → 27.0.0

package/util/template/index-common.js

@@ -1,226 +0,0 @@
-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 firstValueFrom from '../../rxjs/firstValueFrom.js'
-
-export function makeTemplateCompiler({ ds, proxify, logger, platform }) {
-  const compiler = {
-    current: null,
-    resolveTemplate,
-    onResolveTemplate,
-    compileTemplate,
-    isTemplate,
-  }
-
-  const compilers = {
-    nxt: getNxtpressionsCompiler({ ds, logger, platform }),
-    js: getJavascriptCompiler({ ds, proxify, compiler, logger, platform }),
-  }
-
-  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),
-    }
-  }
-
-  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 objCache = new WeakMap()
-
-  const _compileTemplate = (template) => {
-    if (fp.isPlainObject(template)) {
-      let resolver = objCache.get(template)
-      if (resolver == null) {
-        resolver = compileObjectTemplate(template)
-        objCache.set(template, resolver)
-      }
-      return resolver
-    } else if (Array.isArray(template)) {
-      let resolver = objCache.get(template)
-      if (resolver == null) {
-        resolver = compileArrayTemplate(template)
-        objCache.set(template, resolver)
-      }
-      return resolver
-    } else if (isTemplate(template)) {
-      return compileStringTemplate(template)
-    } else {
-      return null
-    }
-  }
-
-  function compileTemplate(template) {
-    const resolver = _compileTemplate(template)
-    return resolver ? (args$) => resolver(template, args$) : null
-  }
-
-  async 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

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

package/util/template/index-web.js

@@ -1,28 +0,0 @@
-import { makeTemplateCompiler as commonMakeTemplateCompiler } from './index-common.js'
-
-export function makeTemplateCompiler({ ds, proxify, logger = console }) {
-  return commonMakeTemplateCompiler({
-    ds,
-    proxify,
-    logger,
-    platform: {
-      hasha: (data) => {
-        throw new Error('hasha 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()
-            },
-          },
-        }
-      },
-      schedule: (fn) => setTimeout(fn, 0),
-    },
-  })
-}

package/util/template/index.d.ts

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

package/util/template/index.js

@@ -1,26 +0,0 @@
-import { makeTemplateCompiler as commonMakeTemplateCompiler } from './index-common.js'
-import { hashSync } from 'hasha'
-import { request } from '@nxtedition/nxt-undici'
-import { doYield } from '../../yield.js'
-
-export * from './index-common.js'
-
-export function makeTemplateCompiler({
-  logger = globalThis.__nxt_lib_app?.logger,
-  dispatcher,
-  platform,
-  ...args
-}) {
-  const defaultOptions = { dispatcher }
-  return commonMakeTemplateCompiler({
-    ...args,
-    logger,
-    platform: {
-      hasha: hashSync,
-      fetch: (resource, options) =>
-        request(resource, options && dispatcher ? { dispatcher, ...options } : defaultOptions),
-      ...platform,
-      schedule: (fn) => doYield(fn),
-    },
-  })
-}

package/util/template/index.test.js

@@ -1,94 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert'
-import { makeTemplateCompiler } from './index.js'
-
-test('javascript', async () => {
-  const compiler = makeTemplateCompiler({
-    ds: {},
-    logger: console,
-  })
-
-  assert.strictEqual(
-    await compiler.resolveTemplate('{{#js _($.foo, foo => foo.toUpperCase()) }}', { foo: 'bar' }),
-    'BAR',
-  )
-})
-
-test('nexpression', async () => {
-  const compiler = makeTemplateCompiler({
-    ds: {},
-    logger: console,
-  })
-
-  assert.strictEqual(await compiler.resolveTemplate('{{ foo }}', { foo: 'bar' }), 'bar')
-})
-
-test('pipe short-circuit', async () => {
-  const compiler = makeTemplateCompiler({
-    ds: {},
-    logger: console,
-  })
-
-  assert.strictEqual(
-    await compiler.resolveTemplate('{{#js _($.id, x => x + "ASD") }}', { foo: 'bar' }),
-    undefined,
-  )
-})
-
-test('return function', async () => {
-  const compiler = makeTemplateCompiler({
-    ds: {},
-    logger: console,
-  })
-
-  assert.strictEqual(
-    (
-      await compiler.resolveTemplate(`{{#js (input) => fp.toUpper($.foo + input) }}`, {
-        foo: 'bar',
-      })
-    )('baz'),
-    'BARBAZ',
-  )
-})
-
-test('noop', async (t) => {
-  const { resolveTemplate } = makeTemplateCompiler({})
-  const x = { foo: 1, bar: {} }
-  const y = await resolveTemplate(x)
-  assert.strictEqual(x, y)
-})
-
-test('simple', async (t) => {
-  const { resolveTemplate } = makeTemplateCompiler({})
-  const x = { bar: '{{#js $.test }}' }
-  const y = await resolveTemplate(x, { test: 1 })
-  assert.deepStrictEqual(y, { bar: 1 })
-})
-
-// test('cache', async (t) => {
-//   const x = '{{#js $.test }}'
-//   t.equal(compileTemplate(x), compileTemplate(x))
-//   t.end()
-// })
-
-test('string concat', async (t) => {
-  const { resolveTemplate } = makeTemplateCompiler({})
-  const x = '{{#js $.pre }} {{#js $.body}} {{#js $.post}}'
-  assert.strictEqual(
-    await resolveTemplate(x, { pre: 'pre', body: 'body', post: 'post' }),
-    'pre body post',
-  )
-})
-
-test('syntax error', async (t) => {
-  const { resolveTemplate } = makeTemplateCompiler({})
-  const x = '{{#js $.test + }}'
-  await assert.rejects(
-    async () => {
-      await resolveTemplate(x, { test: 1 })
-    },
-    {
-      name: 'Error',
-    },
-  )
-})