@operato/board 10.17.0 → 10.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@operato/board",
-  "version": "10.17.0",
+  "version": "10.19.0",
   "description": "Webcomponent for board following open-wc recommendations",
   "author": "heartyoh",
   "type": "module",
@@ -120,17 +120,17 @@
   "dependencies": {
     "@material/web": "^2.0.0",
     "@open-wc/scoped-elements": "^2.1.3",
-    "@operato/app": "^10.17.0",
-    "@operato/data-grist": "^10.17.0",
-    "@operato/font": "^10.17.0",
+    "@operato/app": "^10.19.0",
+    "@operato/data-grist": "^10.19.0",
+    "@operato/font": "^10.19.0",
     "@operato/graphql": "^10.16.2",
     "@operato/i18n": "^10.16.2",
     "@operato/input": "^10.16.2",
     "@operato/layout": "^10.16.2",
     "@operato/markdown": "^10.16.2",
     "@operato/popup": "^10.16.2",
-    "@operato/property-editor": "^10.17.0",
-    "@operato/property-panel": "^10.17.0",
+    "@operato/property-editor": "^10.19.0",
+    "@operato/property-panel": "^10.19.0",
     "@operato/styles": "^10.16.2",
     "@operato/utils": "^10.16.2",
     "@types/file-saver": "^2.0.4",
@@ -180,5 +180,5 @@
       "prettier --write"
     ]
   },
-  "gitHead": "f5851c0f8ea672b5369951395f2413cd4939ede9"
+  "gitHead": "58bdb75a1b1f0c28936d44829e1cf7199de3c617"
 }

package/test/figure-provider.test.ts

