@nxtedition/lib 26.8.7 → 27.0.0-alpha.0

package/util/template/nextpressions.test.js

@@ -1,165 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert'
-import { makeTemplateCompiler } from './index.js'
-import * as rxjs from 'rxjs'
-
-const { resolveTemplate } = makeTemplateCompiler({
-  ds: {
-    record: {
-      observe: () => rxjs.of({ foo: 'bar' }),
-    },
-  },
-})
-
-test('hash to int', async () => {
-  const val = await resolveTemplate('{{test | hashaint() | mod(128)}}', { test: { foo: '11d1' } })
-  assert.strictEqual(Number.isFinite(val), true)
-})
-
-test('baseValue', async () => {
-  assert.strictEqual(await resolveTemplate('{{test}}', { test: '11d1' }), '11d1')
-  assert.strictEqual(await resolveTemplate('{{test}}', { test: rxjs.of('11d1') }), '11d1')
-  assert.strictEqual(
-    await resolveTemplate('{{test.asd}}', { test: rxjs.of({ asd: '11d1' }) }),
-    '11d1',
-  )
-  assert.strictEqual(
-    await resolveTemplate('{{test.asd}}', { test: { asd: rxjs.of('11d1') } }),
-    '11d1',
-  )
-})
-
-test('integer ops', async () => {
-  assert.strictEqual(await resolveTemplate('{{test | div(2)}}', { test: '8' }), 4)
-  assert.strictEqual(await resolveTemplate('{{test | div(2)}}', { test: 8 }), 4)
-  assert.strictEqual(await resolveTemplate('{{test | mul(2)}}', { test: '8' }), 16)
-  assert.strictEqual(await resolveTemplate('{{test | mul(2)}}', { test: 8 }), 16)
-  assert.strictEqual(await resolveTemplate('{{test | add(2)}}', { test: '10' }), 12)
-  assert.strictEqual(await resolveTemplate('{{test | add(2)}}', { test: 10 }), 12)
-  assert.strictEqual(await resolveTemplate('{{test | sub(2)}}', { test: '10' }), 8)
-  assert.strictEqual(await resolveTemplate('{{test | sub(2)}}', { test: 10 }), 8)
-})
-
-test('null undefined args', async () => {
-  assert.strictEqual(await resolveTemplate('{{asd | default(null, true)}}', {}), null)
-  assert.strictEqual(await resolveTemplate('{{asd | default(undefined, true)}}', {}), undefined)
-})
-
-test('path var', async () => {
-  assert.strictEqual(await resolveTemplate('{{test.foo}}', { test: { foo: '111' } }), '111')
-})
-
-test('replaces strings', async () => {
-  assert.strictEqual(await resolveTemplate('{{test}}', { test: '111' }), '111')
-  assert.strictEqual(await resolveTemplate('pre{{test}}post', { test: '111' }), 'pre111post')
-  assert.strictEqual(
-    await resolveTemplate('123{{test}}456{{test}}{{test}}', { test: 'body' }),
-    '123body456bodybody',
-  )
-  assert.strictEqual(
-    await resolveTemplate('test{{test.foo}}test{{test.bar.baz}}test', {
-      test: { foo: '111', bar: { baz: '222' } },
-    }),
-    'test111test222test',
-  )
-  assert.strictEqual(await resolveTemplate('{{ asd | default("te | st")}}', {}), 'te | st')
-  assert.strictEqual(await resolveTemplate('{{ asd | default("test\n") }}', {}), 'test\n')
-  assert.strictEqual(await resolveTemplate('{{ asd | default("test\n\n") }}', {}), 'test\n\n')
-  assert.strictEqual(await resolveTemplate('{{ asd | default("test\r\n") }}', {}), 'test\r\n')
-})
-
-test('nested', async () => {
-  assert.strictEqual(
-    await resolveTemplate('{{ asd | default("{{foo}}") }}', { foo: '"test"' }),
-    '"test"',
-  )
-  assert.strictEqual(await resolveTemplate('{{{{foo}}}}', { test: '111', foo: 'test' }), '111')
-  assert.strictEqual(
-    await resolveTemplate('f{{oo}}', { test: '111', foo: 'test', oo: 'oo' }),
-    'foo',
-  )
-  assert.strictEqual(
-    await resolveTemplate('{{f{{oo}}}}', { test: '111', foo: 'test', oo: 'oo' }),
-    'test',
-  )
-  assert.strictEqual(await resolveTemplate('{{{{foo}}}}', { test: '111', foo: 'test' }), '111')
-  assert.strictEqual(
-    await resolveTemplate('{{{{f{{o}}o}}}}', { test: '111', foo: 'test', o: 'o' }),
-    '111',
-  )
-  assert.strictEqual(
-    await resolveTemplate('{{ asd | default("{{test}}")}}', { test: '111', foo: 'test' }),
-    '111',
-  )
-  assert.strictEqual(
-    await resolveTemplate('{{ asd | default("{{t{{es}}t}}")}}', {
-      test: '111',
-      foo: 'test',
-      es: 'es',
-    }),
-    '111',
-  )
-  assert.strictEqual(
-    await resolveTemplate('{{ asd | default("{{test | default("test\n")}}")}}', {}),
-    'test\n',
-  )
-  assert.strictEqual(
-    await resolveTemplate('{{ asd | default("{{test | default("test\n\n")}}")}}', {}),
-    'test\n\n',
-  )
-  assert.strictEqual(
-    await resolveTemplate('{{ asd | default("{{test | default("test\r\n")}}")}}', {}),
-    'test\r\n',
-  )
-})
-
-test('append', async () => {
-  assert.strictEqual(await resolveTemplate("{{test | append('1')}}", { test: '111' }), '1111')
-})
-
-test('object', async () => {
-  const obj = { foo: 1 }
-  assert.strictEqual(await resolveTemplate('{{test}}', { test: obj }), obj)
-})
-
-test('ds', async () => {
-  assert.strictEqual(
-    await resolveTemplate("{{test | ds() | pluck('foo')}}", { test: 'foo' }),
-    'bar',
-  )
-})
-
-test('replace array', async () => {
-  assert.deepStrictEqual(
-    await resolveTemplate('{{test | join("#") | replace("foo", "bar") | split("#")}}', {
-      test: ['foo', 'bar'],
-    }),
-    ['bar', 'bar'],
-  )
-  assert.deepStrictEqual(
-    await resolveTemplate('{{test | join(",") | replace("foo", "bar") | split(",")}}', {
-      test: ['foo', 'bar'],
-    }),
-    ['bar', 'bar'],
-  )
-})
-
-test('You Do Not Know Me', async () => {
-  assert.deepStrictEqual(
-    await resolveTemplate('{{id | default("You Do Not Know", true)}} -', {}),
-    'You Do Not Know -',
-  )
-})
-
-test('object 1', async () => {
-  assert.deepStrictEqual(await resolveTemplate({ asd: ['{{foo}}'] }, { foo: 'bar' }), {
-    asd: ['bar'],
-  })
-})
-
-test('empty arg', async () => {
-  assert.deepStrictEqual(
-    await resolveTemplate('{{source.value | includes("salami") | ternary([], )}}', {}),
-    undefined,
-  )
-})

