refactor(core): CORE-18 type builtins and own prompt lifetimes

test/browser/notice.spec.js

@@ -0,0 +1,168 @@
+import { expect, test } from './fixtures.js'
+
+async function setup(page, core) {
+  await page.goto(`/test/player.html?core=${core}&chapter=published`)
+  await page.evaluate(() => window.createPlayer('/test/pattern.mp4'))
+  await expect.poll(() => page.evaluate(() => window.art.isReady)).toBe(true)
+  await page.evaluate(() => {
+    window.Artplayer.NOTICE_TIME = 24733
+    window.art.notice.destroy()
+  })
+}
+
+for (const core of ['published', 'candidate']) {
+  test(`${core}: notice updates do not call a consumer override of destroy`, async ({ page }) => {
+    await setup(page, core)
+    expect(await page.evaluate(() => {
+      const notice = window.art.notice
+      const original = notice.destroy
+      let calls = 0
+      notice.destroy = function () {
+        calls++
+        return original.call(this)
+      }
+      notice.show = 'first'
+      notice.show = 'second'
+      const implicit = calls
+      notice.destroy()
+      const explicit = calls
+      window.art.destroy()
+      return { implicit, explicit }
+    })).toEqual({ implicit: 0, explicit: 1 })
+  })
+
+  test(`${core}: notice preserves public shape, Error text and false hide semantics`, async ({ page }) => {
+    await setup(page, core)
+    expect(await page.evaluate(() => {
+      const art = window.art
+      const notice = art.notice
+      notice.show = new Error('  trimmed  ')
+      const visible = notice.show
+      const text = art.template.$noticeInner.textContent
+      const timer = notice.timer
+      notice.show = false
+      const result = {
+        fields: Object.keys(notice),
+        prototype: Object.getOwnPropertyNames(Object.getPrototypeOf(notice)),
+        visible,
+        text,
+        hidden: !notice.show,
+        retained: art.template.$noticeInner.textContent,
+        sameTimer: timer === notice.timer,
+      }
+      notice.destroy()
+      art.destroy()
+      return result
+    })).toEqual({ fields: ['art', 'timer'], prototype: ['constructor', 'destroy', 'show'], visible: true, text: 'trimmed', hidden: true, retained: 'trimmed', sameTimer: true })
+  })
+
+  test(`${core}: notice expires naturally during real playback`, async ({ page }) => {
+    await setup(page, core)
+    await page.evaluate(() => window.art.play())
+    await expect.poll(() => page.evaluate(() => window.art.currentTime)).toBeGreaterThan(0.1)
+    await page.evaluate(() => {
+      window.Artplayer.NOTICE_TIME = 20
+      window.art.notice.show = 'transient'
+    })
+    await expect.poll(() => page.evaluate(() => ({ visible: window.art.notice.show, text: window.art.template.$noticeInner.textContent }))).toEqual({ visible: false, text: '' })
+    expect(await page.evaluate(() => window.art.playing)).toBe(true)
+    await page.evaluate(() => window.art.destroy())
+  })
+
+  test(`${core}: manual notice destroy permits reuse and does not hide its DOM`, async ({ page }) => {
+    await setup(page, core)
+    expect(await page.evaluate(() => {
+      const notice = window.art.notice
+      notice.show = 'visible'
+      notice.destroy()
+      const visible = notice.show
+      const timer = notice.timer
+      notice.show = 'reused'
+      const reused = window.art.template.$noticeInner.textContent
+      notice.destroy()
+      window.art.destroy()
+      return { visible, timer, reused }
+    })).toEqual({ visible: true, timer: null, reused: 'reused' })
+  })
+
+  test(`${core}: destruction during notice text assignment cannot schedule a late timer`, async ({ page }) => {
+    await setup(page, core)
+    expect(await page.evaluate(() => {
+      const art = window.art
+      const notice = art.notice
+      const inner = art.template.$noticeInner
+      const descriptor = Object.getOwnPropertyDescriptor(Node.prototype, 'textContent')
+      Object.defineProperty(inner, 'textContent', {
+        configurable: true,
+        get() {
+          return descriptor.get.call(this)
+        },
+        set(value) {
+          descriptor.set.call(this, value)
+          art.destroy(false)
+        },
+      })
+      notice.show = 'destroy during write'
+      const result = { destroyed: art.isDestroy, timer: notice.timer !== null, visible: notice.show }
+      notice.destroy()
+      return result
+    })).toEqual({ destroyed: true, timer: core === 'published', visible: core === 'published' })
+  })
+
+  test(`${core}: expiry does not hide a notice installed during the clearing write`, async ({ page }) => {
+    await setup(page, core)
+    expect(await page.evaluate(() => {
+      const art = window.art
+      const inner = art.template.$noticeInner
+      const descriptor = Object.getOwnPropertyDescriptor(Node.prototype, 'textContent')
+      const original = window.setTimeout
+      let expire
+      window.setTimeout = function (callback, delay, ...args) {
+        if (delay === 24733)
+          expire = callback
+        return original.call(this, callback, delay, ...args)
+      }
+      art.notice.show = 'old'
+      Object.defineProperty(inner, 'textContent', {
+        configurable: true,
+        get() {
+          return descriptor.get.call(this)
+        },
+        set(value) {
+          descriptor.set.call(this, value)
+          if (value === '')
+            art.notice.show = 'nested'
+        },
+      })
+      expire()
+      const result = { text: inner.textContent, visible: art.notice.show }
+      window.setTimeout = original
+      art.notice.destroy()
+      art.destroy()
+      return result
+    })).toEqual({ text: 'nested', visible: core === 'candidate' })
+  })
+}
+
+test('candidate: retained callbacks and assignments cannot revive destroyed notice resources', async ({ page }) => {
+  await setup(page, 'candidate')
+  expect(await page.evaluate(() => {
+    const art = window.art
+    const original = window.setTimeout
+    const callbacks = []
+    window.setTimeout = function (callback, delay, ...args) {
+      if (delay === 24733)
+        callbacks.push(callback)
+      return original.call(this, callback, delay, ...args)
+    }
+    art.notice.show = 'old'
+    art.notice.show = 'new'
+    callbacks[0]()
+    const before = art.template.$noticeInner.textContent
+    art.destroy(false)
+    callbacks[1]()
+    art.notice.show = 'ignored'
+    window.setTimeout = original
+    return { before, after: art.template.$noticeInner.textContent, timer: art.notice.timer, calls: callbacks.length }
+  })).toEqual({ before: 'new', after: 'new', timer: null, calls: 2 })
+})