@@ -0,0 +1,163 @@
+import { expect } from '@open-wc/testing'
+
+import { Component, hasFigure, registerTypeResolver, resetFigures, resolveUnknownTypes } from '@hatiolab/things-scene'
+
+import { createFigureResolver } from '../src/figure-provider.js'
+
+/**
+ * The path a published figure takes to a board (ADR-0063 결정 2).
+ *
+ * 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
+ * the answer, and how "nobody published this" stays apart from "could not ask".
+ *
+ * The blueprint below is the shape figure-model emits — `registerFigure` rejects anything it cannot
+ * read, so a fixture that drifts fails loudly here instead of drawing nothing at runtime.
+ */
+
+const BLUEPRINT_VERSION = 1
+
+const blueprintOf = (type: string) => ({
+  version: BLUEPRINT_VERSION,
+  type,
+  base: { x: 100, y: 100, z: 100 },
+  groups: [
+    {
+      materialKey: 'palette.dark|metal|f|-|-|-',
+      material: { token: 'palette.dark', preset: 'metal', flatShading: true },
+      animated: false,
+      members: [
+        {
+          name: 'body',
+          primitive: 'cube',
+          geometryKey: 'cube|100x100x100',
+          transform: { position: { x: 0, y: 0, z: 0 }, size: { x: 100, y: 100, z: 100 } },
+          sizing: 'scale',
+          triangles: 12
+        }
+      ]
+    }
+  ]
+})
+
+/** Records what was asked for, and answers from a table. */
+function fetcherOf(published: Record<string, unknown>, failing: string[] = []) {
+  const asked: string[] = []
+
+  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
+    }
+  }
+}
+
+describe('figure 공급자 — 보드가 발행된 Figure 를 받는 길', () => {
+  afterEach(() => {
+    resetFigures()
+  })
+
+  it('대문자 이름만 서버에 묻는다 — 씬의 기본 type 과 오타는 문을 지나지 않는다', async () => {
+    const { asked, fetch } = fetcherOf({ EQ_MIXER: blueprintOf('EQ_MIXER') })
+
+    await createFigureResolver(fetch)(['EQ_MIXER', 'rect', 'Conveyor', 'text', 'VEH_AGV_01'])
+
+    expect(asked).to.deep.equal(['EQ_MIXER', 'VEH_AGV_01'])
+  })
+
+  it('이미 등록된 type 은 묻지 않는다 — 그리고 있는 컴포넌트를 figure 가 덮지 않는다', async () => {
+    const { asked, fetch } = fetcherOf({ EQ_TAKEN: blueprintOf('EQ_TAKEN') })
+
+    /* 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'])
+
+    expect(asked).to.deep.equal([])
+    expect(hasFigure('EQ_TAKEN')).to.equal(false)
+  })
+
+  it('받은 청사진을 등록한다 — 도면은 type 만 적으면 된다', async () => {
+    const { fetch } = fetcherOf({ EQ_REGISTERED: blueprintOf('EQ_REGISTERED') })
+
+    await createFigureResolver(fetch)(['EQ_REGISTERED'])
+
+    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)
+  })
+
+  it('발행된 것이 없으면 조용히 자리표시로 남는다 — 거절이 아니다', async () => {
+    const { fetch } = fetcherOf({})
+
+    let rejected = false
+    try {
+      await createFigureResolver(fetch)(['EQ_NOT_PUBLISHED'])
+    } catch {
+      rejected = true
+    }
+
+    expect(rejected).to.equal(false)
+    expect(hasFigure('EQ_NOT_PUBLISHED')).to.equal(false)
+  })
+
+  it('물을 수 없으면 거절한다. 그때도 답을 받은 것은 등록된다', async () => {
+    const { fetch } = fetcherOf({ EQ_BESIDE_BROKEN: blueprintOf('EQ_BESIDE_BROKEN') }, ['EQ_BROKEN'])
+
+    let message = ''
+    try {
+      await createFigureResolver(fetch)(['EQ_BESIDE_BROKEN', 'EQ_BROKEN'])
+    } catch (error) {
+      message = error instanceof Error ? error.message : String(error)
+    }
+
+    expect(message).to.contain('EQ_BROKEN')
+    expect(message).to.not.contain('EQ_BESIDE_BROKEN')
+    expect(hasFigure('EQ_BESIDE_BROKEN')).to.equal(true)
+  })
+
+  it('읽을 수 없는 청사진은 그 type 만 실패로 남는다 — 다른 type 을 막지 않는다', async () => {
+    const { fetch } = fetcherOf({
+      EQ_BESIDE_MALFORMED: blueprintOf('EQ_BESIDE_MALFORMED'),
+      EQ_MALFORMED: { version: BLUEPRINT_VERSION, type: 'EQ_MALFORMED' }
+    })
+
+    let message = ''
+    try {
+      await createFigureResolver(fetch)(['EQ_BESIDE_MALFORMED', 'EQ_MALFORMED'])
+    } catch (error) {
+      message = error instanceof Error ? error.message : String(error)
+    }
+
+    expect(message).to.contain('EQ_MALFORMED')
+    expect(hasFigure('EQ_BESIDE_MALFORMED')).to.equal(true)
+    expect(hasFigure('EQ_MALFORMED')).to.equal(false)
+  })
+
+  it('씬의 자리에 앉아 동작한다 — 모델의 모르는 type 이 해석 뒤에 남지 않는다', async () => {
+    const { fetch } = fetcherOf({ EQ_ON_A_BOARD: blueprintOf('EQ_ON_A_BOARD') })
+    const takeBack = registerTypeResolver(createFigureResolver(fetch))
+
+    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 }
+        ]
+      }
+
+      const resolution = await resolveUnknownTypes(model)
+
+      expect(resolution.unresolved).to.deep.equal(['EQ_NEVER_PUBLISHED'])
+      expect(resolution.failed).to.deep.equal([])
+      expect(hasFigure('EQ_ON_A_BOARD')).to.equal(true)
+    } finally {
+      takeBack()
+    }
+  })
+})

package/test/resolved-scene.test.ts

@@ -0,0 +1,114 @@
+import { expect, fixture, html } from '@open-wc/testing'
+import type { LitElement } from 'lit'
+import { executeServerCommand } from '@web/test-runner-commands'
+
+import { registerTypeResolver, resetFigures } from '@hatiolab/things-scene'
+
+import { createResolvedScene } from '../src/resolved-scene.js'
+import '../src/ox-board-preview.js'
+
+/**
+ * The one door a model goes through to become a scene (ADR-0063 결정 2).
+ *
+ * Three things are counted here, and each of them is something that goes wrong quietly otherwise:
+ * a scene built somewhere else never resolves its types, a board of ordinary components pays for a
+ * server round trip it does not need, and a scene that was waiting lands on a viewer that has
+ * already moved on.
+ */
+
+const KNOWN_MODEL = {
+  type: 'container',
+  components: [{ type: 'rect', left: 0, top: 0, width: 100, height: 100 }]
+}
+
+const modelWith = (types: string[]) => ({
+  type: 'container',
+  components: types.map((type, index) => ({ type, left: index * 10, top: 0, width: 100, height: 100 }))
+})
+
+describe('씬을 만드는 문은 하나다', () => {
+  it('things-scene 의 create 를 읽는 파일은 resolved-scene.ts 하나뿐이다', async () => {
+    /*
+     * 세는 범위는 이 꾸러미와 `@operato/process` 다 — 문은 여기 있고 그 꾸러미가 둘째 소비자다.
+     * 이 꾸러미만 보던 규칙은 옆에 씬 둘이 서 있는 동안 「문은 하나」라고 답하고 있었다.
+     */
+    const files = await executeServerCommand<unknown, string[]>('files-importing-scene-create')
+
+    expect(files).to.deep.equal(['src/resolved-scene.ts'])
+  })
+})
+
+describe('모르는 type 이 없으면 아무에게도 묻지 않는다', () => {
+  let asked: string[][]
+  let takeBack: () => void
+
+  beforeEach(() => {
+    asked = []
+    takeBack = registerTypeResolver(async types => {
+      asked.push([...types])
+    })
+  })
+
+  afterEach(() => {
+    takeBack()
+    resetFigures()
+  })
+
+  it('씬의 기본 type 만 있는 보드는 공급자를 부르지 않는다', async () => {
+    const scene = await createResolvedScene({ model: KNOWN_MODEL })
+
+    expect(asked).to.deep.equal([])
+    expect(scene).to.not.equal(null)
+
+    scene?.release?.()
+  })
+
+  it('모르는 type 이 있을 때만 부른다', async () => {
+    const scene = await createResolvedScene({ model: modelWith(['rect', 'EQ_ASKED_ABOUT']) })
+
+    expect(asked).to.deep.equal([['EQ_ASKED_ABOUT']])
+
+    scene?.release?.()
+  })
+})
+
+describe('기다리는 동안 화면이 바뀌면 늦게 온 씬은 들어서지 않는다', () => {
+  let takeBack: () => void
+
+  afterEach(() => {
+    takeBack?.()
+    resetFigures()
+  })
+
+  it('앞의 모델을 풀고 돌아왔을 때 미리보기가 다른 모델을 들고 있으면 그 씬은 버린다', async () => {
+    /* The first model's type resolves slowly; the second one has nothing to resolve. */
+    let releaseFirst: () => void = () => {}
+    const firstResolved = new Promise<void>(resolve => {
+      releaseFirst = resolve
+    })
+
+    takeBack = registerTypeResolver(async types => {
+      if (types.includes('EQ_SLOW')) {
+        await firstResolved
+      }
+    })
+
+    const element = (await fixture(html`<ox-board-preview></ox-board-preview>`)) as LitElement & {
+      boardModel: unknown
+      _scene: { root: { components: unknown[] } } | null
+    }
+
+    element.boardModel = modelWith(['EQ_SLOW'])
+    await element.updateComplete
+
+    /* The second model arrives while the first one is still waiting on its type. */
+    element.boardModel = modelWith(['rect', 'rect'])
+    await element.updateComplete
+
+    releaseFirst()
+    await new Promise(resolve => setTimeout(resolve, 0))
+
+    expect(element._scene).to.not.equal(null)
+    expect(element._scene!.root.components.length).to.equal(2)
+  })
+})