@things-factory/figure-ui 10.1.149 → 10.1.151

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-ui",
-  "version": "10.1.149",
+  "version": "10.1.151",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -18,7 +18,7 @@
   "scripts": {
     "build": "npm run build:server && npm run build:client",
     "test": "FIGURE_FREEZE_COMPILED=1 node --import ./test/resolve-ts-siblings.mjs --test test/*.test.ts",
-    "test:browser": "node --test test/browser/modeller.check.mjs test/browser/modeller-revision.check.mjs test/browser/editing.check.mjs test/browser/links.check.mjs test/browser/section.check.mjs test/browser/screen.check.mjs test/browser/product-page.check.mjs test/browser/parts.check.mjs test/browser/places-mesh.check.mjs",
+    "test:browser": "node --test test/browser/build.check.mjs test/browser/modeller.check.mjs test/browser/modeller-revision.check.mjs test/browser/editing.check.mjs test/browser/links.check.mjs test/browser/section.check.mjs test/browser/screen.check.mjs test/browser/product-page.check.mjs test/browser/parts.check.mjs test/browser/places-mesh.check.mjs test/browser/part-ids.check.mjs",
     "copy:files": "copyfiles -e \"./client/**/*.{ts,js,json}\" -u 1 \"./client/**/*\" dist-client",
     "build:client": "npm run copy:files && npx tsc --p ./client/tsconfig.json",
     "build:server": "npx tsc --p ./server/tsconfig.json",
@@ -27,8 +27,8 @@
     "clean": "npm run clean:server && npm run clean:client"
   },
   "dependencies": {
-    "@hatiolab/figure-model": "^0.5.2",
-    "@hatiolab/things-scene": "^10.1.82",
+    "@hatiolab/figure-model": "^0.6.0",
+    "@hatiolab/things-scene": "^10.1.83",
     "@material/web": "^2.0.0",
     "@operato/data-grist": "^10.0.0",
     "@operato/graphql": "^10.0.0",
@@ -41,9 +41,9 @@
     "@operato/slot-layout-editor": "^10.29.25",
     "@operato/styles": "^10.0.0",
     "@operato/utils": "^10.0.0",
-    "@things-factory/ai-assistant": "^10.1.149",
-    "@things-factory/figure-service": "^10.1.149",
+    "@things-factory/ai-assistant": "^10.1.150",
+    "@things-factory/figure-service": "^10.1.151",
     "three": "^0.185.1"
   },
-  "gitHead": "816f88a9fa6110935a3f71740458db8f7469d2e3"
+  "gitHead": "495d06ef9ecf4d19fc9bf45ebc3cff4fdfefca53"
 }

package/test/browser/build.check.mjs

