refactor(core): CORE-01 migrate utility contracts to TypeScript

test/utils.test.js

@@ -0,0 +1,144 @@
+import assert from 'node:assert/strict'
+import process from 'node:process'
+// eslint-disable-next-line test/no-import-node-test -- Control actual timers without wall-clock sleeps.
+import { test } from 'node:test'
+import { loadCoreArtifact, loadPackage, loadPublishedCore } from './helpers/load.js'
+
+const globals = { setTimeout: (...args) => setTimeout(...args), clearTimeout: timer => clearTimeout(timer) }
+const published = await loadPublishedCore(globals)
+const current = { name: 'workspace', Artplayer: (await loadPackage('artplayer')).default }
+const targets = [published, current]
+if (process.env.ARTPLAYER_TEST_CORE)
+  targets.push(await loadCoreArtifact(process.env.ARTPLAYER_TEST_CORE, globals))
+
+for (const { name, Artplayer } of targets) {
+  const utils = Artplayer.utils
+  test(`utils formatting and extension conventions: ${name}`, () => {
+    assert.deepEqual([utils.clamp(4, 5, 1), utils.clamp(-2, 5, 1), utils.clamp(9, 5, 1)], [4, 1, 5])
+    assert(Number.isNaN(utils.clamp(Number.NaN, 0, 1)))
+    for (const [value, result] of [[0, '00:00'], [59.9, '00:59'], [60, '01:00'], [3601, '01:00:01'], [360000, '100:00:00']])
+      assert.equal(utils.secondToTime(value), result)
+    const text = `<b title="A&B">'Text'</b>`
+    assert.equal(utils.escape(text), '&lt;b title=&quot;A&amp;B&quot;&gt;&#39;Text&#39;&lt;/b&gt;')
+    assert.equal(utils.unescape(utils.escape(text)), text)
+    assert.equal(utils.unescape('&amp;lt; &#x3c;'), '&lt; &#x3c;')
+    assert.equal(utils.capitalize('hello'), 'Hello')
+    for (const [url, result] of [[' clip.MP4?token=a.b#hash ', 'mp4'], ['clip.webm#x?y=z', 'webm'], [' video ', 'video'], ['', '']])
+      assert.equal(utils.getExt(url), result)
+  })
+
+  test(`utils property descriptors and deep merge array/reference behavior: ${name}`, () => {
+    const key = Symbol('key')
+    const object = Object.create({ inherited: true })
+    assert.equal(utils.def(object, key, { value: 42 }), object)
+    assert.equal(utils.has(object, key), true)
+    assert.equal(utils.has(object, 'inherited'), false)
+    assert.equal(utils.get(object, 'missing'), undefined)
+    assert.deepEqual({ ...utils.get(object, key) }, { value: 42, writable: false, enumerable: false, configurable: false })
+    const first = { nested: { x: 1 }, array: [1] }
+    const array = [2, [3, 4]]
+    const result = utils.mergeDeep(first, { nested: { y: 2 }, array })
+    assert.equal(JSON.stringify(result), '{"nested":{"x":1,"y":2},"array":[1,2,3,4]}')
+    assert.equal(first.array.length, 1)
+    assert.equal(utils.mergeDeep({ array }).array, array)
+    assert.equal(utils.has(utils.mergeDeep(), 'toString'), false)
+  })
+
+  test(`utils subtitle text output: ${name}`, () => {
+    const srt = '1\n00:00:01,2 --> 00:00:02.3456\n{i}Hello{/i} {unknown}\n'
+    assert.equal(utils.srtToVtt(srt), 'WEBVTT \r\n\r\n1\n00:00:01.200 --> 00:00:02.345\n<i>Hello</i> \n\r\n\r\n')
+    const ass = '[Events]\nDialogue: 0,0:00:01.20,0:00:02.34,Default,,0,0,0,,{\\i1} Hello\\N World\n'
+    assert.equal(utils.assToVtt(ass), 'WEBVTT\n\n1\n00:00:01.200 --> 00:00:02.340\nHello\nWorld')
+    assert.equal(utils.assToVtt('[Script Info]\nno dialogue'), 'WEBVTT\n\n')
+  })
+
+  test(`utils errors retain identity and truthy return values: ${name}`, () => {
+    const object = {}
+    assert.equal(utils.errorHandle(object, 'unused'), object)
+    assert.equal(utils.errorHandle('supported', 'unused'), 'supported')
+    for (const condition of [false, 0, '', null, undefined]) {
+      assert.throws(() => utils.errorHandle(condition, 'Failure'), error => error instanceof utils.ArtPlayerError && error.name === 'ArtPlayerError' && error.message === 'Failure')
+    }
+  })
+
+  test(`utils timer arguments, receivers and leading/trailing behavior: ${name}`, async (context) => {
+    context.mock.timers.enable({ apis: ['setTimeout'] })
+    let slept = false
+    const pending = utils.sleep(10).then(() => slept = true)
+    context.mock.timers.tick(9)
+    await Promise.resolve()
+    assert.equal(slept, false)
+    context.mock.timers.tick(1)
+    await pending
+    const calls = []
+    function receive(value) {
+      calls.push([this.id, value])
+      return 42
+    }
+    const trailing = utils.debounce(receive, 10)
+    assert.equal(trailing.call({ id: 'first' }, 1), undefined)
+    context.mock.timers.tick(5)
+    trailing.call({ id: 'last' }, 2)
+    context.mock.timers.tick(9)
+    assert.deepEqual(calls, [])
+    context.mock.timers.tick(1)
+    assert.deepEqual(calls, [['last', 2]])
+    const leading = utils.throttle(receive, 10)
+    assert.equal(leading.call({ id: 'leading' }, 3), undefined)
+    leading.call({ id: 'ignored' }, 4)
+    context.mock.timers.tick(10)
+    assert.deepEqual(calls, [['last', 2], ['leading', 3]])
+    leading.call({ id: 'later' }, 5)
+    assert.deepEqual(calls, [['last', 2], ['leading', 3], ['later', 5]])
+  })
+}
+
+test('utils export surface preserves the published namespace plus existing workspace additions', () => {
+  const expected = [...Object.keys(published.Artplayer.utils), 'silencePromise', 'getSafeAreaInsets'].sort()
+  for (const { Artplayer } of targets.slice(1)) {
+    assert.deepEqual(Object.keys(Artplayer.utils).sort(), expected)
+    for (const key of Object.keys(published.Artplayer.utils)) {
+      assert.equal(typeof Artplayer.utils[key], typeof published.Artplayer.utils[key], key)
+      if (typeof Artplayer.utils[key] === 'function')
+        assert.equal(Artplayer.utils[key].length, published.Artplayer.utils[key].length, key)
+    }
+  }
+})
+
+test('mergeDeep keeps __proto__ as own data without replacing result prototypes', () => {
+  const input = JSON.parse('{"__proto__":{"unexpected":true},"constructor":{"prototype":{"marker":true}}}')
+  const old = published.Artplayer.utils.mergeDeep({}, input)
+  assert.equal(Object.prototype.hasOwnProperty.call(old, '__proto__'), false)
+  assert.equal(old.unexpected, true, 'Published defect remains demonstrable')
+  for (const { Artplayer } of targets.slice(1)) {
+    const result = Artplayer.utils.mergeDeep({}, input)
+    assert.equal(Object.prototype.hasOwnProperty.call(result, '__proto__'), true)
+    assert.equal(result.unexpected, undefined)
+    assert.equal(Object.getPrototypeOf(result).unexpected, undefined)
+    assert.equal(Object.getOwnPropertyDescriptor(result, '__proto__').value.unexpected, true)
+    const nested = Artplayer.utils.mergeDeep({ nested: {} }, { nested: input })
+    assert.equal(nested.nested.unexpected, undefined)
+    assert.equal(Object.prototype.hasOwnProperty.call(nested.nested, '__proto__'), true)
+    assert.equal({}.unexpected, undefined)
+    assert.equal(JSON.stringify(input), '{"__proto__":{"unexpected":true},"constructor":{"prototype":{"marker":true}}}')
+  }
+})
+
+test('throttle preserves synchronous reentry and retries after callback failure', (context) => {
+  context.mock.timers.enable({ apis: ['setTimeout'] })
+  for (const { Artplayer } of targets) {
+    let calls = 0
+    const invoke = Artplayer.utils.throttle(() => {
+      calls++
+      if (calls === 1)
+        invoke()
+    }, 10)
+    invoke()
+    assert.equal(calls, 2)
+    const broken = Artplayer.utils.throttle(() => {
+      throw new Error('callback failure')
+    }, 10)
+    assert.throws(broken, /callback failure/)
+    assert.throws(broken, /callback failure/)
+  }
+})