flowfig 0.11.0 → 0.12.0

package/dist/verify.js

@@ -1,5 +1,5 @@
 import { resolve } from 'node:path';
-import { edgeId, nodes, toBeat } from './model.js';
+import { edgeId, nodes, scenes, toBeat } from './model.js';
 import { headingSlug, links } from './source.js';
 import { codeFile, isDefined, outside, readFile } from './code.js';
 import { edgeResult } from './edges.js';
@@ -31,6 +31,7 @@ export const coverageLine = (figure, c) => `${figure}: ${c.boxesDefined} of ${c.
     (c.found + c.notFound + c.unsure + c.notChecked
         ? `; edges: ${c.found} found, ${c.notFound} not found, ${c.unsure} unsure, ${c.notChecked} not checked`
         : '');
+export const levelLines = (c) => (c.levels ?? []).map(({ path, coverage: l }) => `[${path}] ${l.boxesDefined} of ${l.boxes} parts defined; edges: ${l.found} found, ${l.notFound} not found, ${l.unsure} unsure, ${l.notChecked} not checked`);
 export const unsureLines = (c) => c.unsureEdges.map((e) => `unsure   edge "${e.id}": ${e.reason}`);
 export const SPEC_MARK = '<metadata id="figure-spec">';
 export function detailFindings(fig, root, read = readFile) {
@@ -49,69 +50,116 @@ export function verifyReport(fig, { root = process.cwd(), read = readFile, cache
     const findings = [];
     const coverage = emptyCoverage();
     findings.push(...detailFindings(fig, root, read));
-    const all = links(fig);
-    if (!all.length)
+    const linked = links(fig);
+    if (!linked.length)
         return {
             findings: [...findings, { rule: 'no-source', severity: 'warning', ids: [], message: 'no box, edge or hop has a source' }],
             coverage,
         };
     const files = new Map();
-    for (const l of all) {
-        const full = resolve(root, l.path);
-        if (!files.has(full))
-            files.set(full, outside(root, l.path) ? null : read(full));
-        const text = files.get(full);
-        const before = findings.length;
-        let doubt = false;
-        const fail = (rule, what) => findings.push({ rule, severity: 'error', ids: [], message: `${l.owner} -> ${l.source}: ${what}` });
-        if (text == null)
-            fail('missing-file', 'file not found');
-        else if (l.symbol) {
-            const code = codeFile(root, l.path, read, cache);
-            if (code) {
-                const r = defines(root, code, l.symbol, read, cache);
-                if (r === false)
-                    fail('missing-symbol', 'symbol not defined');
-                doubt = r == null;
+    const levels = [];
+    const all = scenes(fig);
+    const byKey = new Map(all.map((s) => [s.path.join('>'), s]));
+    const sourceOf = new Map(all.flatMap((s) => nodes(s.props.layout).map((n) => [n.id, n.source])));
+    for (const scene of all) {
+        const level = emptyCoverage();
+        for (const l of linked.filter((x) => (x.level ?? '') === scene.path.join('>'))) {
+            const full = resolve(root, l.path);
+            if (!files.has(full))
+                files.set(full, outside(root, l.path) ? null : read(full));
+            const text = files.get(full);
+            const before = findings.length;
+            let doubt = false;
+            const fail = (rule, what) => findings.push({ rule, severity: 'error', ids: [], message: `${l.owner} -> ${l.source}: ${what}` });
+            if (text == null)
+                fail('missing-file', 'file not found');
+            else if (l.symbol) {
+                const code = codeFile(root, l.path, read, cache);
+                if (code) {
+                    const r = defines(root, code, l.symbol, read, cache);
+                    if (r === false)
+                        fail('missing-symbol', 'symbol not defined');
+                    doubt = r == null;
+                }
+                else if (!new RegExp(`(^|[^\\w$])${escape(l.symbol)}(?![\\w$])`).test(text) &&
+                    !(/\.(md|markdown)$/i.test(l.path) && hasHeading(text, l.symbol)))
+                    fail('missing-symbol', 'symbol not found');
+            }
+            if (l.owner.startsWith('box "') || l.owner.startsWith('part "')) {
+                level.boxes++;
+                if (findings.length === before && !doubt)
+                    level.boxesDefined++;
             }
-            else if (!new RegExp(`(^|[^\\w$])${escape(l.symbol)}(?![\\w$])`).test(text) &&
-                !(/\.(md|markdown)$/i.test(l.path) && hasHeading(text, l.symbol)))
-                fail('missing-symbol', 'symbol not found');
-        }
-        if (l.owner.startsWith('box "')) {
-            coverage.boxes++;
-            if (findings.length === before && !doubt)
-                coverage.boxesDefined++;
-        }
-    }
-    const source = new Map(nodes(fig.layout).map((n) => [n.id, n.source]));
-    const check = (who, id, caller, callee, via) => {
-        const { result, reason } = caller ? edgeResult(root, caller, callee, via, read, cache) : { result: 'not-checked', reason: '' };
-        if (result === 'found')
-            coverage.found++;
-        else if (result === 'not-found') {
-            coverage.notFound++;
-            findings.push({ rule: 'edge-not-found', severity: 'warning', ids: [id], message: `${who}: ${reason}` });
-        }
-        else if (result === 'unsure') {
-            coverage.unsure++;
-            coverage.unsureEdges.push({ id, reason });
         }
-        else
-            coverage.notChecked++;
-    };
-    for (const e of fig.edges)
-        check(`edge "${edgeId(e)}"`, edgeId(e), e.source ?? source.get(e.from), source.get(e.to), e.via);
-    const byId = new Map(fig.edges.map((e) => [edgeId(e), e]));
-    for (const step of fig.steps ?? [])
-        for (const beat of step.flow)
-            for (const h of toBeat(beat).hops) {
-                const e = byId.get(h.edge);
-                if (!e || (h.source == null && h.via == null))
-                    continue;
-                const [a, b] = h.back ? [e.to, e.from] : [e.from, e.to];
-                check(`hop on "${h.edge}"`, h.edge, h.source ?? (h.back ? undefined : e.source) ?? source.get(a), source.get(b), h.via);
+        const props = scene.props;
+        const source = new Map(nodes(props.layout).map((n) => [n.id, n.source]));
+        const call = (caller, callee, via) => caller ? edgeResult(root, caller, callee, via, read, cache) : { result: 'not-checked', reason: '' };
+        const ports = new Set(scene.ports.map((p) => p.id));
+        const edgeCall = (e) => {
+            const direct = call(e.source ?? source.get(e.from), source.get(e.to), e.via);
+            const into = ports.has(e.from);
+            if (direct.result === 'found' || e.source != null || e.via != null || into === ports.has(e.to))
+                return direct;
+            const n = into ? e.from : e.to;
+            const chains = [];
+            const inner = [];
+            let callee = source.get(into ? e.to : e.from);
+            for (let k = scene.path.length; k > 0 && byKey.get(scene.path.slice(0, k).join('>')).ports.some((p) => p.id === n); k--) {
+                const owner = sourceOf.get(scene.path[k - 1]);
+                inner.push([owner, callee]);
+                callee = owner;
+                chains.push([...inner, into ? [source.get(n), owner] : [owner, source.get(n)]].map(([a, b]) => call(a, b)));
             }
+            if (chains.some((c) => c.every((r) => r.result === 'found')))
+                return { result: 'found', reason: '' };
+            for (const r of ['not-found', 'not-checked'])
+                if (direct.result === r && chains.every((c) => c.some((x) => x.result === r)))
+                    return direct;
+            const doubt = [direct, ...chains.flat()].find((r) => r.result === 'unsure');
+            return {
+                result: 'unsure',
+                reason: doubt?.reason ?? `${direct.reason}; the call through box "${scene.path.at(-1)}" is not checked`,
+            };
+        };
+        const check = (who, id, { result, reason }) => {
+            if (result === 'found')
+                level.found++;
+            else if (result === 'not-found') {
+                level.notFound++;
+                findings.push({
+                    rule: 'edge-not-found',
+                    severity: 'warning',
+                    ids: [id],
+                    message: `${who}${scene.line ? ` [${scene.line}]` : ''}: ${reason}`,
+                });
+            }
+            else if (result === 'unsure') {
+                level.unsure++;
+                level.unsureEdges.push({ id, reason });
+            }
+            else
+                level.notChecked++;
+        };
+        for (const e of props.edges)
+            check(`edge "${edgeId(e)}"`, edgeId(e), edgeCall(e));
+        const byId = new Map(props.edges.map((e) => [edgeId(e), e]));
+        for (const step of props.steps ?? [])
+            for (const beat of step.flow)
+                for (const h of toBeat(beat).hops) {
+                    const e = byId.get(h.edge);
+                    if (!e || (h.source == null && h.via == null))
+                        continue;
+                    const [a, b] = h.back ? [e.to, e.from] : [e.from, e.to];
+                    check(`hop on "${h.edge}"`, h.edge, call(h.source ?? (h.back ? undefined : e.source) ?? source.get(a), source.get(b), h.via));
+                }
+        for (const k of ['boxes', 'boxesDefined', 'found', 'notFound', 'unsure', 'notChecked'])
+            coverage[k] += level[k];
+        coverage.unsureEdges.push(...level.unsureEdges);
+        if (scene.line)
+            levels.push({ path: scene.line, coverage: level });
+    }
+    if (levels.length)
+        coverage.levels = levels;
     return { findings, coverage };
 }
 export const verify = (fig, opts = {}) => verifyReport(fig, opts).findings;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.11.0";
+export declare const VERSION = "0.12.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 // The release list bumps this with package.json.
-export const VERSION = '0.11.0';
+export const VERSION = '0.12.0';

package/dist/world-art.d.ts

@@ -0,0 +1,59 @@
+import type { FigLook } from './model.ts';
+export type Pt = [number, number];
+export type P3 = [number, number, number];
+export declare const U = 40, C: number, S: number;
+export declare const P: (x: number, y: number, z?: number) => Pt;
+export declare const BY = 1.6;
+export declare const antenna: ([x, y, z]: P3) => string;
+export declare function hull(points: Pt[]): Pt[];
+export type Lot = {
+    x: number;
+    y: number;
+    hull: Pt[];
+    tag: Pt;
+    door: number;
+    depot: {
+        x: number;
+        y: number;
+    } | null;
+    roof: Pt | null;
+};
+export declare function street(looks: (FigLook | undefined)[], withAntenna: boolean[], pitch: number, step?: number): {
+    svg: string;
+    lots: Lot[];
+    bends: Pt[];
+};
+export declare const LANE = 6.6, TD = 0.78, BAR_Y = 5.7, GZ = 0.8, GL = 1.2;
+export declare const BED_ROWS: number[];
+export declare const INK: {
+    ink: string;
+    data: string;
+    fail: string;
+    muted: string;
+};
+export declare const UNIT: Record<'box' | 'barrel' | 'notes', string>;
+export declare function truckArt(depot: {
+    x: number;
+    y: number;
+}): {
+    door: string;
+    yard: string;
+    road: string;
+    slots: {
+        L: number[];
+        R: number[];
+    };
+};
+export declare const PHONE: {
+    svg: string;
+    w: number;
+    h: number;
+};
+export type Gate = {
+    px: number;
+    ex: number;
+    y: number;
+    z: number;
+    L: number;
+};
+export declare function gateArt(g: Gate): string;