@@ -0,0 +1,77 @@
+/*
+ * Two runs building the same page at the same time, as two sessions on one machine do: each builds in a folder of its
+ * own, neither takes away the other's page, and each folder goes when its process ends -- by itself or stopped.
+ *
+ * Run:  node --test test/browser/build.check.mjs
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { spawn } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { dirname } from 'node:path'
+
+const BUILD = new URL('./build.mjs', import.meta.url).href
+
+/* A run: builds the page, says where and what it built, and when asked says whether its page is still as it built it. */
+const RUN = `
+import { buildPage } from ${JSON.stringify(BUILD)}
+import { readFileSync, existsSync } from 'node:fs'
+import { createHash } from 'node:crypto'
+const hash = file => (existsSync(file) ? createHash('sha1').update(readFileSync(file)).digest('hex') : null)
+const file = await buildPage('modeller-page.js')
+const built = hash(file)
+console.log(JSON.stringify({ file }))
+process.stdin.on('data', () => console.log(JSON.stringify({ intact: hash(file) === built })))
+`
+
+/** Starts a run; `next()` gives the next line it says, as JSON. */
+function start() {
+  const child = spawn(process.execPath, ['--input-type=module', '-e', RUN], { stdio: ['pipe', 'pipe', 'inherit'] })
+  const lines = []
+  const waiting = []
+  let rest = ''
+  child.stdout.on('data', chunk => {
+    rest += chunk
+    for (let at = rest.indexOf('\n'); at >= 0; at = rest.indexOf('\n')) {
+      const line = rest.slice(0, at)
+      rest = rest.slice(at + 1)
+      if (!line.startsWith('{')) continue
+      const said = JSON.parse(line)
+      waiting.length ? waiting.shift()(said) : lines.push(said)
+    }
+  })
+  const ended = new Promise(done => child.on('exit', done))
+  /* A run that ends before it says what was asked has failed -- its build did not finish: said at once, not waited out. */
+  const quit = ended.then(code => {
+    throw Error(`the run ended (${code}) before it said what was asked`)
+  })
+  quit.catch(() => {})
+  return {
+    child,
+    ended,
+    next: () => (lines.length ? Promise.resolve(lines.shift()) : Promise.race([new Promise(done => waiting.push(done)), quit]))
+  }
+}
+
+test('two runs at once build in folders of their own, keep each other\'s page, and take their folder with them', { timeout: 300000 }, async t => {
+  const a = start()
+  const b = start()
+  /* Whatever fails below, no run is left waiting: a run left behind keeps this file from ending. */
+  t.after(() => {
+    for (const run of [a, b]) if (run.child.exitCode === null && run.child.signalCode === null) run.child.kill('SIGKILL')
+  })
+  const [builtA, builtB] = await Promise.all([a.next(), b.next()])
+  assert.notEqual(dirname(builtA.file), dirname(builtB.file), 'each run builds in a folder of its own')
+
+  /* Both have built: each page is still the one its run built, whichever finished last. */
+  a.child.stdin.write('\n')
+  b.child.stdin.write('\n')
+  assert.deepEqual(await Promise.all([a.next(), b.next()]), [{ intact: true }, { intact: true }])
+
+  /* One ends by itself, the other is stopped: neither leaves its folder behind. */
+  a.child.stdin.end()
+  b.child.kill('SIGTERM')
+  await Promise.all([a.ended, b.ended])
+  assert.equal(existsSync(dirname(builtA.file)), false, 'the folder of the run that ended')
+  assert.equal(existsSync(dirname(builtB.file)), false, 'the folder of the run that was stopped')
+})

package/test/browser/build.mjs

@@ -7,7 +7,7 @@
  * (its browser bundle, `things-scene.mjs`).
  */
 import { execFileSync } from 'node:child_process'