package/util/template/transform.js

@@ -1,22 +0,0 @@
-import { parse } from 'acorn'
-import { generate } from 'astring'
-
-export default function (code) {
-  const ast = parse(code, { ecmaVersion: 'latest' })
-
-  const { body } = ast
-
-  if (body.length > 0) {
-    const lastStatement = body[body.length - 1]
-
-    if (lastStatement.type !== 'ReturnStatement') {
-      body[body.length - 1] = {
-        type: 'ReturnStatement',
-        argument:
-          lastStatement.type === 'ExpressionStatement' ? lastStatement.expression : lastStatement,
-      }
-    }
-  }
-
-  return generate(ast)
-}

package/util/template/transform.test.js

@@ -1,16 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert'
-import transform from './transform.js'
-
-test('transform', function () {
-  assert.strictEqual(transform('const x = 2; x;'), 'const x = 2;\nreturn x;\n')
-  assert.strictEqual(transform('[1,2,3];'), 'return [1, 2, 3];\n')
-  assert.strictEqual(transform('[1,2,3]'), 'return [1, 2, 3];\n')
-  assert.strictEqual(transform('x\n? \n2 \n: \n3'), `return x ? 2 : 3;\n`)
-  // assert.strictEqual(transform('return x\n? \n2 \n: \n3'), `return x ? 2 : 3;\n`)
-  // assert.strictEqual(transform('return\n x\n? \n2 \n: \n3'), `return x ? 2 : 3;\n`)
-  assert.strictEqual(
-    transform('$.width > $.height ? 30 : 20'),
-    `return $.width > $.height ? 30 : 20;\n`,
-  )
-})

