lynkeus 0.2.0 → 0.4.0

package/src/knowledge/__tests__/plan.test.ts

@@ -1,52 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-
-import type { ObservedEdge } from '../edges.js';
-import { describePlan, plan } from '../plan.js';
-import type { ScreenGraph } from '../types.js';
-
-const graph = (routes: string[]): ScreenGraph => ({
-  app: 'test',
-  root: '/tmp',
-  extractedAt: '2026-01-01',
-  screens: Object.fromEntries(routes.map((route) => [route, { route, component: route, file: null, declaredIn: 'nav.tsx' }])),
-  files: {},
-  warnings: [],
-});
-
-const edge = (e: Partial<ObservedEdge> & Pick<ObservedEdge, 'from' | 'to' | 'via'>): ObservedEdge => ({ seen: 1, last: '2026-01-01', ...e });
-
-test('a sheet is a place the directions can reach', () => {
-  const steps = plan(graph(['Settings.Main', 'Account.Delete']), 'Settings.Main', 'Account.Delete', [
-    edge({ from: 'Settings.Main', to: 'Settings.Main', via: 'account-button', toLayer: 'account-button' }),
-    edge({ from: 'Settings.Main', to: 'Account.Delete', via: 'delete-account-button', fromLayer: 'account-button' }),
-  ]);
-
-  assert.deepEqual(
-    steps?.map((s) => [s.from, s.press, s.to]),
-    [
-      ['Settings.Main', 'account-button', 'Settings.Main#account-button'],
-      ['Settings.Main#account-button', 'delete-account-button', 'Account.Delete'],
-    ],
-  );
-  assert.match(describePlan(steps!), /opens a layer/);
-});
-
-test('what a screen offers does not apply while a sheet covers it', () => {
-  const steps = plan(graph(['Settings.Main', 'Profile.Edit']), 'Settings.Main#account-button', 'Profile.Edit', [
-    edge({ from: 'Settings.Main', to: 'Profile.Edit', via: 'profile-button' }),
-  ]);
-
-  assert.equal(steps, null);
-});
-
-test('asking for a route accepts arriving with something open over it', () => {
-  const steps = plan(graph(['Settings.Main', 'Checkout.Main']), 'Settings.Main', 'Checkout.Main', [
-    edge({ from: 'Settings.Main', to: 'Checkout.Main', via: 'send-button', toLayer: 'send-button' }),
-  ]);
-
-  assert.deepEqual(
-    steps?.map((s) => s.to),
-    ['Checkout.Main#send-button'],
-  );
-});

package/src/knowledge/__tests__/query.test.ts

@@ -1,74 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-
-import { screensAffectedBy } from '../query.js';
-import type { ScreenGraph } from '../types.js';
-
-const graph = {
-  app: 'test',
-  root: 'Root',
-  extractedAt: '',
-  warnings: [],
-  screens: {
-    'A.Main': { route: 'A.Main', component: 'A', file: 'app/a.tsx', declaredIn: 'nav.tsx' },
-    'B.Main': { route: 'B.Main', component: 'B', file: 'app/b.tsx', declaredIn: 'nav.tsx' },
-  },
-  files: {
-    'app/a.tsx': { imports: ['app/shared.tsx'] },
-    'app/b.tsx': { imports: [] },
-    'app/shared.tsx': { imports: [] },
-  },
-} as unknown as ScreenGraph;
-
-test('a changed screen file is affected at distance 0', () => {
-  const r = screensAffectedBy(graph, ['app/a.tsx']);
-  assert.deepEqual(
-    r.map((x) => [x.route, x.distance]),
-    [['A.Main', 0]],
-  );
-});
-test('a shared file reaches its importer at distance 1, naming the changed file', () => {
-  const r = screensAffectedBy(graph, ['app/shared.tsx']);
-  assert.deepEqual(
-    r.map((x) => [x.route, x.distance, x.via]),
-    [['A.Main', 1, 'app/shared.tsx']],
-  );
-});
-test('results are nearest first', () => {
-  const g = {
-    ...graph,
-    screens: { ...graph.screens, 'C.Main': { route: 'C.Main', component: 'C', file: 'app/c.tsx', declaredIn: 'nav.tsx' } },
-    files: { ...graph.files, 'app/c.tsx': { imports: ['app/a.tsx'] } },
-  } as unknown as ScreenGraph;
-  const r = screensAffectedBy(g, ['app/shared.tsx']);
-  assert.deepEqual(
-    r.map((x) => [x.route, x.distance]),
-    [
-      ['A.Main', 1],
-      ['C.Main', 2],
-    ],
-  );
-});
-test('an unrelated change affects nothing', () => {
-  assert.deepEqual(screensAffectedBy(graph, ['app/unrelated.tsx']), []);
-});
-test('a barrel reaches who imports through it only when the barrel itself changed', () => {
-  const g = {
-    ...graph,
-    files: {
-      'app/a.tsx': { imports: ['app/hooks/useThing.ts'], barrels: ['app/hooks/index.ts'] },
-      'app/b.tsx': { imports: ['app/hooks/useOther.ts'], barrels: ['app/hooks/index.ts'] },
-      'app/hooks/index.ts': { imports: ['app/hooks/useThing.ts', 'app/hooks/useOther.ts'] },
-      'app/hooks/useThing.ts': { imports: [] },
-      'app/hooks/useOther.ts': { imports: [] },
-    },
-  } as unknown as ScreenGraph;
-  assert.deepEqual(
-    screensAffectedBy(g, ['app/hooks/useThing.ts']).map((x) => x.route),
-    ['A.Main'],
-  );
-  assert.deepEqual(
-    screensAffectedBy(g, ['app/hooks/index.ts']).map((x) => x.route),
-    ['A.Main', 'B.Main'],
-  );
-});

