@operato/board 10.29.8 → 10.29.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@operato/board",
-  "version": "10.29.8",
+  "version": "10.29.9",
   "description": "Webcomponent for board following open-wc recommendations",
   "author": "heartyoh",
   "type": "module",
@@ -120,18 +120,18 @@
   "dependencies": {
     "@material/web": "^2.0.0",
     "@open-wc/scoped-elements": "^2.1.3",
-    "@operato/app": "^10.29.8",
-    "@operato/data-grist": "^10.29.8",
-    "@operato/font": "^10.29.8",
+    "@operato/app": "^10.29.9",
+    "@operato/data-grist": "^10.29.9",
+    "@operato/font": "^10.29.9",
     "@operato/graphql": "^10.29.5",
     "@operato/i18n": "^10.29.1",
-    "@operato/input": "^10.29.1",
-    "@operato/layout": "^10.29.7",
-    "@operato/markdown": "^10.29.1",
-    "@operato/popup": "^10.29.1",
-    "@operato/property-editor": "^10.29.8",
-    "@operato/property-panel": "^10.29.8",
-    "@operato/styles": "^10.29.1",
+    "@operato/input": "^10.29.9",
+    "@operato/layout": "^10.29.9",
+    "@operato/markdown": "^10.29.9",
+    "@operato/popup": "^10.29.9",
+    "@operato/property-editor": "^10.29.9",
+    "@operato/property-panel": "^10.29.9",
+    "@operato/styles": "^10.29.9",
     "@operato/utils": "^10.29.1",
     "@types/file-saver": "^2.0.4",
     "@types/sortablejs": "^1.10.7",
@@ -144,7 +144,7 @@
   "devDependencies": {
     "@custom-elements-manifest/analyzer": "^0.10.0",
     "@hatiolab/prettier-config": "^1.0.0",
-    "@hatiolab/things-scene": "^10.1.61",
+    "@hatiolab/things-scene": "^10.1.74",
     "@open-wc/eslint-config": "^12.0.3",
     "@open-wc/testing": "^4.0.0",
     "@rollup/plugin-image": "^3.0.3",
@@ -180,5 +180,5 @@
       "prettier --write"
     ]
   },
-  "gitHead": "7afbba99cf2119ccb709b6cb0cff8b58d447ef88"
+  "gitHead": "24e4809ab0168eef48792291f72b11f75d8179ad"
 }

package/test/figure-provider.test.ts

@@ -2,10 +2,17 @@ import { expect } from '@open-wc/testing'
 
 import { Component, hasFigure, registerTypeResolver, resetFigures, resolveUnknownTypes } from '@hatiolab/things-scene'
 