package/weakCache.d.ts

@@ -1,4 +0,0 @@
-export function makeWeakCache<FactoryArgs extends unknown[], CachedType>(
-  valueSelector: (...args: FactoryArgs) => CachedType,
-  keySelector?: (...args: FactoryArgs) => string,
-): (...args: FactoryArgs) => CachedType

package/weakCache.js

@@ -1,25 +0,0 @@
-export function makeWeakCache(valueSelector, keySelector) {
-  const cache = new Map()
-  const finalizationRegistry = new FinalizationRegistry((key) => {
-    const ref = cache.get(key)
-    if (ref !== undefined && ref.deref() === undefined) {
-      cache.delete(key)
-    }
-  })
-  return (...args) => {
-    const key = keySelector ? keySelector(...args) : args[0]
-    const ref = cache.get(key)
-    if (ref != null) {
-      const deref = ref.deref()
-      if (deref != null) {
-        return deref
-      }
-    }
-    const value = valueSelector(...args)
-    if (value != null) {
-      cache.set(key, new WeakRef(value))
-      finalizationRegistry.register(value, key)
-    }
-    return value
-  }
-}

package/yield.js

@@ -1,103 +0,0 @@
-const kDefaultSchedule = globalThis.setImmediate ?? ((fn) => setTimeout(fn, 0))
-let yieldSchedule = kDefaultSchedule
-const yieldQueue = []
-
-let yieldIndex = 0
-let yieldTimeout = 40
-let yieldActive = false
-let yieldScheduled = false
-let yieldTime = performance.now()
-
-export function setYieldDispatcher(schedule) {
-  yieldSchedule = schedule ?? kDefaultSchedule
-}
-
-export function setYieldTimeout(timeout) {
-  if (typeof timeout !== 'number' || timeout < 0) {
-    throw new TypeError('timeout must be a positive number')
-  }
-  yieldTimeout = timeout
-}
-
-export function shouldYield(timeout) {
-  if (timeout === undefined) {
-    timeout = yieldTimeout
-  }
-
-  if (!yieldActive && performance.now() - yieldTime >= timeout) {
-    yieldActive = true
-  }
-
-  return yieldActive
-}
-
-export function maybeYield(callback, opaque, timeout) {
-  if (callback != null && typeof callback !== 'function') {
-    throw new TypeError('callback must be a function')
-  }
-
-  if (shouldYield(timeout)) {
-    return doYield(callback, opaque)
-  }
-
-  if (callback != null) {
-    callback(null, opaque)
-  }
-
-  return null
-}
-
-export function doYield(callback, opaque) {
-  if (callback != null && typeof callback !== 'function') {
-    throw new TypeError('callback must be a function')
-  }
-
-  if (!yieldScheduled) {
-    yieldScheduled = true
-    yieldSchedule(dispatchYield)
-  }
-
-  if (callback != null) {
-    yieldQueue.push(callback, opaque)
-    return null
-  }
-
-  return new Promise((resolve) => {
-    yieldQueue.push(resolve, opaque)
-  })
-}
-
-function dispatchYield() {
-  yieldTime = performance.now()
-  yieldActive = false
-
-  const maxIndex = yieldQueue.length
-
-  while (yieldIndex < maxIndex) {
-    const resolve = yieldQueue[yieldIndex]
-    yieldQueue[yieldIndex] = null
-    yieldIndex += 1
-
-    const opaque = yieldQueue[yieldIndex]
-    yieldQueue[yieldIndex] = null
-    yieldIndex += 1
-
-    resolve(opaque)
-
-    if (shouldYield()) {
-      break
-    }
-  }
-
-  if (yieldIndex === yieldQueue.length) {
-    yieldScheduled = false
-    yieldQueue.splice(0)
-    yieldIndex = 0
-  } else {
-    if (yieldIndex > 16 * 1024) {
-      yieldQueue.splice(0, yieldIndex)
-      yieldIndex = 0
-    }
-    yieldSchedule(dispatchYield)
-  }
-}