@operato/shell 10.29.52 → 10.29.60

package/package.json

@@ -2,7 +2,7 @@
   "name": "@operato/shell",
   "description": "WebApplication architecturing shell following open-wc recommendations",
   "author": "heartyoh",
-  "version": "10.29.52",
+  "version": "10.29.60",
   "type": "module",
   "main": "dist/src/index.js",
   "module": "dist/src/index.js",
@@ -62,7 +62,7 @@
     "@material/web": "^2.0.0",
     "@operato/graphql": "^10.29.49",
     "@operato/i18n": "^10.29.27",
-    "@operato/popup": "^10.29.52",
+    "@operato/popup": "^10.29.59",
     "@operato/styles": "^10.29.30",
     "@operato/utils": "^10.29.49",
     "@webcomponents/scoped-custom-element-registry": "^0.0.9",
@@ -103,5 +103,5 @@
       "prettier --write"
     ]
   },
-  "gitHead": "2e34202735031117c1f096297dee7e48d3595144"
+  "gitHead": "aa25a78fc85445ead63a305c1fd7c973551a0d24"
 }

package/test/page-refresh.test.ts

@@ -0,0 +1,166 @@
+import { expect, fixture } from '@open-wc/testing'
+import { html } from 'lit'
+
+import { PageView } from '../src/app/pages/page-view.js'
+
+/**
+ * A page refresh (ADR-0174) reads the page again as if it had just been opened at its address: every way a page
+ * reads - once at initialization, on activation, on new route arguments - runs again, and so does a grid the page
+ * left to read itself. Unsaved edits follow the rule of a route change on the page on screen.
+ */
+
+class FakeGrist extends HTMLElement {
+  reads = 0
+  dirtyRecords: unknown[] = []
+  async fetch() {
+    this.reads++
+  }
+  reset() {
+    this.dirtyRecords = []
+  }
+  flushEdits() {}
+}
+customElements.define('ox-grist', FakeGrist)
+
+const frame = () => new Promise(resolve => requestAnimationFrame(resolve))
+
+class ReadingPage extends PageView {
+  initialized = 0
+  seen: string[][] = []
+  /** Reads the first grid on new route arguments only, as Office's ledger does. */
+  readsOnParams = true
+  answer = true
+  asked = 0
+
+  render() {
+    return html`<ox-grist id="own"></ox-grist><ox-grist id="self"></ox-grist>`
+  }
+
+  pageInitialized() {
+    this.initialized++
+  }
+
+  pageUpdated(changes: any) {
+    this.seen.push(Object.keys(changes).sort())
+    if (this.readsOnParams && changes.params) void this.grid('own').fetch()
+  }
+
+  async canDeactivate() {
+    this.asked++
+    return this.answer
+  }
+
+  grid(id: string) {
+    return this.renderRoot.querySelector(`#${id}`) as FakeGrist
+  }
+}
+customElements.define('refresh-reading-page', ReadingPage)
+
+const open = async () => {
+  const page = await fixture<ReadingPage>(html`<refresh-reading-page></refresh-reading-page>`)
+  page.lifecycle = { active: true, params: { year: '2026' } }
+  page.active = true
+  await page.updateComplete
+  await frame()
+  await frame()
+  return page
+}
+
+describe('page refresh', () => {
+  it('opening the page again at the same address reads nothing: the reason a refresh is needed', async () => {
+    const page = await open()
+    const seen = page.seen.length
+    page.lifecycle = { active: true, params: { year: '2026' } }
+    await page.updateComplete
+    await frame()
+    expect(page.seen.length).to.equal(seen)
+  })
+
+  it('plays the lifecycle from nothing: initialization and every change a page reads on', async () => {
+    const page = await open()
+    expect(await page.refresh()).to.equal(true)
+    expect(page.initialized).to.equal(2)
+    expect(page.seen[page.seen.length - 1]).to.include.members(['initialized', 'active', 'params'])
+  })
+
+  it('a grid the page read again is not read twice; a grid that reads itself is read again', async () => {
+    const page = await open()
+    page.grid('self').reads = 1
+    const own = page.grid('own').reads
+    await page.refresh()
+    expect(page.grid('own').reads).to.equal(own + 1)
+    expect(page.grid('self').reads).to.equal(2)
+  })
+
+  it('a grid never read is left alone: it may be waiting for a selection', async () => {
+    const page = await open()
+    await page.refresh()
+    expect(page.grid('self').reads).to.equal(0)
+  })
+
+  it('unsaved grid edits no draft keeps are asked about; on "keep" nothing is read', async () => {
+    const page = await open()
+    page.grid('self').dirtyRecords = [{}]
+    page.answer = false
+    const initialized = page.initialized
+    expect(await page.refresh()).to.equal(false)
+    expect(page.asked).to.equal(1)
+    expect(page.initialized).to.equal(initialized)
+    expect(page.grid('self').dirtyRecords.length).to.equal(1)
+  })
+
+  it('a refresh nobody asked for never asks: with unsaved edits it reads nothing', async () => {
+    const page = await open()
+    page.grid('self').dirtyRecords = [{}]
+    const initialized = page.initialized
+    expect(await page.refresh({ ask: false })).to.equal(false)
+    expect(page.asked).to.equal(0)
+    expect(page.initialized).to.equal(initialized)
+    expect(page.grid('self').dirtyRecords.length).to.equal(1)
+  })
+
+  it('a refresh nobody asked for reads nothing even over edits a draft keeps: no restore offer follows', async () => {
+    const page = await open()
+    page.grid('self').dirtyRecords = [{}]
+    Object.defineProperty(page, 'addressEditsKept', { get: () => true })
+    const initialized = page.initialized
+    expect(await page.refresh({ ask: false })).to.equal(false)
+    expect(page.initialized).to.equal(initialized)
+
+    expect(await page.refresh()).to.equal(true)
+    expect(page.asked).to.equal(0)
+    expect(page.initialized).to.equal(initialized + 1)
+  })
+
+  it('without unsaved edits it reads like any refresh', async () => {
+    const page = await open()
+    expect(await page.refresh({ ask: false })).to.equal(true)
+    expect(page.initialized).to.equal(2)
+  })
+
+  it('on "discard" the edits are reset and the page is read', async () => {
+    const page = await open()
+    page.grid('self').dirtyRecords = [{}]
+    expect(await page.refresh()).to.equal(true)
+    expect(page.grid('self').dirtyRecords.length).to.equal(0)
+    expect(page.initialized).to.equal(2)
+  })
+
+  it('a page not on screen is read when it is next shown', async () => {
+    const page = await open()
+    page.grid('self').reads = 1
+    page.active = false
+    await page.updateComplete
+    await page.refresh()
+    expect(page.initialized).to.equal(1)
+
+    page.active = true
+    await page.updateComplete
+    await frame()
+    await frame()
+    await frame()
+    expect(page.initialized).to.equal(2)
+    expect(page.seen[page.seen.length - 1]).to.include.members(['initialized', 'active', 'params'])
+    expect(page.grid('self').reads).to.equal(2)
+  })
+})