package/src/knowledge/__tests__/screens.test.ts

@@ -1,37 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { test } from 'node:test';
-
-import type { Screen } from 'lynkeus-protocol';
-
-import { diffGeometry, record } from '../screens.js';
-
-const f = (x: number, y: number, w: number, h: number) => ({ x, y, w, h });
-
-test('drift within the tolerance is not a change', () => {
-  assert.deepEqual(diffGeometry({ a: f(10, 10, 100, 40) }, { a: f(12, 8, 102, 41) }), []);
-});
-test('a move past the tolerance is reported with both positions', () => {
-  assert.deepEqual(diffGeometry({ a: f(10, 10, 100, 40) }, { a: f(10, 60, 100, 40) }), ['#a moved (10,10)→(10,60)']);
-});
-test('a resize is reported', () => {
-  assert.deepEqual(diffGeometry({ a: f(0, 0, 100, 40) }, { a: f(0, 0, 100, 80) }), ['#a resized 100×40→100×80']);
-});
-test('an element that collapsed to zero is named as such', () => {
-  assert.deepEqual(diffGeometry({ a: f(0, 0, 100, 40) }, { a: f(0, 0, 100, 0) }), ['#a collapsed to 100×0 (was 100×40)']);
-});
-test('elements only on one side are not geometry changes', () => {
-  assert.deepEqual(diffGeometry({ a: f(0, 0, 1, 1) }, { b: f(0, 0, 1, 1) }), []);
-});
-
-test('a recorded screen keeps what is presented, not what another tab or a covered screen holds', () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'lynkeus-screens-'));
-  const el = (i: number, testId: string, hidden?: string) => ({ i, kind: 'button', frame: f(0, i * 50, 100, 40), enabled: true, depth: 0, testId, hidden });
-  const screen = (elements: object[]) =>
-    ({ route: 'Settings.Main', path: ['Settings.Main'], commit: 1, busy: false, window: { w: 390, h: 844 }, costMs: 1, elements }) as unknown as Screen;
-  record(dir, screen([el(0, 'save'), el(1, 'other-tab', 'a11y'), el(2, 'slide', 'inert')]));
-  const change = record(dir, screen([el(0, 'save'), el(2, 'slide', 'inert')]));
-  assert.equal(change, null);
-});

package/src/knowledge/__tests__/why.test.ts

@@ -1,40 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-
-import { explain } from '../why.js';
-import type { Element, RequestRecord, Screen, TraceEvent } from 'lynkeus-protocol';
-
-const el = (p: Partial<Element>, i: number): Element =>
-  ({ i, kind: 'button', frame: { x: 0, y: 0, w: 10, h: 10 }, enabled: true, depth: 1, tag: i + 1, ...p }) as Element;
-const screen = (elements: Element[], route?: string): Screen => ({ route, path: route ? [route] : [], elements, commit: 5, costMs: 1 }) as unknown as Screen;
-const req = (status: number | undefined, url: string, error?: string): RequestRecord => ({ id: 1, method: 'GET', url, status, startedAt: 0, ms: 10, error });
-const rules = (f: ReturnType<typeof explain>) => f.map((x) => x.rule);
-
-test('a dead navigator and a gone session are named', () => {
-  assert.deepEqual(rules(explain({ screen: screen([]), requests: [], inFlight: 0 })), ['dead-navigator']);
-  assert.ok(
-    rules(explain({ screen: screen([el({}, 0)], 'Home'), requests: [req(401, 'http://x/a'), req(401, 'http://x/b')], inFlight: 0 })).includes('session-gone'),
-  );
-});
-
-test('a covered target, a near text and a capped list', () => {
-  const s = screen([el({ testId: 'submit', covered: true }, 0), el({ kind: 'text', text: 'Café Ünïcode wörks here' }, 1)], 'Home');
-  assert.ok(rules(explain({ screen: s, requests: [], inFlight: 0, target: { testId: 'submit' } })).includes('covered'));
-  assert.ok(rules(explain({ screen: s, requests: [], inFlight: 0, target: { text: 'Cafe Unicode works here' } })).includes('near-match'));
-  assert.ok(rules(explain({ screen: s, requests: [], inFlight: 0, target: { text: 'cafe unicode works here' } })).includes('near-match'));
-  assert.ok(!rules(explain({ screen: s, requests: [], inFlight: 0, target: { text: 'A completely different sentence' } })).includes('near-match'));
-  const list = screen(
-    Array.from({ length: 12 }, (_, i) => el({ testId: `row-${i}-item`, text: `Item${i}` }, i)),
-    'Search',
-  );
-  assert.ok(rules(explain({ screen: list, requests: [req(200, 'http://x/search')], inFlight: 0, target: { text: 'itemabc' } })).includes('capped-list'));
-});
-
-test('backend and loading conditions', () => {
-  const s = screen([el({}, 0)], 'Home');
-  assert.ok(rules(explain({ screen: s, requests: [req(500, 'http://x/api/a')], inFlight: 0 })).includes('backend-error'));
-  assert.ok(rules(explain({ screen: s, requests: [req(200, 'http://x/a')], inFlight: 2, target: { testId: 'x' } })).includes('in-flight'));
-  const stall: TraceEvent = { seq: 1, t: 1, kind: 'stall', renders: 2000, windowMs: 3000, component: 'Feed' };
-  assert.ok(rules(explain({ screen: s, requests: [], inFlight: 0, trace: [stall] })).includes('render-loop'));
-  assert.deepEqual(rules(explain({ screen: s, requests: [req(200, 'http://x/a')], inFlight: 0 })), []);
-});