-import { mkdirSync, rmSync, existsSync } from 'node:fs'
+import { mkdtempSync, rmSync, existsSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { dirname, join, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
@@ -20,15 +20,30 @@ const HERE = dirname(fileURLToPath(import.meta.url))
 const PACKAGE = resolve(HERE, '../..')
 const ROOT = resolve(PACKAGE, '../..')
 
+/*
+ * Each build is made in a folder of its own and taken away when the process ends. A folder named by the page alone was
+ * removed and written again by every build of that page, so runs at the same time on one machine (sessions side by
+ * side, a server beside a check) could take away each other's page while it was being built or served.
+ */
+const made = []
+const takeAway = () => {
+  for (const dir of made.splice(0)) rmSync(dir, { recursive: true, force: true })
+}
+process.on('exit', takeAway)
+for (const signal of ['SIGINT', 'SIGTERM'])
+  process.once(signal, () => {
+    takeAway()
+    process.kill(process.pid, signal)
+  })
+
 /*
  * `standIns` maps a module the page would import to a file beside this one: for a module that cannot run here (the
  * assistant dock needs the whole app's tool bar), a stand-in that records what the product asked of it.
  */
 export async function buildPage(page = 'modeller-page.js', { standIns = {} } = {}) {
-  const out = join(tmpdir(), 'figure-ui-browser-' + page.replace(/\W+/g, '-'))
+  const out = mkdtempSync(join(tmpdir(), 'figure-ui-browser-' + page.replace(/\W+/g, '-') + '-'))
+  made.push(out)
   const emitted = join(out, 'client')
-  rmSync(out, { recursive: true, force: true })
-  mkdirSync(out, { recursive: true })
 
   /* Types are the unit suite's and tsc's business; here only what runs. */
   execFileSync(join(ROOT, 'node_modules/.bin/tsc'), ['-p', join(PACKAGE, 'client/tsconfig.json'), '--outDir', emitted, '--noCheck', '--declaration', 'false', '--incremental', 'false'], {
@@ -80,4 +95,9 @@ export async function buildPage(page = 'modeller-page.js', { standIns = {} } = {
   return file
 }
 
-if (process.argv[1] === fileURLToPath(import.meta.url)) console.log(await buildPage())
+/* Run on its own it prints where the page is, and leaves it there for whoever asked. */
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  const file = await buildPage()
+  made.length = 0
+  console.log(file)
+}

package/test/browser/part-ids.check.mjs

@@ -0,0 +1,86 @@
+/*
+ * A new part's id, in a real browser, on a figure with a row: the palette's box, a copy from the parts list. A row's
+ * copies are drawn under ids of their own; the part made into the row still holds its id, and the next part is not
+ * offered it (on :3300, 2026-10-11, a box added after a row was refused with DUPLICATE_PART).
+ *
+ * Run:  node --test test/browser/part-ids.check.mjs
+ */
+import { test, describe, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { addFigureBox, applyFigureAuthoring, createFigureAsset, serializeFigureAsset } from '@hatiolab/figure-model'
+
+import { buildPage } from './build.mjs'
+import { openPage } from './serve.mjs'
+
+const sleep = ms => new Promise(done => setTimeout(done, ms))
+
+let opened
+before(async () => {
+  opened = await openPage(await buildPage('places-mesh-page.js'))
+})
+after(async () => {
+  await opened?.close()
+})
+
+const page = () => opened.page
+const read = (fn, ...args) => page().evaluate(fn, ...args)
+const state = () => read(() => probe.state())
+/** The parts as authored, one per part as the parts list shows them. */
+const parts = () => read(() => probe.source().appearance.map(look => look.target))
+
+async function until(fn, args, what, ms = 8000) {
+  const deadline = Date.now() + ms
+  for (;;) {
+    if (await read(fn, ...args)) return
+    if (Date.now() > deadline) assert.fail(`waited for ${what}`)
+    await sleep(50)
+  }
+}
+const settled = () => read(() => document.querySelector('figure-editor').updateComplete)
+async function click(selector, options = {}, what = selector) {
+  const element = await page().evaluateHandle((s, o) => findDeep(s, o), selector, options)
+  assert.ok(await element.evaluate(e => !!e), `${what} is on the page`)
+  await element.evaluate(e => e.scrollIntoView({ block: 'center' }))
+  await element.click()
+  await settled()
+}
+
+/* box-1 on the floor, box-2 on it made into a row 300 apart: box-2's id is drawn nowhere as it is. */
+function rowed() {
+  let a = addFigureBox(createFigureAsset('Rowed'), { id: 'box-1', size: { x: 1000, y: 100, z: 400 }, position: { x: 0, y: 50, z: 0 } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'box-1', face: 'bottom', to: { plane: 'mounting-plane' } })
+  a = addFigureBox(a, { id: 'box-2', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 150, z: 0 } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'box-2', face: 'bottom', to: { part: 'box-1', face: 'top' } })
+  return applyFigureAuthoring(a, { kind: 'make-repeat', part: 'box-2', axis: 'x', pitch: 300 })
+}
+
+describe('a new part on a figure with a row takes an id no part holds', () => {
+  before(async () => {
+    await read(text => harness.mount('given', text), serializeFigureAsset(rowed()))
+    await until(() => look.drawn().length > 0, [], 'the board is drawn')
+    assert.equal((await read(() => probe.ids())).includes('box-2'), false, 'the row is drawn under its copies\' ids')
+  })
+
+  test('a box from the palette: added as box-3, one step, selected', async () => {
+    const start = await state()
+    await click('button[shape]', { has: 'figure.label.primitive-cube' }, 'the palette\'s box')
+    await until(() => probe.state().selected === 'box-3', [], 'box-3 selected')
+    const after = await state()
+    assert.equal(after.error, '')
+    assert.equal(after.revision, start.revision + 1)
+    assert.deepEqual(await parts(), ['box-1', 'box-2', 'box-3'])
+  })
+
+  test('the row\'s part copied from the list: the copy is a part, and it is what is selected', async () => {
+    const at = await read(() => probe.row('box-2'))
+    await page().mouse.click(at.x, at.y)
+    await until(() => probe.state().selected === 'box-2', [], 'box-2 selected')
+    const before = await parts()
+    await click('button[op="duplicate-part"]')
+    await until(n => probe.source().appearance.length === n, [before.length + 1], 'the copy')
+    const copy = (await parts()).find(id => !before.includes(id))
+    assert.equal((await state()).selected, copy)
+    assert.equal((await state()).error, '')
+  })
+})