-import { createFigureResolver } from '../src/figure-provider.js'
+import {
+  createFigureResolver,
+  FIGURE_TYPE_MAP_CHANGED,
+  figureMapReleaseOfPage,
+  resetFigureMapPage,
+  setFigureMapChoice,
+  type FigureBlueprintsAnswer
+} from '../src/figure-provider.js'
 
 /**
- * The path a published figure takes to a board (ADR-0063 결정 2).
+ * The path a figure takes to a board (ADR-0063 결정 2, ADR-0114): one batch question by full name.
  *
  * things-scene holds the seat and knows nothing about figures; this package fills it. What is
  * checked here is the part that belongs to the board: which names are asked about, what happens to
@@ -56,166 +63,169 @@ const figureAssetOf = (type: string) => ({
   }
 })
 
-const figurePayloadOf = (type: string) => ({ type, asset: figureAssetOf(type) })
-
-/** Records what was asked for, and answers from a table. */
-function fetcherOf(published: Record<string, unknown>, failing: string[] = []) {
-  const asked: string[] = []
-
+/** A server that answers from a table, from one map release, and records each question. */
+function serverOf(
+  published: Record<string, unknown>,
+  release: { version: number; revision: number } | null = { version: 1, revision: 1 },
+  refusals: Record<string, string> = {}
+) {
+  const asked: { types: string[]; map: string }[] = []
+  const state = { release }
   return {
     asked,
-    fetch: async (type: string) => {
-      asked.push(type)
-      if (failing.includes(type)) {
-        throw new Error(`no route to the door (${type})`)
-      }
-      return (published[type] ?? null) as never
+    state,
+    fetch: async (types: readonly string[], map: string): Promise<FigureBlueprintsAnswer> => {
+      asked.push({ types: [...types], map })
+      const items = types.filter(type => published[type]).map(type => ({ type, ref: `${type}@1`, asset: published[type] }))
+      const refused = types
+        .filter(type => !published[type])
+        .map(type => ({ type, code: 'figure-not-in-type-map', message: refusals[type] ?? `${type} is not in the type map` }))
+      return { release: state.release, items, refused }
     }
   }
 }
 
-describe('figure 공급자 — 보드가 발행된 Figure 를 받는 길', () => {
+const name = (label: string) => `hatiolab.com/${label}-${Math.random().toString(36).slice(2, 8)}`
+
+describe('figure 공급자 — 보드가 Figure 를 정식 이름으로 한 번에 묻는다', () => {
   afterEach(() => {
     resetFigures()
+    resetFigureMapPage()
   })
 
-  it('대문자 이름만 서버에 묻는다 — 씬의 기본 type 과 오타는 문을 지나지 않는다', async () => {
-    const { asked, fetch } = fetcherOf({ EQ_MIXER: figurePayloadOf('EQ_MIXER') })
+  it('등록되지 않은 type 을 대소문자와 관계없이 한 번에 묻는다 — 이미 등록된 것은 묻지 않는다', async () => {
+    const mixer = name('eq-mixer')
+    const { asked, fetch } = serverOf({ [mixer]: figureAssetOf(mixer) })
 
-    await createFigureResolver(fetch)(['EQ_MIXER', 'rect', 'Conveyor', 'text', 'VEH_AGV_01'])
+    await createFigureResolver(fetch)([mixer, 'rect', 'Conveyor', 'text', 'VEH_AGV_01'])
 
-    expect(asked).to.deep.equal(['EQ_MIXER', 'VEH_AGV_01'])
+    expect(asked).to.deep.equal([{ types: [mixer, 'Conveyor', 'VEH_AGV_01'], map: 'ACTIVE' }])
   })
 
-  it('이미 등록된 type 은 묻지 않는다 — 그리고 있는 컴포넌트를 figure 가 덮지 않는다', async () => {
-    const { asked, fetch } = fetcherOf({ EQ_TAKEN: figurePayloadOf('EQ_TAKEN') })
+  it('이미 등록된 이름은 묻지 않고, figure 가 그 컴포넌트를 덮지 않는다', async () => {
+    const taken = name('taken')
+    const { asked, fetch } = serverOf({ [taken]: figureAssetOf(taken) })
+    Component.register(taken, class Taken extends Component {} as never)
 
-    /* Somebody else already draws this name — a plugin, an app's own component. */
-    Component.register('EQ_TAKEN', class Taken extends Component {} as never)
-
-    await createFigureResolver(fetch)(['EQ_TAKEN'])
+    await createFigureResolver(fetch)([taken])
 
     expect(asked).to.deep.equal([])
-    expect(hasFigure('EQ_TAKEN')).to.equal(false)
+    expect(hasFigure(taken)).to.equal(false)
   })
 
-  it('받은 자산을 등록한다 — 도면은 type 만 적으면 된다', async () => {
-    const { fetch } = fetcherOf({ EQ_REGISTERED: figurePayloadOf('EQ_REGISTERED') })
+  it('받은 자산을 물은 이름으로 등록한다', async () => {
+    const conveyor = name('conveyor')
+    const { fetch } = serverOf({ [conveyor]: figureAssetOf(conveyor) })
 
-    await createFigureResolver(fetch)(['EQ_REGISTERED'])
+    await createFigureResolver(fetch)([conveyor])
 
-    expect(hasFigure('EQ_REGISTERED')).to.equal(true)
-    /* The component type is registered with it — the model writes `type` and nothing else. */
-    expect(Component.register('EQ_REGISTERED')).to.not.equal(undefined)
+    expect(hasFigure(conveyor)).to.equal(true)
+    expect(Component.register(conveyor)).to.not.equal(undefined)
   })
 
-  it('자산은 씬의 문으로 등록한다 — 보드는 그것을 읽지 않고 씬에 넘긴다', async () => {
-    const { fetch } = fetcherOf({ EQ: figurePayloadOf('EQ') })
+  it('★ 그리지 못한 이름은 서버가 준 이유를 그대로 돌려준다 — 읽을 수 없는 자산도 그 이름만 이유를 받는다', async () => {
+    const good = name('good')
+    const broken = name('broken')
+    const missing = name('missing')
+    const brokenAsset = figureAssetOf(broken)
+    brokenAsset.appearance = []
+    const { fetch } = serverOf({ [good]: figureAssetOf(good), [broken]: brokenAsset }, { version: 1, revision: 1 }, { [missing]: '타입 맵에 없습니다' })
 
-    await createFigureResolver(fetch)(['EQ'])
+    const answer = await createFigureResolver(fetch)([good, broken, missing])
 
-    expect(hasFigure('EQ')).to.equal(true)
-    /* 도면은 type 하나만 적으면 그려진다. */
-    expect(Component.register('EQ')).to.not.equal(undefined)
+    expect(hasFigure(good)).to.equal(true)
+    expect(hasFigure(broken)).to.equal(false)
+    expect(answer!.refused.map(r => r.type)).to.deep.equal([missing, broken])
+    expect(answer!.refused[0].message).to.equal('타입 맵에 없습니다')
   })
 
-  it('자산이 없는 답은 그 type 만 실패로 남는다 — 옛 청사진을 그리지 않는다', async () => {
-    const { fetch } = fetcherOf({ EQ_NEW: figurePayloadOf('EQ_NEW'), EQ_OLD: { version: 1, type: 'EQ_OLD', groups: [] } })
-
-    let message = ''
-    try {
-      await createFigureResolver(fetch)(['EQ_NEW', 'EQ_OLD'])
-    } catch (error) {
-      message = error instanceof Error ? error.message : String(error)
+  it('물을 수 없으면 거절한다 — 씬은 실패로 모으고 보드는 열린다', async () => {
+    const fetch = async () => {
+      throw new Error('no route to the door')
     }
-
-    expect(message).to.contain('not a figure asset: EQ_OLD')
-    expect(hasFigure('EQ_NEW')).to.equal(true)
-    expect(hasFigure('EQ_OLD')).to.equal(false)
-  })
-
-  it('읽을 수 없는 자산은 그 type 만 실패로 남는다', async () => {
-    const broken = figurePayloadOf('EQ_ASSET_BROKEN')
-    broken.asset.appearance = []
-    const { fetch } = fetcherOf({ EQ_BESIDE: figurePayloadOf('EQ_BESIDE'), EQ_ASSET_BROKEN: broken })
-
     let message = ''
     try {
-      await createFigureResolver(fetch)(['EQ_BESIDE', 'EQ_ASSET_BROKEN'])
+      await createFigureResolver(fetch as never)([name('x')])
     } catch (error) {
       message = error instanceof Error ? error.message : String(error)
     }
-
-    expect(message).to.contain('EQ_ASSET_BROKEN')
-    expect(hasFigure('EQ_BESIDE')).to.equal(true)
-    expect(hasFigure('EQ_ASSET_BROKEN')).to.equal(false)
+    expect(message).to.contain('no route to the door')
   })
 
-  it('발행된 것이 없으면 조용히 자리표시로 남는다 — 거절이 아니다', async () => {
-    const { fetch } = fetcherOf({})
+  it('★ 페이지는 처음 받은 맵 릴리스를 기억하고, 후보의 revision 이 바뀐 답은 등록하지 않는다', async () => {
+    const first = name('first')
+    const later = name('later')
+    const server = serverOf({ [first]: figureAssetOf(first), [later]: figureAssetOf(later) }, { version: 2, revision: 3 })
+    const resolver = createFigureResolver(server.fetch)
+    setFigureMapChoice('CANDIDATE')
+
+    await resolver([first])
+    expect(figureMapReleaseOfPage()).to.deep.equal({ map: 'CANDIDATE', version: 2, revision: 3 })
 
-    let rejected = false
+    let changed: any = null
+    const listen = (e: Event) => (changed = (e as CustomEvent).detail)
+    window.addEventListener(FIGURE_TYPE_MAP_CHANGED, listen)
     try {
-      await createFigureResolver(fetch)(['EQ_NOT_PUBLISHED'])
-    } catch {
-      rejected = true
+      server.state.release = { version: 2, revision: 4 }
+      const answer = await resolver([later])
+      expect(hasFigure(later)).to.equal(false)
+      expect(answer!.refused.map(r => r.type)).to.deep.equal([later])
+      expect(changed).to.deep.equal({ was: { map: 'CANDIDATE', version: 2, revision: 3 }, now: { map: 'CANDIDATE', version: 2, revision: 4 } })
+      expect(figureMapReleaseOfPage()).to.deep.equal({ map: 'CANDIDATE', version: 2, revision: 3 })
+    } finally {
+      window.removeEventListener(FIGURE_TYPE_MAP_CHANGED, listen)
     }
-
-    expect(rejected).to.equal(false)
-    expect(hasFigure('EQ_NOT_PUBLISHED')).to.equal(false)
   })
 
-  it('물을 수 없으면 거절한다. 그때도 답을 받은 것은 등록된다', async () => {
-    const { fetch } = fetcherOf({ EQ_BESIDE_BROKEN: figurePayloadOf('EQ_BESIDE_BROKEN') }, ['EQ_BROKEN'])
+  it('★ 활성 맵과 후보 맵의 등록을 한 페이지에서 섞지 않는다', async () => {
+    const active = name('active')
+    const preview = name('preview')
+    const server = serverOf({ [active]: figureAssetOf(active), [preview]: figureAssetOf(preview) }, { version: 1, revision: 1 })
+    const resolver = createFigureResolver(server.fetch)
 
-    let message = ''
-    try {
-      await createFigureResolver(fetch)(['EQ_BESIDE_BROKEN', 'EQ_BROKEN'])
-    } catch (error) {
-      message = error instanceof Error ? error.message : String(error)
-    }
+    await resolver([active])
+    expect(figureMapReleaseOfPage()).to.deep.equal({ map: 'ACTIVE', version: 1, revision: 1 })
+
+    setFigureMapChoice('CANDIDATE')
+    const answer = await resolver([preview])
 
-    expect(message).to.contain('EQ_BROKEN')
-    expect(message).to.not.contain('EQ_BESIDE_BROKEN')
-    expect(hasFigure('EQ_BESIDE_BROKEN')).to.equal(true)
+    expect(server.asked.map(a => a.map)).to.deep.equal(['ACTIVE', 'CANDIDATE'])
+    expect(hasFigure(preview)).to.equal(false)
+    expect(answer!.refused.map(r => r.type)).to.deep.equal([preview])
   })
 
-  it('읽을 수 없는 자산은 그 type 만 실패로 남는다 — 다른 type 을 막지 않는다', async () => {
-    const { fetch } = fetcherOf({
-      EQ_BESIDE_MALFORMED: figurePayloadOf('EQ_BESIDE_MALFORMED'),
-      EQ_MALFORMED: { type: 'EQ_MALFORMED', asset: { version: 'figure-asset-1' } }
-    })
+  it('맵 릴리스가 없는 서버(저작 서버의 최신 정책)는 기억하지 않는다', async () => {
+    const a = name('a')
+    const b = name('b')
+    const server = serverOf({ [a]: figureAssetOf(a), [b]: figureAssetOf(b) }, null)
+    const resolver = createFigureResolver(server.fetch)
 
-    let message = ''
-    try {
-      await createFigureResolver(fetch)(['EQ_BESIDE_MALFORMED', 'EQ_MALFORMED'])
-    } catch (error) {
-      message = error instanceof Error ? error.message : String(error)
-    }
+    await resolver([a])
+    await resolver([b])
 
-    expect(message).to.contain('EQ_MALFORMED')
-    expect(hasFigure('EQ_BESIDE_MALFORMED')).to.equal(true)
-    expect(hasFigure('EQ_MALFORMED')).to.equal(false)
+    expect(figureMapReleaseOfPage()).to.equal(null)
+    expect(hasFigure(a)).to.equal(true)
+    expect(hasFigure(b)).to.equal(true)
   })
 
-  it('씬의 자리에 앉아 동작한다 — 모델의 모르는 type 이 해석 뒤에 남지 않는다', async () => {
-    const { fetch } = fetcherOf({ EQ_ON_A_BOARD: figurePayloadOf('EQ_ON_A_BOARD') })
-    const takeBack = registerTypeResolver(createFigureResolver(fetch))
+  it('씬의 자리에 앉아 동작한다 — 받은 것은 그려지고 나머지는 자리표시로 남는다', async () => {
+    const onBoard = name('on-board')
+    const never = name('never')
+    const { fetch } = serverOf({ [onBoard]: figureAssetOf(onBoard) })
+    const takeBack = registerTypeResolver(createFigureResolver(fetch) as never)
 
     try {
       const model = {
         type: 'container',
         components: [
-          { type: 'EQ_ON_A_BOARD', left: 0, top: 0, width: 100, height: 100 },
-          { type: 'EQ_NEVER_PUBLISHED', left: 0, top: 0, width: 100, height: 100 }
+          { type: onBoard, left: 0, top: 0, width: 100, height: 100 },
+          { type: never, left: 0, top: 0, width: 100, height: 100 }
         ]
       }
-
       const resolution = await resolveUnknownTypes(model)
-
-      expect(resolution.unresolved).to.deep.equal(['EQ_NEVER_PUBLISHED'])
+      expect(resolution.unresolved).to.deep.equal([never])
       expect(resolution.failed).to.deep.equal([])
-      expect(hasFigure('EQ_ON_A_BOARD')).to.equal(true)
+      expect(hasFigure(onBoard)).to.equal(true)
     } finally {
       takeBack()
     }

package/translations/en.json

@@ -36,5 +36,6 @@
   "label.list": "list",
   "label.visibility-domain": "public in group",
   "label.visibility-private": "private",
-  "label.visibility-public": "public"
+  "label.visibility-public": "public",
+  "text.figure-type-map-changed": "the type map changed. reopen to draw it."
 }

package/translations/ja.json

@@ -36,5 +36,6 @@
   "label.list": "一覧",
   "label.visibility-domain": "グループ内公開",
   "label.visibility-private": "プライベート",
-  "label.visibility-public": "公開"
+  "label.visibility-public": "公開",
+  "text.figure-type-map-changed": "タイプマップが変わりました。開き直すと描画されます。"
 }

package/translations/ko.json

@@ -36,5 +36,6 @@
   "label.list": "목록",
   "label.visibility-domain": "그룹내 공개",
   "label.visibility-private": "비공개",
-  "label.visibility-public": "공개"
+  "label.visibility-public": "공개",
+  "text.figure-type-map-changed": "타입 맵이 바뀌었습니다. 다시 열면 그려집니다."
 }