@operato/shell 10.29.1 → 10.29.5

package/package.json

@@ -2,7 +2,7 @@
   "name": "@operato/shell",
   "description": "WebApplication architecturing shell following open-wc recommendations",
   "author": "heartyoh",
-  "version": "10.29.1",
+  "version": "10.29.5",
   "type": "module",
   "main": "dist/src/index.js",
   "module": "dist/src/index.js",
@@ -60,7 +60,8 @@
   },
   "dependencies": {
     "@material/web": "^2.0.0",
-    "@operato/graphql": "^10.29.1",
+    "@operato/graphql": "^10.29.5",
+    "@operato/i18n": "^10.29.1",
     "@operato/popup": "^10.29.1",
     "@operato/styles": "^10.29.1",
     "@operato/utils": "^10.29.1",
@@ -102,5 +103,5 @@
       "prettier --write"
     ]
   },
-  "gitHead": "1ae246813b79645ee00b600bd7f631bacf1a9213"
+  "gitHead": "0995f71d6a9678da116781ec38ae80a253ab8b3e"
 }

package/test/drafts.test.ts

@@ -0,0 +1,153 @@
+import { expect } from '@open-wc/testing'
+import { OxPrompt } from '@operato/popup'
+
+import {
+  draftDecision,
+  draftKey,
+  readDraft,
+  removeDraftsOf,
+  writeDraft,
+  DRAFT_LIFETIME_MS,
+  UnsavedDraftController,
+  type DraftAddress
+} from '../src/index.js'
+
+/**
+ * Unsaved edits kept as drafts (design/ui/unsaved-drafts.md, architect ruling 2026-09-27): the edit is
+ * written as it happens and offered back when the screen opens, so nothing has to ask at reload.
+ */
+
+const at = (target: string, user = 'u1'): DraftAddress => ({ user, domain: 'd', screen: 'test-modeller', target })
+
+class Host {
+  controllers: any[] = []
+  addController(c: any) {
+    this.controllers.push(c)
+  }
+  removeController() {}
+  requestUpdate() {}
+  updateComplete = Promise.resolve(true)
+  connect() {
+    this.controllers.forEach(c => c.hostConnected?.())
+  }
+  disconnect() {
+    this.controllers.forEach(c => c.hostDisconnected?.())
+  }
+}
+
+describe('draft decision', () => {
+  const now = 1_000_000_000_000
+
+  it('★ a draft whose base is the saved copy now is offered', () => {
+    expect(draftDecision({ at: now - 60_000, base: 7 }, 7, now)).to.equal('offer')
+    expect(draftDecision({ at: now - 60_000, base: null }, null, now)).to.equal('offer')
+  })
+
+  it('★ saved again since the draft began: offered, and the save will report the conflict', () => {
+    expect(draftDecision({ at: now - 60_000, base: 7 }, 8, now)).to.equal('offer-behind')
+    expect(draftDecision({ at: now - 60_000, base: null }, 1, now)).to.equal('offer-behind')
+  })
+
+  it('★ older than seven days is dropped without asking', () => {
+    expect(draftDecision({ at: now - DRAFT_LIFETIME_MS - 1, base: 7 }, 7, now)).to.equal('drop')
+  })
+
+  it('a key never lets one user read another\'s draft, and survives odd names', () => {
+    expect(draftKey(at('x', 'u1'))).to.not.equal(draftKey(at('x', 'u2')))
+    expect(draftKey({ user: 'a/b', domain: 'd', screen: 's', target: 't' })).to.not.equal(
+      draftKey({ user: 'a', domain: 'b/d', screen: 's', target: 't' })
+    )
+  })
+})
+
+describe('draft store', () => {
+  it('★ what is written is read back', async () => {
+    const key = draftKey(at('round-trip'))
+    await writeDraft({ key, value: { parts: 3 }, base: 7, at: 123 })
+    const read = await readDraft<{ parts: number }>(key)
+    expect(read?.value.parts).to.equal(3)
+    expect(read?.base).to.equal(7)
+  })
+
+  it('★ sign-out takes one user\'s drafts, and only theirs', async () => {
+    await writeDraft({ key: draftKey(at('a', 'leaving')), value: 1, base: null, at: 1 })
+    await writeDraft({ key: draftKey(at('b', 'leaving')), value: 2, base: null, at: 1 })
+    await writeDraft({ key: draftKey(at('a', 'staying')), value: 3, base: null, at: 1 })
+
+    await removeDraftsOf('leaving')
+
+    expect(await readDraft(draftKey(at('a', 'leaving')))).to.equal(undefined)
+    expect(await readDraft(draftKey(at('b', 'leaving')))).to.equal(undefined)
+    expect((await readDraft(draftKey(at('a', 'staying'))))?.value).to.equal(3)
+  })
+})
+
+describe('UnsavedDraftController', () => {
+  const originalOpen = OxPrompt.open
+  afterEach(() => ((OxPrompt as any).open = originalOpen))
+
+  function screen(target: string, state: { value?: number; base: number | null; saved: number | null }) {
+    const host = new Host()
+    const restored: any[] = []
+    const controller = new UnsavedDraftController<number>(host as any, {
+      address: () => at(target),
+      snapshot: () => (state.value == null ? undefined : { value: state.value, base: state.base }),
+      savedRevision: () => state.saved,
+      restore: (value, base) => restored.push({ value, base })
+    })
+    host.connect()
+    return { host, controller, restored }
+  }
+
+  it('★ an edit is written; reopening offers it and puts it back with its base', async () => {
+    const first = screen('reopen', { value: 42, base: 5, saved: 5 })
+    first.controller.changed()
+    await first.controller.flush()
+    first.host.disconnect()
+
+    let asked = ''
+    ;(OxPrompt as any).open = async (options: any) => ((asked = options.text), true)
+    const again = screen('reopen', { base: 5, saved: 5 })
+    expect(await again.controller.offer()).to.equal(true)
+    expect(again.restored).to.deep.equal([{ value: 42, base: 5 }])
+    expect(asked).to.not.contain('conflict')
+  })
+
+  it('★ saved again elsewhere: the question says the save will report the conflict', async () => {
+    const first = screen('behind', { value: 1, base: 5, saved: 5 })
+    await first.controller.flush()
+
+    let asked = ''
+    ;(OxPrompt as any).open = async (options: any) => ((asked = options.text), true)
+    const again = screen('behind', { base: 6, saved: 6 })
+    await again.controller.offer()
+    expect(asked).to.contain('conflict')
+    expect(again.restored[0].base).to.equal(5)
+  })
+
+  it('★ discard removes it; saving removes it', async () => {
+    ;(OxPrompt as any).open = async () => false
+    const a = screen('discard', { value: 1, base: null, saved: null })
+    await a.controller.flush()
+    expect(await a.controller.offer()).to.equal(false)
+    expect(await readDraft(draftKey(at('discard')))).to.equal(undefined)
+
+    const b = screen('saved', { value: 1, base: null, saved: null })
+    await b.controller.flush()
+    await b.controller.settled()
+    expect(await readDraft(draftKey(at('saved')))).to.equal(undefined)
+  })
+
+  it('★ where drafts cannot be kept, the browser\'s own question comes back while something is unsaved', async () => {
+    const { controller } = screen('fallback', { value: 1, base: null, saved: null })
+    ;(controller as any).cannotKeep = true
+    const event = new Event('beforeunload', { cancelable: true })
+    window.dispatchEvent(event)
+    expect(event.defaultPrevented).to.equal(true)
+
+    ;(controller as any).cannotKeep = false
+    const kept = new Event('beforeunload', { cancelable: true })
+    window.dispatchEvent(kept)
+    expect(kept.defaultPrevented).to.equal(false)
+  })
+})