@sitecore-feaas/clientside 0.1.28 → 0.1.29

package/test/FEAASComponent.test.tsx

@@ -0,0 +1,284 @@
+import { beforeEach, afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
+import { FEAASComponent } from '../src/components/FEAASComponent.js'
+import { renderDOMContent } from '../src/dom/rendering.js'
+import { clearFetchCache } from '../src/fetch.js'
+
+const earliest = new Date(2000, 1, 1, 0, 0, 0)
+const earlier = new Date(2000, 1, 2, 0, 0, 0)
+const now = new Date(2000, 1, 2, 12, 0, 0)
+describe('Components', () => {
+  beforeAll(() => {
+    // vi.useFakeTimers()
+    vi.setSystemTime(now)
+  })
+  afterAll(() => {
+    // vi.useRealTimers()
+  })
+  beforeEach(() => {
+    document.write()
+    clearFetchCache()
+  })
+  it('should load component using', async () => {
+    const spy = vi.spyOn(global, 'fetch')
+    spy.mockImplementation(async (url: string, options: Parameters<typeof fetch>[1] = {}) => {
+      if (url.match('CDN/components/L/C/V/R')) {
+        return new Response('TODAY', {
+          headers: {
+            date: now.toUTCString(),
+            'last-modified': earlier.toUTCString()
+          }
+        })
+      }
+    })
+
+    // Fixme change to production component
+    document.body.innerHTML =
+      '<feaas-component with-stylesheet="false" library="L" cdn="CDN" component="C" version="V" revision="R"></feaas-component>'
+
+    const component = document.body.firstElementChild as FEAASComponent
+
+    await expect(component.whenRendered).resolves.toEqual(component)
+    expect(spy).toHaveBeenCalledTimes(1)
+
+    expect(component.innerHTML).toContain('TODAY')
+  })
+
+  it('should load component using src attribute shorthand', async () => {
+    const spy = vi.spyOn(global, 'fetch')
+    spy.mockImplementation(async (url: string, options: Parameters<typeof fetch>[1] = {}) => {
+      if (url.match('http://a/components/b/c/d/e.html')) {
+        return new Response('TODAY', {
+          headers: {
+            date: now.toUTCString(),
+            'last-modified': earlier.toUTCString()
+          }
+        })
+      }
+    })
+
+    // Fixme change to production component
+    document.body.innerHTML =
+      '<feaas-component with-stylesheet="false" src="http://a/components/b/c/d/e.html"></feaas-component>'
+
+    const component = document.body.firstElementChild as FEAASComponent
+
+    await expect(component.whenRendered).resolves.toEqual(component)
+    expect(spy).toHaveBeenCalledTimes(1)
+
+    expect(component.outerHTML).toBe(
+      `<feaas-component with-stylesheet="false" src="http://a/components/b/c/d/e.html" cdn="http://a" library="b" component="c" version="d" revision="e" class="-feaas">TODAY</feaas-component>`
+    )
+  })
+
+  it('should revalidate cached component response', async () => {
+    const spy = vi.spyOn(global, 'fetch')
+    spy.mockImplementation(async (url: string, options: Parameters<typeof fetch>[1] = {}) => {
+      if (url.match('CDN/components/L/C/V/R') && options.method != 'HEAD') {
+        // 1. Here's cached component
+        return new Response('TODAY', {
+          headers: {
+            date: earlier.toUTCString(),
+            'last-modified': earlier.toUTCString()
+          }
+        })
+      } else {
+        // 2. Is my cached response up to date? Yes.
+        return new Response(null, {
+          headers: {
+            date: now.toUTCString(),
+            'last-modified': earlier.toUTCString()
+          }
+        })
+      }
+    })
+
+    // Fixme change to production component
+    document.body.innerHTML =
+      '<feaas-component with-stylesheet="false" library="L" cdn="CDN" component="C" version="V" revision="R"></feaas-component>'
+
+    const component = document.body.firstElementChild as FEAASComponent
+
+    await expect(component.whenRendered).resolves.toEqual(component)
+    expect(spy).toHaveBeenCalledTimes(2)
+
+    expect(component.innerHTML).toContain('TODAY')
+  })
+
+  it('should reload component while using stale cache', async () => {
+    const spy = vi.spyOn(global, 'fetch')
+    spy.mockImplementation(async (url: string, options: Parameters<typeof fetch>[1] = {}) => {
+      if (options.method != 'HEAD' && options['cache'] != 'reload') {
+        // Here's cached component
+        return new Response('YESTERDAY', {
+          headers: {
+            date: earlier.toUTCString(),
+            'last-modified': earliest.toUTCString()
+          }
+        })
+      } else if (options.method == 'HEAD') {
+        // Is my cached response up to date?
+        return new Response(null, {
+          headers: {
+            date: now.toUTCString(),
+            'last-modified': earlier.toUTCString()
+          }
+        })
+      } else {
+        // Up to date version
+        return new Response('TODAY', {
+          headers: {
+            date: now.toUTCString(),
+            'last-modified': earlier.toUTCString()
+          }
+        })
+      }
+    })
+
+    // Fixme change to production component
+    document.body.innerHTML =
+      '<feaas-component with-stylesheet="false" library="L" cdn="CDN" component="C" version="V" revision="R"></feaas-component>'
+
+    const component = document.body.firstElementChild as FEAASComponent
+    // Renders cached version initially
+    await expect(component.whenRendered).resolves.toEqual(component)
+    expect(component.innerHTML).toContain('YESTERDAY')
+    expect(spy).toHaveBeenCalledTimes(2)
+
+    // whenLoaded only fires when ensures that up-to-date version is loaded
+    await expect(component.whenLoaded).resolves.toBeTruthy()
+    expect(spy).toHaveBeenCalledTimes(3)
+    expect(component.innerHTML).toContain('TODAY')
+  })
+
+  it('should re-fetch component when attributes change', async () => {
+    const spy = vi.spyOn(global, 'fetch')
+    spy.mockImplementation(async (url: string, options: Parameters<typeof fetch>[1] = {}) => {
+      if (url.match('CDN/components/L/C2/V/R')) {
+        return new Response('C2', {
+          headers: {
+            date: now.toUTCString(),
+            'last-modified': earlier.toUTCString()
+          }
+        })
+      } else if (url.match('CDN/components/L/C1/V/R')) {
+        return new Response('C1', {
+          headers: {
+            date: now.toUTCString(),
+            'last-modified': earlier.toUTCString()
+          }
+        })
+      }
+    })
+
+    // Fixme change to production component
+    document.body.innerHTML =
+      '<feaas-component with-stylesheet="false" library="L" cdn="CDN" component="C1" version="V" revision="R"></feaas-component>'
+
+    const component = document.body.firstElementChild as FEAASComponent
+    await expect(component.whenRendered).resolves.toEqual(component)
+    expect(spy).toHaveBeenNthCalledWith(1, 'CDN/components/L/C1/V/R.html', undefined)
+    expect(spy).toHaveBeenCalledTimes(1)
+    expect(component.innerHTML).toContain('C1')
+
+    component.setAttribute('component', 'C2')
+    await expect(component.whenRendered).resolves.toEqual(component)
+    expect(spy).toHaveBeenNthCalledWith(2, 'CDN/components/L/C2/V/R.html', undefined)
+    expect(spy).toHaveBeenCalledTimes(2)
+    expect(component.innerHTML).toContain('C2')
+  })
+  it('should wait for stylesheet to load', async () => {
+    const spy = vi.spyOn(global, 'fetch')
+    spy.mockImplementation(async (url: string, options: Parameters<typeof fetch>[1] = {}) => {
+      if (url.includes('.css')) {
+        if (url.match('/styles/L/published.css') && options?.method != 'HEAD' && options?.['cache'] != 'reload') {
+          // Serve from cache
+          await new Promise((resolve) => setTimeout(resolve, 100))
+          return new Response('YESTERDAY {}', {
+            headers: {
+              date: earlier.toUTCString(),
+              'last-modified': earliest.toUTCString()
+            }
+          })
+        } else if (url.match('/styles/L/published.css') && options?.method == 'HEAD') {
+          // Validate
+          return new Response(null, {
+            headers: {
+              date: now.toUTCString(),
+              'last-modified': earlier.toUTCString()
+            }
+          })
+        } else {
+          await new Promise((resolve) => setTimeout(resolve, 200))
+          return new Response('TODAY {}', {
+            headers: {
+              date: now.toUTCString(),
+              'last-modified': earlier.toUTCString()
+            }
+          })
+        }
+      } else {
+        if (options.method != 'HEAD' && options['cache'] != 'reload') {
+          // Here's cached component
+          return new Response('YESTERDAY', {
+            headers: {
+              date: earlier.toUTCString(),
+              'last-modified': earliest.toUTCString()
+            }
+          })
+        } else if (options.method == 'GET' && options['cache'] == 'reload') {
+          // Is my cached response up to date?
+          return new Response(null, {
+            headers: {
+              date: now.toUTCString(),
+              'last-modified': earlier.toUTCString()
+            }
+          })
+        } else {
+          //  Latest
+          await new Promise((resolve) => setTimeout(resolve, 100))
+          return new Response('TODAY', {
+            headers: {
+              date: now.toUTCString(),
+              'last-modified': earlier.toUTCString()
+            }
+          })
+        }
+      }
+    })
+    // Fixme change to production component
+    document.body.innerHTML = '<feaas-component src="L/C"></feaas-component>'
+    const component = document.body.firstElementChild as FEAASComponent
+    expect(document.head.querySelector('style')).toBeNull()
+    await new Promise((resolve) => setTimeout(resolve, 50))
+    const stylesheet = document.head.querySelector('style') as HTMLStyleElement
+    expect(stylesheet.innerHTML).toEqual('')
+    expect(component.innerHTML).toEqual('')
+    // Component will rendered with stale cached stylesheet
+    await expect(component.whenRendered).resolves.toEqual(component)
+    expect(stylesheet.innerHTML).toEqual('YESTERDAY {}')
+    expect(component.innerHTML).toEqual('YESTERDAY')
+    // Component will update itself with stale cached stylesheet
+    await expect(component.whenLoaded).resolves.toEqual('TODAY')
+    expect(stylesheet.innerHTML).toEqual('YESTERDAY {}')
+    expect(component.innerHTML).toEqual('TODAY')
+    await new Promise((resolve) => setTimeout(resolve, 100))
+    // Stylesheet will update later
+    expect(stylesheet.innerHTML).toEqual('TODAY {}')
+  })
+
+  it('render without data', () => {
+    const component = new FEAASComponent()
+    const div = document.createElement('div')
+    div.appendChild(component)
+    document.body.appendChild(div)
+    renderDOMContent(component, `<section class="-theme--abc test"></section><section class="-theme--cde"></section>`)
+    expect(div.innerHTML).toEqual(
+      `<feaas-component class="-feaas"><section class="-theme--abc test"></section><section class="-theme--cde"></section></feaas-component>`
+    )
+    component.className = '-theme--override test2'
+    renderDOMContent(component, `<section class="-theme--abc test"></section><section class="-theme--cde"></section>`)
+    expect(div.innerHTML).toEqual(
+      `<feaas-component class="-theme--override test2 -feaas"><section class="test"></section><section class=""></section></feaas-component>`
+    )
+  })
+})

package/test/FEAASContext.test.tsx

@@ -0,0 +1,76 @@
+import { beforeEach, describe, it, assert, beforeAll, expect } from 'vitest'
+import { FEAASBase, ReactPayload } from '../src/headless.js'
+import { FEAASContextProps, FEAASContext } from '../src/ui/FEAASContext.js'
+import { JSDOM } from 'jsdom'
+import { vi } from 'vitest'
+
+describe('React', function () {
+  describe('FEAASContext', () => {
+    beforeEach(() => {
+      document.write()
+    })
+    it('should initiate loading with isolation', async () => {
+      // @ts-ignore
+      const spyLoad = vi.spyOn(FEAASContext.prototype, 'import')
+      // @ts-ignore
+      spyLoad.mockImplementation(async (url: string) => {
+        if (url.match('test.js')) {
+          return Promise.all([import('react'), import('react-dom'), import('react-dom/client')]).then(
+            ([React, ReactDOM, ReactDOMClient]) => {
+              return {
+                React,
+                ReactDOM,
+                ReactDOMClient,
+                Chakra: { Tooltip: {} },
+                AppContext: ({ libraryId }: any) => <p>Context {libraryId}</p>
+              }
+            }
+          )
+        }
+      })
+      // Fixme change to production component
+      document.body.innerHTML = '<feaas-context src="test.js" library="abc" isolate="false"></feaas-context>'
+
+      const component = document.body.firstElementChild as FEAASContext
+
+      await expect(component.whenRendered).resolves.toEqual(component)
+      expect(spyLoad).toHaveBeenCalledTimes(1)
+
+      expect(component.outerHTML).toBe(
+        '<feaas-context src="test.js" library="abc" isolate="false" frontend="https://components.sitecoreclud.io" backend="https://components-api.sitecoreclud.io" cdn="https://feaascompontsapiprod.blob.core.windows.net"><div><p>Context abc</p></div></feaas-context>'
+      )
+    })
+  })
+  it('should initiate loading without isolation', async () => {
+    // @ts-ignore
+    const spyLoad = vi.spyOn(FEAASContext.prototype, 'import')
+    // @ts-ignore
+    spyLoad.mockImplementation(async (url: string) => {
+      if (url.match('test.js')) {
+        return Promise.all([import('react'), import('react-dom'), import('react-dom/client')]).then(
+          ([React, ReactDOM, ReactDOMClient]) => {
+            return {
+              React,
+              ReactDOM,
+              ReactDOMClient,
+              Chakra: { Tooltip: {} },
+              AppContext: ({ libraryId }: any) => <p>Context {libraryId}</p>
+            }
+          }
+        )
+      }
+    })
+    // Fixme change to production component
+    document.body.innerHTML = '<feaas-context src="test.js" library="abc"></feaas-context>'
+
+    const component = document.body.firstElementChild as FEAASContext
+
+    await expect(component.whenRendered).resolves.toEqual(component)
+    expect(spyLoad).toHaveBeenCalledTimes(1)
+
+    expect(component.outerHTML).toBe(
+      '<feaas-context src="test.js" library="abc" frontend="https://components.sitecoreclud.io" backend="https://components-api.sitecoreclud.io" cdn="https://feaascompontsapiprod.blob.core.windows.net"></feaas-context>'
+    )
+    expect(component.shadowRoot.innerHTML).toBe('<div><p>Context abc</p></div>')
+  })
+})

package/test/FEAASPicker.test.tsx

@@ -0,0 +1,40 @@
+import { beforeEach, describe, it, assert, beforeAll, expect } from 'vitest'
+import { FEAASBase, ReactPayload } from '../src/headless.js'
+import { FEAASPickerProps, FEAASPicker } from '../src/ui/FEAASPicker.js'
+import { JSDOM } from 'jsdom'
+import { vi } from 'vitest'
+
+describe('React', function () {
+  describe('FEAASPicker', () => {
+    beforeEach(() => {
+      document.write()
+    })
+    it('should initiate loading', async () => {
+      // @ts-ignore
+      const spyLoad = vi.spyOn(FEAASPicker.prototype, 'import')
+      // @ts-ignore
+      spyLoad.mockImplementation(async (url: string) => {
+        if (url.match('test.js')) {
+          return Promise.all([import('react'), import('react-dom'), import('react-dom/client')]).then(
+            ([React, ReactDOM, ReactDOMClient]) => {
+              return { React, ReactDOM, ReactDOMClient, Picker: () => <p>Picker</p> }
+            }
+          )
+        }
+      })
+      const spyRender = vi.spyOn(FEAASPicker.prototype, 'render')
+      spyRender.mockImplementation((props: React.PropsWithChildren<FEAASPickerProps>, { React, Picker }) => {
+        return <Picker>123</Picker>
+      })
+      // Fixme change to production component
+      document.body.innerHTML = '<feaas-picker src="test.js"></feaas-picker>'
+
+      const component = document.body.firstElementChild as FEAASPicker
+
+      await expect(component.whenRendered).resolves.toEqual(component)
+      expect(spyLoad).toHaveBeenCalledTimes(1)
+
+      expect(component.innerHTML).toContain('Picker')
+    })
+  })
+})

package/test/FEAASStylesheet.test.tsx

@@ -0,0 +1,159 @@
+import { afterAll, beforeEach, beforeAll, describe, expect, it, vi } from 'vitest'
+import { FEAASStylesheet } from '../src/components/FEAASStylesheet.js'
+import { renderDOMContent } from '../src/dom/rendering.js'
+import { clearFetchCache, loadStylesheet } from '../src/headless.js'
+
+const earliest = new Date(2000, 1, 1, 0, 0, 0)
+const earlier = new Date(2000, 1, 2, 0, 0, 0)
+const now = new Date(2000, 1, 2, 12, 0, 0)
+
+describe('Stylesheet', () => {
+  beforeAll(() => {
+    // vi.useFakeTimers()
+    vi.setSystemTime(now)
+  })
+  beforeEach(() => {
+    document.open()
+    document.write('<html><head></head><body></body></html')
+    document.close()
+    clearFetchCache()
+  })
+  it('should instantiate', () => {
+    expect(new FEAASStylesheet()).toBeInstanceOf(FEAASStylesheet)
+  })
+  it('should not load unconfigured stylesheet', async () => {
+    const spy = vi.spyOn(global, 'fetch')
+    document.body.innerHTML = '<feaas-stylesheet cdn="CDN" revision="R"></feaas-stylesheet>'
+    expect(spy).toHaveBeenCalledTimes(0)
+  })
+  it('should load stylesheet (cold cache)', async () => {
+    const spy = vi.spyOn(global, 'fetch')
+    spy.mockImplementation(async (url: string, options: Parameters<typeof fetch>[1] = {}) => {
+      return new Response('TODAY {}', {
+        headers: {
+          date: now.toUTCString(),
+          'last-modified': earlier.toUTCString()
+        }
+      })
+    })
+
+    document.body.innerHTML = '<feaas-stylesheet library="L" cdn="CDN" revision="R"></feaas-stylesheet>'
+
+    const stylesheet = document.body.firstElementChild as FEAASStylesheet
+
+    await expect(stylesheet.whenRendered).resolves.toEqual(stylesheet)
+    expect(spy).toHaveBeenCalledTimes(1)
+
+    expect(document.head.querySelector('style').textContent).toContain('TODAY')
+  })
+
+  it('should invalidate stylesheet cache', async () => {
+    const spy = vi.spyOn(global, 'fetch')
+    spy.mockImplementation(async (url: string, options: Parameters<typeof fetch>[1] = {}) => {
+      if (url.match('CDN/styles/L/R.css') && options?.method != 'HEAD') {
+        return new Response('TODAY {}', {
+          headers: {
+            date: earlier.toUTCString(),
+            'last-modified': earlier.toUTCString()
+          }
+        })
+      } else if (url.match('CDN/styles/L/R.css') && options?.method == 'HEAD') {
+        return new Response(null, {
+          headers: {
+            date: earlier.toUTCString(),
+            'last-modified': earlier.toUTCString()
+          }
+        })
+      }
+    })
+
+    document.body.innerHTML = '<feaas-stylesheet library="L" cdn="CDN" revision="R"></feaas-stylesheet>'
+
+    const stylesheet = document.body.firstElementChild as FEAASStylesheet
+
+    await expect(stylesheet.whenRendered).resolves.toEqual(stylesheet)
+    expect(spy).toHaveBeenCalledTimes(2)
+
+    expect(document.head.querySelector('style').textContent).toContain('TODAY')
+  })
+  it('should update stylesheet while using stale cache', async () => {
+    const spy = vi.spyOn(global, 'fetch')
+    spy.mockImplementation(async (url: string, options: Parameters<typeof fetch>[1] = {}) => {
+      if (url.match('CDN/styles/L/R.css') && options?.method != 'HEAD' && options?.['cache'] != 'reload') {
+        // Serve from cache
+        return new Response('YESTERDAY {}', {
+          headers: {
+            date: earlier.toUTCString(),
+            'last-modified': earliest.toUTCString()
+          }
+        })
+      } else if (url.match('CDN/styles/L/R.css') && options?.method == 'HEAD') {
+        // Validate
+        return new Response(null, {
+          headers: {
+            date: now.toUTCString(),
+            'last-modified': earlier.toUTCString()
+          }
+        })
+      } else {
+        return new Response('TODAY {}', {
+          headers: {
+            date: now.toUTCString(),
+            'last-modified': earlier.toUTCString()
+          }
+        })
+      }
+    })
+
+    document.body.innerHTML = '<feaas-stylesheet library="L" cdn="CDN" revision="R"></feaas-stylesheet>'
+
+    const stylesheet = document.body.firstElementChild as FEAASStylesheet
+
+    await expect(stylesheet.whenRendered).resolves.toEqual(stylesheet)
+    expect(spy).toHaveBeenCalledTimes(2)
+    expect(document.head.querySelector('style').textContent).toContain('YESTERDAY {}')
+
+    // whenLoaded only fires when ensures that up-to-date version is loaded
+    await expect(stylesheet.whenLoaded).resolves.toBeTruthy()
+    expect(spy).toHaveBeenCalledTimes(3)
+    expect(document.head.querySelector('style').textContent).toContain('TODAY {}')
+  })
+
+  it('should load stylesheet statically', async () => {
+    const spy = vi.spyOn(global, 'fetch')
+    spy.mockImplementation(async (url: string, options: Parameters<typeof fetch>[1] = {}) => {
+      if (url.match('CDN/styles/L/published.css') && options?.method != 'HEAD' && options?.['cache'] != 'reload') {
+        // Serve from cache
+        return new Response('YESTERDAY {}', {
+          headers: {
+            date: earlier.toUTCString(),
+            'last-modified': earliest.toUTCString()
+          }
+        })
+      } else if (url.match('CDN/styles/L/published.css') && options?.method == 'HEAD') {
+        // Validate
+        return new Response(null, {
+          headers: {
+            date: now.toUTCString(),
+            'last-modified': earlier.toUTCString()
+          }
+        })
+      } else {
+        return new Response('TODAY {}', {
+          headers: {
+            date: now.toUTCString(),
+            'last-modified': earlier.toUTCString()
+          }
+        })
+      }
+    })
+
+    await expect(
+      loadStylesheet({
+        cdn: 'CDN',
+        library: 'L',
+        revision: 'published'
+      }).then((r) => r.textContent)
+    ).resolves.toEqual('TODAY {}')
+  })
+})

package/test/cdn.ts

@@ -0,0 +1,39 @@
+import { describe, it, assert, beforeAll, expect } from 'vitest'
+import { parseComponentSource, getComponentSource, DEFAULT_CDN_URL } from '../src/cdn.js'
+import { CH1Node, serializeCH1RichText } from '../src/dom/data.js'
+describe('CDN', function () {
+  it('should parse and serialize component src', function () {
+    ;[
+      'library/component',
+      'cdn/components/library/component',
+      'https://cdn/components/library/component',
+      '//cdn/components/library/component',
+      'cdn/components/library/component/version',
+      'cdn/components/library/component/version/1',
+      'library/component/version/1',
+      'https://feaaslocal.blob.core.windows.net/components/library/component/version/1'
+    ].forEach((expression) => {
+      expect(getComponentSource(parseComponentSource(expression))).toEqual(expression)
+    })
+    expect(getComponentSource(parseComponentSource('library/component/version/1.html'))).toEqual(
+      'library/component/version/1'
+    )
+    expect(
+      parseComponentSource('https://feaaslocal.blob.core.windows.net/components/library/component/version/1.html')
+    ).toEqual({
+      cdn: 'https://feaaslocal.blob.core.windows.net',
+      component: 'component',
+      library: 'library',
+      revision: '1',
+      version: 'version'
+    })
+    expect(
+      getComponentSource(parseComponentSource(DEFAULT_CDN_URL + '/components/library/component/version/1.html'))
+    ).toEqual('library/component/version/1')
+    expect(
+      getComponentSource(
+        parseComponentSource(DEFAULT_CDN_URL + '/components/library/component/responsive/published.html')
+      )
+    ).toEqual('library/component')
+  })
+})

package/test/{render.ts → dom.test.ts}

@@ -1,9 +1,18 @@
 import { JSDOM } from 'jsdom'
-import * as FEAAS from '../src/dom.js'
+import * as FEAAS from '../src/headless.js'
 import * as FEAASServerSide from '../src/node.js'
 import { describe, it, assert, beforeAll } from 'vitest'
+import { parseHTML } from 'linkedom'
 
-const { renderDOMElement } = FEAAS
+export function renderHTMLContentFallback(
+  template: string,
+  data?: FEAAS.Datascopes,
+  config?: FEAAS.FEAASCustomizations
+) {
+  const newTemplate = config?.processTemplate?.(null, template, data) || template
+  const { document } = parseHTML(newTemplate)
+  return FEAAS.renderDOMElement(document, data, config).toString()
+}
 
 function assertScriptLoaded(element: HTMLElement, src: string) {
   assert.equal(
@@ -51,10 +60,7 @@ function assertRenderedHTML(
   if (!ignoreHTML) {
     assert.equal(normalize(FEAAS.renderHTMLContent('<body>' + input + '</body>', data, customizations)), expectation)
 
-    assert.equal(
-      normalize(FEAASServerSide.renderHTMLContent('<body>' + input + '</body>', data, customizations)),
-      expectation
-    )
+    assert.equal(normalize(renderHTMLContentFallback('<body>' + input + '</body>', data, customizations)), expectation)
   }
 }
 describe('DOM Clientside', function () {

package/test/extras.ts

@@ -1,5 +1,5 @@
 import { describe, it, assert, beforeAll, expect } from 'vitest'
-import { CH1Node, serializeCH1RichText } from '../src/dom.js'
+import { CH1Node, serializeCH1RichText } from '../src/dom/data.js'
 describe('Extras', function () {
   it('should serialize content hub', function () {
     const data: CH1Node = {