@teleporthq/teleport-plugin-next-workflows 0.43.69 → 0.43.71

package/__tests__/chapter-reached-trigger.test.ts

@@ -0,0 +1,141 @@
+// `event-chapter-reached` is a LIFECYCLE trigger bound to ONE element (a
+// scroll-scene chapter): it listens for the `tq-chapter-reached` event the
+// published TqScrollScene dispatches on the chapter, so it follows the same
+// rules as element-visible — DOM id lookup, and pruned from every page whose
+// JSX does not render the chapter.
+
+import { createNextWorkflowPlugin } from '../src/workflow-component-plugin'
+
+const HTML_ID = 'thq_chapter_pricing'
+const NODE_ID = 'TQ__chapterPricing'
+
+const chapterWorkflow = (config: Record<string, unknown>) => ({
+  id: 'wf-chapter-pricing',
+  name: 'Load pricing on chapter',
+  trigger: {
+    type: 'event-chapter-reached',
+    nodeId: 'trigger-chapter',
+    scope: 'element',
+    config,
+  },
+  nodes: [
+    {
+      id: 'update-1',
+      type: 'state-update-local-state',
+      config: { property: 'pricingLoaded', value: true },
+      stepNumber: 1,
+      label: 'Mark loaded',
+    },
+  ],
+  edges: [{ id: 'e1', source: 'trigger-chapter', target: 'update-1' }],
+})
+
+const jsxWithElementId = (elementId: string | null) => ({
+  type: 'chunk-type-ast',
+  name: 'jsx-component',
+  content: {
+    type: 'VariableDeclaration',
+    declarations: [
+      {
+        type: 'VariableDeclarator',
+        init: {
+          type: 'ArrowFunctionExpression',
+          body: {
+            type: 'BlockStatement',
+            body: [
+              {
+                type: 'ReturnStatement',
+                argument: {
+                  type: 'JSXElement',
+                  openingElement: {
+                    type: 'JSXOpeningElement',
+                    name: { type: 'JSXIdentifier', name: 'div' },
+                    attributes: elementId
+                      ? [
+                          {
+                            type: 'JSXAttribute',
+                            name: { type: 'JSXIdentifier', name: 'id' },
+                            value: { type: 'StringLiteral', value: elementId },
+                          },
+                        ]
+                      : [],
+                  },
+                  children: [],
+                },
+              },
+            ],
+          },
+        },
+      },
+    ],
+  },
+})
+
+const getWorkflowModule = async (
+  workflow: any,
+  renderedElementId: string | null
+): Promise<string | null> => {
+  const plugin = createNextWorkflowPlugin({ isPage: true })
+  const structure: any = {
+    uidl: {
+      name: 'Story',
+      node: { type: 'element', content: { elementType: 'container', name: 'Container' } },
+      stateDefinitions: { pricingLoaded: { type: 'boolean', defaultValue: false } },
+    },
+    chunks: [jsxWithElementId(renderedElementId)],
+    options: { workflows: { workflows: { [workflow.id]: workflow }, customNodes: {} } },
+    dependencies: {},
+  }
+  await plugin(structure)
+  const moduleChunk = (structure.chunks as any[]).find((c: any) => c.name === 'workflow-module')
+  return moduleChunk ? String(moduleChunk.content) : null
+}
+
+describe('event-chapter-reached — generated listener', () => {
+  const module = (config: Record<string, unknown>, rendered: string | null = HTML_ID) =>
+    getWorkflowModule(chapterWorkflow(config), rendered)
+
+  it('listens on the chapter DOM id for the scene announcement', async () => {
+    const code = await module({ nodeId: NODE_ID, elementHtmlId: HTML_ID })
+    expect(code).not.toBeNull()
+    expect(code).toContain(`document.getElementById('${HTML_ID}')`)
+    expect(code).toContain("addEventListener('tq-chapter-reached'")
+    expect(code).toContain(`elementId: '${HTML_ID}'`)
+    expect(code).toContain('chapterIndex: detail.chapterIndex')
+    expect(code).not.toContain(NODE_ID)
+  })
+
+  it('listens on the chapter root and ignores announcements bubbling from a nested scene', async () => {
+    const code = await module({ nodeId: NODE_ID, elementHtmlId: HTML_ID })
+    expect(code).toContain(".closest('[data-scene-stage] > *, [data-scene-track] > *')")
+    expect(code).toMatch(/if \(event\.target !== __chRoot_\w+\) \{ return; \}/)
+  })
+
+  it('fires once by default and detaches after the first announcement', async () => {
+    const code = await module({ nodeId: NODE_ID, elementHtmlId: HTML_ID })
+    expect(code).toMatch(
+      /__chRoot_\w+\.removeEventListener\('tq-chapter-reached', __chH_\w+\);\n\s+__chFire_/
+    )
+    expect(code).toMatch(/if \(!__chStamp_\w+\) \{/)
+  })
+
+  it('keeps listening when the author asked for every time', async () => {
+    const code = await module({ nodeId: NODE_ID, elementHtmlId: HTML_ID, once: false })
+    expect(code).not.toMatch(
+      /__chRoot_\w+\.removeEventListener\('tq-chapter-reached', __chH_\w+\);\n\s+__chFire_/
+    )
+    expect(code).not.toMatch(/if \(!__chStamp_\w+\) \{/)
+    expect(code).toContain("addEventListener('tq-chapter-reached'")
+  })
+
+  it('reads the stamped chapter and count when it attaches after the announcement', async () => {
+    const code = await module({ nodeId: NODE_ID, elementHtmlId: HTML_ID })
+    expect(code).toContain("getAttribute('data-chapter-active')")
+    expect(code).toContain("getAttribute('data-chapter-count')")
+  })
+
+  it('is pruned from a page that does not render the chapter', async () => {
+    const code = await module({ nodeId: NODE_ID, elementHtmlId: HTML_ID }, 'some_other_element')
+    expect(code === null || !code.includes('tq-chapter-reached')).toBe(true)
+  })
+})

package/__tests__/element-video-control.test.ts

@@ -0,0 +1,102 @@
+// "Control a Video" runs in the browser against the bound Video element. The
+// generated handler is exercised here on a stubbed DOM: every action, the
+// container-holding-a-video case, and the muted retry when the browser
+// blocks a play with sound.
+
+import { nodeRegistry } from '../src'
+import { resolveHandlerEntryName } from '../src/nodes/types'
+
+type Handler = (config: Record<string, unknown>, context: Record<string, unknown>) => Promise<any>
+
+const loadHandler = (): Handler => {
+  const source = nodeRegistry['element-video-control'].generateHandler()
+  const entry = resolveHandlerEntryName(source, 'element-video-control')
+  // eslint-disable-next-line no-new-func
+  return new Function(`${source}\nreturn ${entry};`)() as Handler
+}
+
+const fakeVideo = (options: { blockSound?: boolean } = {}) => {
+  const video: any = {
+    tagName: 'VIDEO',
+    paused: true,
+    ended: false,
+    muted: false,
+    currentTime: 12,
+    playCalls: 0,
+    play() {
+      this.playCalls += 1
+      if (options.blockSound && !this.muted) {
+        return Promise.reject(new Error('NotAllowedError'))
+      }
+      this.paused = false
+      return Promise.resolve()
+    },
+    pause() {
+      this.paused = true
+    },
+  }
+  return video
+}
+
+const withDom = (byId: Record<string, any>) => {
+  ;(globalThis as any).document = {
+    getElementById: (id: string) => byId[id] || null,
+  }
+}
+
+describe('element-video-control — generated handler', () => {
+  afterEach(() => {
+    delete (globalThis as any).document
+  })
+
+  it('registers as a client-side element node', () => {
+    expect(nodeRegistry['element-video-control'].executionEnv).toBe('client')
+    expect(nodeRegistry['element-video-control'].generateHandler()).not.toContain('`')
+  })
+
+  it('plays by default and reports the state', async () => {
+    const video = fakeVideo()
+    withDom({ hero: video })
+    const result = await loadHandler()({ nodeId: 'hero' }, {})
+    expect(result).toMatchObject({ success: true, action: 'play', playing: true, currentTime: 12 })
+    expect(video.playCalls).toBe(1)
+  })
+
+  it('finds the video inside a bound container and resolves the html id fallback', async () => {
+    const video = fakeVideo()
+    const container = { tagName: 'DIV', querySelector: () => video }
+    withDom({ thq_hero: container })
+    const result = await loadHandler()(
+      { nodeId: 'TQ_hero', elementHtmlId: 'thq_hero', action: 'pause' },
+      {}
+    )
+    expect(result).toMatchObject({ success: true, action: 'pause', playing: false })
+  })
+
+  it('pauses, toggles, restarts, mutes and unmutes', async () => {
+    const video = fakeVideo()
+    video.paused = false
+    withDom({ v: video })
+    const handler = loadHandler()
+    expect((await handler({ nodeId: 'v', action: 'toggle' }, {})).playing).toBe(false)
+    expect((await handler({ nodeId: 'v', action: 'toggle' }, {})).playing).toBe(true)
+    const restarted = await handler({ nodeId: 'v', action: 'restart' }, {})
+    expect(restarted).toMatchObject({ playing: true, currentTime: 0 })
+    expect((await handler({ nodeId: 'v', action: 'mute' }, {})).muted).toBe(true)
+    expect((await handler({ nodeId: 'v', action: 'unmute' }, {})).muted).toBe(false)
+  })
+
+  it('retries muted when the browser blocks a play with sound, and says so', async () => {
+    const video = fakeVideo({ blockSound: true })
+    withDom({ v: video })
+    const result = await loadHandler()({ nodeId: 'v', action: 'play' }, {})
+    expect(result).toMatchObject({ success: true, playing: true, muted: true, mutedFallback: true })
+    expect(video.playCalls).toBe(2)
+  })
+
+  it('reports a missing video instead of throwing', async () => {
+    withDom({})
+    const result = await loadHandler()({ nodeId: 'nowhere', action: 'play' }, {})
+    expect(result).toEqual({ success: false, action: 'play', reason: 'video-not-found' })
+  })
+})

package/__tests__/element-visible-settings.test.ts

@@ -0,0 +1,128 @@
+// The "On Visible" trigger's settings, as the editor's inspector writes them:
+// a PERCENT threshold and `once` (formerly `triggerOnce`). Before 2026-09-18 the
+// percent reached IntersectionObserver unconverted — Chrome 153: "RangeError:
+// Failed to construct 'IntersectionObserver': Threshold values must be numbers
+// between 0 and 1" — and "run once" was never read.
+
+import { elementVisibleObserverCode, elementVisibleSettings } from '../src/element-visible-trigger'
+import { generateTriggerCode } from '../src/trigger-generator'
+
+describe('elementVisibleSettings', () => {
+  it('turns the inspector percent into the share the browser counts, within 0–1', () => {
+    expect(elementVisibleSettings({ threshold: 50 }).threshold).toBe(0.5)
+    expect(elementVisibleSettings({ threshold: 100 }).threshold).toBe(1)
+    expect(elementVisibleSettings({ threshold: 250 }).threshold).toBe(1)
+    expect(elementVisibleSettings({ threshold: -5 }).threshold).toBe(0)
+    expect(elementVisibleSettings({}).threshold).toBe(0)
+    expect(elementVisibleSettings({ threshold: 'x' }).threshold).toBe(0)
+  })
+
+  it('runs once unless told otherwise, and still reads the name older projects saved', () => {
+    expect(elementVisibleSettings({}).once).toBe(true)
+    expect(elementVisibleSettings({ once: false }).once).toBe(false)
+    expect(elementVisibleSettings({ triggerOnce: false }).once).toBe(false)
+    expect(elementVisibleSettings({ triggerOnce: true }).once).toBe(true)
+    // the current name wins when both are present
+    expect(elementVisibleSettings({ once: true, triggerOnce: false }).once).toBe(true)
+  })
+})
+
+/**
+ * Runs the generated statements against a fake IntersectionObserver and lets a
+ * test feed it the entries a browser would, one visibility change at a time.
+ */
+const observe = (config: Record<string, unknown>, viewportHeight = 1000) => {
+  let callback: (entries: unknown[]) => void = () => undefined
+  let options: { threshold: number | number[] } = { threshold: 0 }
+  let disconnected = false
+  class FakeObserver {
+    constructor(cb: (entries: unknown[]) => void, opts: { threshold: number | number[] }) {
+      callback = cb
+      options = opts
+    }
+    disconnect() {
+      disconnected = true
+    }
+  }
+  const runs: number[] = []
+  const code = elementVisibleObserverCode('obs', config, 'runs.push(entry.intersectionRatio);')
+  // tslint:disable-next-line:function-constructor
+  new Function('IntersectionObserver', 'window', 'runs', code)(
+    FakeObserver,
+    { innerHeight: viewportHeight },
+    runs
+  )
+  const see = (ratio: number, height = 400) => {
+    if (!disconnected) {
+      callback([
+        { isIntersecting: ratio > 0, intersectionRatio: ratio, boundingClientRect: { height } },
+      ])
+    }
+  }
+  return { runs, see, options: () => options, disconnected: () => disconnected }
+}
+
+describe('the generated observer', () => {
+  it('builds a valid observer for a threshold typed in the inspector', () => {
+    const { options } = observe({ threshold: 50 })
+    const thresholds = ([] as number[]).concat(options().threshold)
+    expect(thresholds.every((value) => value >= 0 && value <= 1)).toBe(true)
+  })
+
+  it('runs when enough of the element is on screen, once by default', () => {
+    const trigger = observe({ threshold: 50 })
+    trigger.see(0.3)
+    expect(trigger.runs).toEqual([])
+    trigger.see(0.55)
+    expect(trigger.runs).toEqual([0.55])
+    expect(trigger.disconnected()).toBe(true)
+    trigger.see(0.1)
+    trigger.see(0.9)
+    expect(trigger.runs).toEqual([0.55])
+  })
+
+  it('"every time" runs again after the element has left, never twice while it stays', () => {
+    const trigger = observe({ threshold: 50, triggerOnce: false })
+    trigger.see(0.6)
+    trigger.see(0.8)
+    trigger.see(0.65)
+    expect(trigger.runs).toEqual([0.6])
+    trigger.see(0.2)
+    trigger.see(0.7)
+    expect(trigger.runs).toEqual([0.6, 0.7])
+    expect(trigger.disconnected()).toBe(false)
+  })
+
+  it('an element taller than the screen runs at what it can reach', () => {
+    // 3000px tall in a 1000px screen: at most a third of it is ever visible
+    const trigger = observe({ threshold: 60 }, 1000)
+    trigger.see(0.32, 3000)
+    expect(trigger.runs).toEqual([0.32])
+  })
+
+  it('with no threshold it runs as soon as any part appears', () => {
+    const trigger = observe({})
+    expect(trigger.options().threshold).toBe(0)
+    trigger.see(0.01)
+    expect(trigger.runs).toEqual([0.01])
+  })
+})
+
+describe('both generator paths use it', () => {
+  it('the exported trigger generator no longer passes the percent to the browser', () => {
+    const code = generateTriggerCode(
+      {
+        id: 'wf-1',
+        trigger: {
+          type: 'event-element-visible',
+          config: { elementHtmlId: 'hero', threshold: 50, triggerOnce: false },
+        },
+      } as never,
+      'wf'
+    )
+    expect(code).not.toContain('threshold: 50')
+    expect(code).toContain('Math.min(0.5, reach * 0.9)')
+    // "every time": the only disconnect left is the cleanup's
+    expect(code.match(/disconnect\(\)/g)).toHaveLength(1)
+  })
+})

package/__tests__/element-visible-trigger-scoping.test.ts

@@ -294,3 +294,25 @@ describe('event-element-visible — config/handler integrity when the module is
     expect(code).toContain('const __wfConfig_wf_cookie_visible =')
   })
 })
