Back to Nappakura
SOURCE / PINNED RELEASE

Made of little things.

Nappakura

Release
a75ca0f8b596…
Author-recorded commit
4463126213fa…
License
LICENSE
Author’s source reference
nostr://npub182jczunncwe0jn6frpqwq3e0qjws7yqqnc3auccqv9nte2dnd63scjm4rf/wss%3A%2F%2Fgit.napplet.soy%2F/n-8db03001b62

Archive hash verified: b448d77b767ae754…. The source-to-build association is the author’s claim; it has not been independently rebuilt.

tests/gizmo-browser.mjs
import assert from 'node:assert/strict';
import { realpath, mkdir } from 'node:fs/promises';
import { createRequire } from 'node:module';
const require = createRequire(
  await realpath(new URL('../node_modules/@napplet/conformance-cli/package.json', import.meta.url)),
);
const { chromium } = require('playwright');
const browser = await chromium.launch({ headless: true });
try {
  const page = await browser.newPage({ viewport: { width: 1800, height: 1100 } });
  page.setDefaultTimeout(15000);
  const errors = [];
  page.on('pageerror', (e) => errors.push(e.message));
  await page.goto(process.env.NAPPLET_PREVIEW_URL);
  const f = page.frameLocator('iframe');
  await f.locator('#modelName').waitFor();
  await f.getByRole('button', { name: '+ Primitive', exact: true }).click();
  await f.locator('#model-kind').selectOption('box');
  await f.locator('#modelApply').click();
  const inspect = async () => {
    await page.getByRole('button', { name: 'Agent tools', exact: true }).click();
    const detail = page.getByText(/tools · inspect and try a call/);
    if (!(await page.getByLabel('Agent tool', { exact: true }).isVisible())) await detail.click();
    await page.getByLabel('Allow shell tool access for this document', { exact: true }).check();
    await page
      .getByLabel('Agent tool', { exact: true })
      .selectOption({ label: 'inspect_document' });
    await page.getByLabel('Tool arguments', { exact: true }).fill('{"includeGeometry":true}');
    await page.getByRole('button', { name: 'Run tool', exact: true }).click();
    const r = page.getByLabel('Tool result', { exact: true });
    await r.filter({ hasNotText: 'Running…' }).waitFor();
    const doc = JSON.parse(await r.innerText());
    await page.getByLabel('Close agent tools', { exact: true }).click();
    return doc;
  };
  let doc = await inspect();
  await f.locator('#modelElements').selectOption(doc.polygonIds);
  const cy = Math.cos(-0.55),
    sy = Math.sin(-0.55),
    cp = Math.cos(0.28),
    sp = Math.sin(0.28);
  const project = (v) => [v[0] * cy + v[2] * sy, -(v[1] * cp - (-v[0] * sy + v[2] * cy) * sp)];
  const basis = [
    [1, 0, 0],
    [0, 1, 0],
    [0, 0, 1],
  ].map(project);
  const origin = async () => {
    const b = await f.locator('#modelCanvas').boundingBox();
    return [b.x + b.width / 2, b.y + b.height / 2];
  };
  const at = (o, v, n) => [o[0] + v[0] * n, o[1] + v[1] * n];
  const drag = async (a, b, cancel = false) => {
    await page.mouse.move(...a);
    await page.mouse.down();
    await page.mouse.move(...b, { steps: 8 });
    if (cancel) await page.keyboard.press('Escape');
    await page.mouse.up();
    await page.waitForTimeout(150);
  };
  // An entire box stays planar, and each drag creates one revision, never one per move.
  let o = await origin(),
    revision = doc.revision;
  await drag(at(o, basis[0], 70), at(o, basis[0], 90));
  doc = await inspect();
  assert.equal(doc.revision, revision + 1);
  const xMoved = doc.geometry.vertices[0].point[0];
  assert.ok(xMoved > -20);
  assert.equal(doc.geometry.vertices[0].point[1], -20);
  assert.equal(doc.geometry.vertices[0].point[2], -20);
  await f.locator('[data-gizmo=scale]').click();
  o = await origin();
  await drag(at(o, basis[0], 80), at(o, basis[0], 120));
  doc = await inspect();
  assert.ok(Math.abs(doc.dimensions[0] - 60) < 0.01);
  assert.equal(doc.dimensions[1], 40);
  assert.equal(doc.dimensions[2], 40);
  await f.locator('[data-gizmo=move]').click();
  o = await origin();
  const xy = [basis[0][0] + basis[1][0], basis[0][1] + basis[1][1]];
  revision = doc.revision;
  await drag(at(o, xy, 27), at(o, xy, 37));
  doc = await inspect();
  assert.equal(doc.revision, revision + 1);
  await f.locator('[data-gizmo=rotate]').click();
  assert.equal(await f.locator('[data-gizmo=rotate]').getAttribute('aria-pressed'), 'true');
  o = await origin();
  revision = doc.revision;
  const ring = (t) =>
    at(
      o,
      [
        basis[0][0] * Math.cos(t) + basis[1][0] * Math.sin(t),
        basis[0][1] * Math.cos(t) + basis[1][1] * Math.sin(t),
      ],
      65,
    );
  await drag(ring(0.6), ring(1.0));
  doc = await inspect();
  assert.equal(doc.revision, revision + 1);
  await f.locator('[data-gizmo=move]').click();
  o = await origin();
  revision = doc.revision;
  await drag(at(o, basis[0], 70), at(o, basis[0], 110), true);
  doc = await inspect();
  assert.equal(doc.revision, revision);
  // Single vertex selection gets the same handles; a warp of a planar quad is rejected.
  await f.locator('[data-select=vertex]').click();
  await f.locator('#modelElements').selectOption(doc.geometry.vertices[0].id);
  const vertexPoint = async (doc, point) => {
    const b = await f.locator('#modelCanvas').boundingBox(),
      vs = doc.geometry.vertices.map((v) => v.point),
      lo = [0, 1, 2].map((i) => Math.min(...vs.map((v) => v[i]))),
      hi = [0, 1, 2].map((i) => Math.max(...vs.map((v) => v[i]))),
      size = Math.max(...hi.map((v, i) => v - lo[i])),
      p = project(point.map((v, i) => (v - (hi[i] + lo[i]) / 2) / size)),
      scale = Math.min(b.width, b.height) * 0.65;
    return [b.x + b.width / 2 + p[0] * scale, b.y + b.height / 2 + p[1] * scale];
  };
  const vp = await vertexPoint(doc, doc.geometry.vertices[0].point);
  revision = doc.revision;
  await drag(at(vp, basis[0], 70), at(vp, basis[0], 95));
  doc = await inspect();
  assert.equal(doc.revision, revision, 'warped quad must not commit');
  await page.screenshot({
    path: new URL('../.napplet-space/ui-checks/gizmo-vertex.png', import.meta.url).pathname,
  });
  await f.locator('[data-select=edge]').click();
  await f.locator('#modelElements').selectOption(doc.edges[0].id);
  await page.screenshot({
    path: new URL('../.napplet-space/ui-checks/gizmo-edge.png', import.meta.url).pathname,
  });
  await f.locator('[data-select=polygon]').click();
  await f.locator('#modelElements').selectOption(doc.polygonIds);
  await f.locator('[data-gizmo=rotate]').click();
  await page.screenshot({
    path: new URL('../.napplet-space/ui-checks/gizmo-rotation.png', import.meta.url).pathname,
  });
  assert.deepEqual(errors, []);
  const touch = await browser.newPage({
    viewport: { width: 1000, height: 1100 },
    hasTouch: true,
    isMobile: true,
  });
  await touch.goto(process.env.NAPPLET_PREVIEW_URL);
  const tf = touch.frameLocator('iframe');
  await tf.locator('#modelName').waitFor();
  await touch.locator('iframe').evaluate((el) => {
    el.style.width = '320px';
    el.style.height = '560px';
    el.style.flex = 'none';
  });
  await tf.locator('.modeller .modelling-tools').waitFor({ state: 'attached' });
  assert.ok((await tf.locator('#modelCanvas').boundingBox()).height >= 120);
  await tf.locator('.view-switch [data-view=tools]').click();
  assert.equal(
    await tf.getByRole('toolbar', { name: 'Modelling tools' }).getByRole('button').count(),
    9,
  );
  await tf.getByRole('button', { name: '+ Primitive', exact: true }).click();
  await tf.locator('#model-kind').selectOption('box');
  await tf.locator('#modelApply').click();
  await tf.locator('.view-switch [data-view=model]').click();
  assert.match(await tf.locator('#modelStats').innerText(), /6 polygons/);
  assert.ok((await tf.locator('#modelCanvas').boundingBox()).height >= 120);
  await touch.screenshot({
    path: new URL('../.napplet-space/ui-checks/gizmo-touch.png', import.meta.url).pathname,
  });
  await touch.locator('iframe').evaluate((el) => {
    el.style.width = '900px';
    el.style.height = '600px';
  });
  await tf.locator('.model-pane .modelling-tools').waitFor();
  assert.equal(await tf.locator('html').evaluate((el) => el.scrollWidth > innerWidth), false);
  await touch.close();
  console.log(
    'PASS gizmo: axis move, XY plane move, single-axis scale, Z rotation, one undo record per drag, Escape rollback, vertex/edge/polygon handles.',
  );
} finally {
  await browser.close();
}