+
+// The inspector writes the threshold as a percent and, in projects saved before
+// 2026-09-18, the run choice as `triggerOnce` (see element-visible-trigger.ts).
+describe('event-element-visible — the inspector settings reach the page', () => {
+  it('a 50% threshold becomes the 0.5 the browser accepts, and "every time" keeps observing', async () => {
+    const code =
+      (await getWorkflowModule(
+        elementVisibleWorkflow({
+          nodeId: NODE_ID,
+          elementHtmlId: HTML_ID,
+          threshold: 50,
+          triggerOnce: false,
+        }),
+        HTML_ID
+      )) || ''
+
+    expect(code).toContain('Math.min(0.5, reach * 0.9)')
+    expect(code).not.toContain('threshold: 50 }')
+    // the only disconnect left is the cleanup's
+    expect(code.match(/__obs_wf_cookie_visible\.disconnect\(\)/g)).toHaveLength(1)
+  })
+})

package/__tests__/scrolled-past-trigger.test.ts

@@ -0,0 +1,189 @@
+// The two "scrolled past a point" triggers. `event-scene-scrolled-past` is a
+// LIFECYCLE trigger bound to ONE element (the scroll scene): it listens for
+// `tq-scene-point-passed` on the scene's track and is pruned from pages that
+// do not render the scene. `event-page-scrolled-past` is page-scoped and
+// watches the window's own scroll progress.
+
+import { createNextWorkflowPlugin } from '../src/workflow-component-plugin'
+
+const HTML_ID = 'thq_story_scene'
+const NODE_ID = 'TQ__storyScene'
+
+const workflowWith = (trigger: Record<string, unknown>) => ({
+  id: 'wf-scrolled-past',
+  name: 'Reveal offer',
+  trigger: { nodeId: 'trigger-scroll', ...trigger },
+  nodes: [
+    {
+      id: 'update-1',
+      type: 'state-update-local-state',
+      config: { property: 'offerShown', value: true },
+      stepNumber: 1,
+      label: 'Show offer',
+    },
+  ],
+  edges: [{ id: 'e1', source: 'trigger-scroll', target: 'update-1' }],
+})
+
+const sceneWorkflow = (config: Record<string, unknown>) =>
+  workflowWith({ type: 'event-scene-scrolled-past', scope: 'element', config })
+
+const pageWorkflow = (config: Record<string, unknown>) =>
+  workflowWith({ type: 'event-page-scrolled-past', scope: 'page', config })
+
+const jsxWithElementId = (elementId: string | null) => ({
+  type: 'chunk-type-ast',
+  name: 'jsx-component',
+  content: {
+    type: 'VariableDeclaration',
+    declarations: [
+      {
+        type: 'VariableDeclarator',
+        init: {
+          type: 'ArrowFunctionExpression',
+          body: {
+            type: 'BlockStatement',
+            body: [
+              {
+                type: 'ReturnStatement',
+                argument: {
+                  type: 'JSXElement',
+                  openingElement: {
+                    type: 'JSXOpeningElement',
+                    name: { type: 'JSXIdentifier', name: 'div' },
+                    attributes: elementId
+                      ? [
+                          {
+                            type: 'JSXAttribute',
+                            name: { type: 'JSXIdentifier', name: 'id' },
+                            value: { type: 'StringLiteral', value: elementId },
+                          },
+                        ]
+                      : [],
+                  },
+                  children: [],
+                },
+              },
+            ],
+          },
+        },
+      },
+    ],
+  },
+})
+
+const getWorkflowModule = async (
+  workflow: any,
+  renderedElementId: string | null
+): Promise<string | null> => {
+  const plugin = createNextWorkflowPlugin({ isPage: true })
+  const structure: any = {
+    uidl: {
+      name: 'Story',
+      outputOptions: { pageId: 'page_home', fileName: 'page_home' },
+      node: { type: 'element', content: { elementType: 'container', name: 'Container' } },
+      stateDefinitions: { offerShown: { type: 'boolean', defaultValue: false } },
+    },
+    chunks: [jsxWithElementId(renderedElementId)],
+    options: { workflows: { workflows: { [workflow.id]: workflow }, customNodes: {} } },
+    dependencies: {},
+  }
+  await plugin(structure)
+  const moduleChunk = (structure.chunks as any[]).find((c: any) => c.name === 'workflow-module')
+  return moduleChunk ? String(moduleChunk.content) : null
+}
+
+describe('event-scene-scrolled-past — generated listener', () => {
+  const module = (config: Record<string, unknown>, rendered: string | null = HTML_ID) =>
+    getWorkflowModule(sceneWorkflow(config), rendered)
+
+  it('listens on the scene track for the point the author picked', async () => {
+    const code = await module({ nodeId: NODE_ID, elementHtmlId: HTML_ID, point: 'three-quarters' })
+    expect(code).not.toBeNull()
+    expect(code).toContain(`document.getElementById('${HTML_ID}')`)
+    expect(code).toContain(".closest('[data-scene-track]')")
+    expect(code).toContain("addEventListener('tq-scene-point-passed'")
+    expect(code).toContain("if (detail.point !== 'three-quarters') { return; }")
+    expect(code).toContain(`elementId: '${HTML_ID}', point: 'three-quarters'`)
+    expect(code).toMatch(/if \(event\.target !== __spRoot_\w+\) \{ return; \}/)
+    expect(code).not.toContain(NODE_ID)
+  })
+
+  it('falls back to halfway when no point was set', async () => {
+    const code = await module({ nodeId: NODE_ID, elementHtmlId: HTML_ID })
+    expect(code).toContain("if (detail.point !== 'half') { return; }")
+    expect(code).toMatch(/if \(__spStamp_\w+ >= 2\) \{/)
+  })
+
+  it('fires once by default: detaches after the first pass and skips the listener when the stamp already covers it', async () => {
+    const code = await module({ nodeId: NODE_ID, elementHtmlId: HTML_ID, point: 'end' })
+    expect(code).toMatch(
+      /__spRoot_\w+\.removeEventListener\('tq-scene-point-passed', __spH_\w+\);\n\s+__spFire_/
+    )
+    expect(code).toMatch(/if \(__spStamp_\w+ < 4\) \{/)
+  })
+
+  it('keeps listening when the author asked for every time', async () => {
+    const code = await module({
+      nodeId: NODE_ID,
+      elementHtmlId: HTML_ID,
+      point: 'quarter',
+      once: false,
+    })
+    expect(code).not.toMatch(
+      /__spRoot_\w+\.removeEventListener\('tq-scene-point-passed', __spH_\w+\);\n\s+__spFire_/
+    )
+    expect(code).not.toMatch(/if \(__spStamp_\w+ < 1\) \{/)
+    expect(code).toContain("addEventListener('tq-scene-point-passed'")
+  })
+
+  it('reads the stamped furthest point when it attaches after the pass', async () => {
+    const code = await module({ nodeId: NODE_ID, elementHtmlId: HTML_ID, point: 'half' })
+    expect(code).toContain("getAttribute('data-scene-point')")
+    expect(code).toMatch(/if \(__spStamp_\w+ >= 2\) \{\n\s+__spFire_\w+\(0\.5\);/)
+  })
+
+  it('is pruned from a page that does not render the scene', async () => {
+    const code = await module({ nodeId: NODE_ID, elementHtmlId: HTML_ID }, 'some_other_element')
+    expect(code === null || !code.includes('tq-scene-point-passed')).toBe(true)
+  })
+})
+
+describe('event-page-scrolled-past — generated listener', () => {
+  const module = (config: Record<string, unknown>) => getWorkflowModule(pageWorkflow(config), null)
+
+  it('watches the window scroll progress for the point the author picked', async () => {
+    const code = await module({ pageId: 'page_home', point: 'three-quarters' })
+    expect(code).not.toBeNull()
+    expect(code).toContain("window.addEventListener('scroll', __ppOnScroll_")
+    expect(code).toContain("window.addEventListener('resize', __ppOnScroll_")
+    expect(code).toContain('document.documentElement.scrollHeight - window.innerHeight')
+    expect(code).toContain('if (progress < 0.75 - 0.000001)')
+    expect(code).toContain("point: 'three-quarters', progress: progress, url: window.location.href")
+  })
+
+  it('checks once on attach so an anchor link that opens past the point counts', async () => {
+    const code = await module({ pageId: 'page_home', point: 'half' })
+    expect(code).toMatch(/cleanups\.push\(__ppStop_\w+\);\n\s+__ppCheck_\w+\(\);/)
+  })
+
+  it('stays off every page but the one it watches', async () => {
+    const code = await module({ pageId: 'page_pricing', point: 'half' })
+    expect(code === null || !code.includes('__ppOnScroll_')).toBe(true)
+    const everywhere = await module({ allPages: true, point: 'half' })
+    expect(everywhere).toContain('__ppOnScroll_')
+  })
+
+  it('treats a page that cannot scroll as fully in view', async () => {
+    const code = await module({ pageId: 'page_home', point: 'end' })
+    expect(code).toContain('return max <= 0 ? 1 :')
+  })
+
+  it('fires once by default and detaches; every time re-arms when the visitor scrolls back up', async () => {
+    const once = await module({ pageId: 'page_home', point: 'half' })
+    expect(once).toMatch(/__ppPassed_\w+ = true;\n\s+__ppStop_\w+\(\);/)
+    const every = await module({ pageId: 'page_home', point: 'half', once: false })
+    expect(every).not.toMatch(/__ppPassed_\w+ = true;\n\s+__ppStop_\w+\(\);/)
+    expect(every).toMatch(/\{ __ppPassed_\w+ = false; return; \}/)
+  })
+})

package/dist/cjs/api-route-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api-route-generator.d.ts","sourceRoot":"","sources":["../../src/api-route-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EAIb,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAuD9C,MAAM,WAAW,yBAAyB;IACxC,0EAA0E;IAC1E,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;IACxB;;;;OAIG;IACH,KAAK,CAAC,EAAE,YAAY,CAAA;CACrB;AA4BD,eAAO,MAAM,6BAA6B,YAC/B,eAAe,iBACT,MAAM,eACR,sBAAsB,YAC1B,yBAAyB,KACjC,MA+WF,CAAA;AAED,eAAO,MAAM,kBAAkB,YAAa,eAAe,KAAG,OAE7D,CAAA;AAED,eAAO,MAAM,sCAAsC,YACxC,eAAe,iBACT,MAAM,eACR,sBAAsB,YAC1B,yBAAyB,KACjC,MAsbF,CAAA;AA2JD,eAAO,MAAM,oBAAoB,aACrB,YAAY,gBACR,OAAO,MAAM,EAAE,sBAAsB,CAAC,KACnD,MAsHF,CAAA;AAED,eAAO,MAAM,mBAAmB,eAClB,MAAM,aACP,MAAM,iBACF,MAAM,KACpB,MA4BF,CAAA;AAED,eAAO,MAAM,oBAAoB,aAAc,YAAY,KAAG,MAa7D,CAAA;AA8RD,eAAO,MAAM,+BAA+B,aAChC,YAAY,gBACR,OAAO,MAAM,EAAE,sBAAsB,CAAC,KACnD,MA0OF,CAAA;AAED,eAAO,MAAM,uBAAuB,aAAc,YAAY,KAAG,MAiBhE,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B,cAC1B,aAAa,GAAG,SAAS,cACxB,MAAM,KACjB,MAAM,GAAG,IAYX,CAAA;AAED,eAAO,MAAM,mBAAmB,aAAc,YAAY,KAAG,MAAM,EAqBlE,CAAA"}
+{"version":3,"file":"api-route-generator.d.ts","sourceRoot":"","sources":["../../src/api-route-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EAIb,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAuD9C,MAAM,WAAW,yBAAyB;IACxC,0EAA0E;IAC1E,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;IACxB;;;;OAIG;IACH,KAAK,CAAC,EAAE,YAAY,CAAA;CACrB;AA4BD,eAAO,MAAM,6BAA6B,YAC/B,eAAe,iBACT,MAAM,eACR,sBAAsB,YAC1B,yBAAyB,KACjC,MA+WF,CAAA;AAED,eAAO,MAAM,kBAAkB,YAAa,eAAe,KAAG,OAE7D,CAAA;AAED,eAAO,MAAM,sCAAsC,YACxC,eAAe,iBACT,MAAM,eACR,sBAAsB,YAC1B,yBAAyB,KACjC,MAsbF,CAAA;AA4JD,eAAO,MAAM,oBAAoB,aACrB,YAAY,gBACR,OAAO,MAAM,EAAE,sBAAsB,CAAC,KACnD,MAsHF,CAAA;AAED,eAAO,MAAM,mBAAmB,eAClB,MAAM,aACP,MAAM,iBACF,MAAM,KACpB,MA4BF,CAAA;AAED,eAAO,MAAM,oBAAoB,aAAc,YAAY,KAAG,MAa7D,CAAA;AA8RD,eAAO,MAAM,+BAA+B,aAChC,YAAY,gBACR,OAAO,MAAM,EAAE,sBAAsB,CAAC,KACnD,MA0OF,CAAA;AAED,eAAO,MAAM,uBAAuB,aAAc,YAAY,KAAG,MAiBhE,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B,cAC1B,aAAa,GAAG,SAAS,cACxB,MAAM,KACjB,MAAM,GAAG,IAYX,CAAA;AAED,eAAO,MAAM,mBAAmB,aAAc,YAAY,KAAG,MAAM,EAqBlE,CAAA"}

package/dist/cjs/api-route-generator.js

@@ -942,6 +942,7 @@ const CLIENT_ONLY_NODES = new Set([
     'element-show',
     'element-hide',
     'element-scroll-to',
+    'element-video-control',
     'element-get-input-value',
     'element-set-text',
     'element-set-attribute',