@expofp/wayfinding-compiler 0.0.0-experimental.3b0db16 → 0.0.0-stage

package/dist/lib/reachability.d.ts

@@ -1,58 +0,0 @@
-import type { WayfindingSource, WfV1Graph } from './types.js';
-/** A POI by its place in the source, with the name the plan gave it. */
-export interface PoiRef {
-    /** The layer the POI stands on. */
-    readonly layer: string;
-    /** Index in that layer's `destinations` — unique where names are not. */
-    readonly index: number;
-    /** `SourceDestination.id` — the POI name; may repeat or be empty. */
-    readonly id: string;
-}
-/** One connected part of the emitted graph. */
-export interface NetworkPart {
-    /** Distinct graph nodes in it. */
-    readonly nodes: number;
-    /** Indices into `graph.lines`. */
-    readonly lines: readonly number[];
-    /** The layers it reaches, in source order. */
-    readonly layers: readonly string[];
-    /** The POI bound to it. */
-    readonly poi: readonly PoiRef[];
-}
-/** Where one POI meets the graph. */
-export interface PoiBinding {
-    /** The POI. */
-    readonly ref: PoiRef;
-    /** Indices into `graph.lineEnds` that lie inside the POI's `dock ?? polygon`, on its layer. */
-    readonly ends: readonly number[];
-    /** Index into {@link Reachability.parts}, or -1 when {@link ends} is empty. */
-    readonly part: number;
-    /** True when its ends fall on more than one part; {@link part} is then the first of them. */
-    readonly split: boolean;
-}
-/** What the emitted graph connects: its parts, and which part every POI is bound to. */
-export interface Reachability {
-    /**
-     * Connected parts, main first: most POI, then most nodes, then the earliest source POI, then the
-     * smallest node key — independent of line order.
-     */
-    readonly parts: readonly NetworkPart[];
-    /** One entry per source POI: layers in source order, POI in source order within a layer. */
-    readonly poi: readonly PoiBinding[];
-    /** `lineEnds` inside no source ring and starting no shaft edge — bound to nothing. */
-    readonly unownedEnds: readonly number[];
-    /** `lineEnds` inside more than one source ring — either POI may be reached through them. */
-    readonly sharedEnds: readonly {
-        readonly end: number;
-        readonly poi: readonly PoiRef[];
-    }[];
-}
-/**
- * Read what the emitted graph connects: nodes joined by exact coordinates, a POI
- * bound to the `lineEnds` inside its ring. Reads only the graph and the source rings.
- * @param graph The emitted graph, in plan units.
- * @param source The plan the graph was compiled from, in plan units.
- * @returns The parts, the binding of every POI, and the ends nobody or several POI own.
- */
-export declare function readReachability(graph: WfV1Graph, source: WayfindingSource): Reachability;
-//# sourceMappingURL=reachability.d.ts.map

package/dist/lib/reachability.js

@@ -1,220 +0,0 @@
-import { boundsOf, pointInRing } from './geom/primitives.js';
-import { crosses } from './graph-invariants.js';
-/**
- * A node's key: its exact emitted coordinates, since the graph joins nodes only there.
- * @param p An emitted point.
- * @returns Its key.
- */
-function nodeKey(p) {
-    return `${p.layer}_${p.x}_${p.y}`;
-}
-/**
- * Read what the emitted graph connects: nodes joined by exact coordinates, a POI
- * bound to the `lineEnds` inside its ring. Reads only the graph and the source rings.
- * @param graph The emitted graph, in plan units.
- * @param source The plan the graph was compiled from, in plan units.
- * @returns The parts, the binding of every POI, and the ends nobody or several POI own.
- */
-export function readReachability(graph, source) {
-    const ids = new Map();
-    const parent = [];
-    const nodeLayer = [];
-    const nodePos = [];
-    const node = (p) => {
-        const key = nodeKey(p);
-        let id = ids.get(key);
-        if (id === undefined) {
-            id = parent.length;
-            ids.set(key, id);
-            parent.push(id);
-            nodeLayer.push(p.layer);
-            nodePos.push([p.x, p.y]);
-        }
-        return id;
-    };
-    const find = (id) => {
-        let root = id;
-        while (parent[root] !== root)
-            root = parent[root];
-        while (parent[id] !== root)
-            [id, parent[id]] = [parent[id], root];
-        return root;
-    };
-    const lineNodes = graph.lines.map((line) => [node(line.p0), node(line.p1)]);
-    const union = (p0, p1) => {
-        const a = find(p0);
-        const b = find(p1);
-        if (a !== b)
-            parent[Math.max(a, b)] = Math.min(a, b);
-    };
-    for (const [p0, p1] of lineNodes)
-        union(p0, p1);
-    // A node lying on a line's span joins the line there, and two lines that cross join at the crossing:
-    // the converter that builds wf.data.js cuts the lines there, within a tenth of a plan unit.
-    const touch = 0.1;
-    const cell = END_CELL_METERS * (source.unitsPerMeter ?? 1);
-    const cells = new Map();
-    const linesIn = new Map();
-    nodePos.forEach(([x, y], id) => {
-        const key = `${nodeLayer[id]}|${Math.floor(x / cell)}|${Math.floor(y / cell)}`;
-        cells.set(key, [...(cells.get(key) ?? []), id]);
-    });
-    graph.lines.forEach(({ p0, p1 }, index) => {
-        if (p0.layer !== p1.layer)
-            return;
-        const dx = p1.x - p0.x;
-        const dy = p1.y - p0.y;
-        const length = Math.hypot(dx, dy);
-        if (length <= 2 * touch)
-            return;
-        const x0 = Math.floor((Math.min(p0.x, p1.x) - touch) / cell);
-        const x1 = Math.floor((Math.max(p0.x, p1.x) + touch) / cell);
-        const y0 = Math.floor((Math.min(p0.y, p1.y) - touch) / cell);
-        const y1 = Math.floor((Math.max(p0.y, p1.y) + touch) / cell);
-        for (let cx = x0; cx <= x1; cx++)
-            for (let cy = y0; cy <= y1; cy++) {
-                const key = `${p0.layer}|${cx}|${cy}`;
-                for (const id of cells.get(key) ?? []) {
-                    const [px, py] = nodePos[id];
-                    const along = ((px - p0.x) * dx + (py - p0.y) * dy) / length;
-                    const off = Math.abs((px - p0.x) * dy - (py - p0.y) * dx) / length;
-                    if (off <= touch && along > touch && along < length - touch)
-                        union(id, lineNodes[index][0]);
-                }
-                for (const other of linesIn.get(key) ?? []) {
-                    const o = graph.lines[other];
-                    if (crosses([p0.x, p0.y, p1.x, p1.y], [o.p0.x, o.p0.y, o.p1.x, o.p1.y]))
-                        union(lineNodes[index][0], lineNodes[other][0]);
-                }
-                linesIn.set(key, [...(linesIn.get(key) ?? []), index]);
-            }
-    });
-    // A docking point no line reaches is a part of its own, connected to nothing else.
-    const endNodes = graph.lineEnds.map(node);
-    const bindings = bind(graph, source);
-    const byRoot = new Map();
-    const partAt = (root) => {
-        let part = byRoot.get(root);
-        if (!part) {
-            part = { nodes: 0, lines: [], layers: new Set(), poi: [], firstPoi: Infinity, minKey: '' };
-            byRoot.set(root, part);
-        }
-        return part;
-    };
-    for (const [key, id] of ids) {
-        const part = partAt(find(id));
-        part.nodes++;
-        part.layers.add(nodeLayer[id]);
-        if (!part.minKey || key < part.minKey)
-            part.minKey = key;
-    }
-    lineNodes.forEach(([p0], index) => partAt(find(p0)).lines.push(index));
-    bindings.forEach(({ ref, ends }, order) => {
-        for (const root of new Set(ends.map((end) => find(endNodes[end])))) {
-            const part = partAt(root);
-            part.poi.push(ref);
-            part.firstPoi = Math.min(part.firstPoi, order);
-        }
-    });
-    const ranked = [...byRoot].sort(([, a], [, b]) => b.poi.length - a.poi.length ||
-        b.nodes - a.nodes ||
-        a.firstPoi - b.firstPoi ||
-        (a.minKey < b.minKey ? -1 : a.minKey > b.minKey ? 1 : 0));
-    const rank = new Map(ranked.map(([root], index) => [root, index]));
-    const sourceLayers = [...new Set(source.layers.map((layer) => layer.layer))];
-    const parts = ranked.map(([, part]) => ({
-        nodes: part.nodes,
-        lines: part.lines,
-        layers: sourceLayers.filter((layer) => part.layers.has(layer)),
-        poi: part.poi,
-    }));
-    const poi = bindings.map(({ ref, ends }) => {
-        const on = [...new Set(ends.map((end) => rank.get(find(endNodes[end]))))].sort((a, b) => a - b);
-        return { ref, ends, part: on[0] ?? -1, split: on.length > 1 };
-    });
-    const owners = new Map();
-    for (const { ref, ends } of bindings)
-        for (const end of ends) {
-            const list = owners.get(end);
-            if (list)
-                list.push(ref);
-            else
-                owners.set(end, [ref]);
-        }
-    // A shaft edge starts at its stop's dock, often inside a pad no source ring holds: such ends are the shaft's.
-    const shaftEnds = new Set();
-    graph.lines.forEach((line, index) => {
-        if (line.p0.layer === line.p1.layer)
-            return;
-        shaftEnds.add(lineNodes[index][0]);
-        shaftEnds.add(lineNodes[index][1]);
-    });
-    const unownedEnds = endNodes
-        .map((id, end) => ({ id, end }))
-        .filter(({ id, end }) => !owners.has(end) && !shaftEnds.has(id))
-        .map(({ end }) => end);
-    const sharedEnds = [...owners]
-        .filter(([, refs]) => refs.length > 1)
-        .sort(([a], [b]) => a - b)
-        .map(([end, refs]) => ({ end, poi: refs }));
-    return { parts, poi, unownedEnds, sharedEnds };
-}
-/** Side of a cell the line ends are bucketed in, in meters: a booth or two across. */
-const END_CELL_METERS = 4;
-/**
- * Which `lineEnds` lie inside each source POI's ring, on its layer — the graph's binding rule, run
- * only on the ends in cells the ring's bounds cover.
- * @param graph The emitted graph.
- * @param source The source plan.
- * @returns One binding per source POI, in source order; each POI's ends in ascending order.
- */
-function bind(graph, source) {
-    const cell = END_CELL_METERS * (source.unitsPerMeter ?? 1);
-    const cellKey = (layer, cx, cy) => `${layer}\u0000${cx}\u0000${cy}`;
-    const cells = new Map();
-    // The cells holding line ends, per layer: a ring is looked up no farther, whatever its bounds are.
-    const spans = new Map();
-    graph.lineEnds.forEach((end, index) => {
-        const cx = Math.floor(end.x / cell);
-        const cy = Math.floor(end.y / cell);
-        const key = cellKey(end.layer, cx, cy);
-        const list = cells.get(key);
-        const span = spans.get(end.layer);
-        if (list)
-            list.push(index);
-        else
-            cells.set(key, [index]);
-        if (span) {
-            span[0] = Math.min(span[0], cx);
-            span[1] = Math.min(span[1], cy);
-            span[2] = Math.max(span[2], cx);
-            span[3] = Math.max(span[3], cy);
-        }
-        else
-            spans.set(end.layer, [cx, cy, cx, cy]);
-    });
-    return source.layers.flatMap((layer) => layer.destinations.map((destination, index) => {
-        const ring = destination.dock ?? destination.polygon;
-        const ref = { layer: layer.layer, index, id: destination.id };
-        const span = spans.get(layer.layer);
-        // Fewer than three vertices enclose nothing, and a layer with no line ends binds nothing.
-        if (ring.length < 3 || !span)
-            return { ref, ends: [] };
-        const [x0, y0, x1, y1] = boundsOf(ring);
-        const ends = [];
-        // Clamped to the layer's line ends: a ring that is huge, or holds a coordinate that is not a
-        // number, costs no more than the graph is large.
-        const cx0 = Math.max(Math.floor(x0 / cell), span[0]);
-        const cy0 = Math.max(Math.floor(y0 / cell), span[1]);
-        const cx1 = Math.min(Math.floor(x1 / cell), span[2]);
-        const cy1 = Math.min(Math.floor(y1 / cell), span[3]);
-        for (let cx = cx0; cx <= cx1; cx++)
-            for (let cy = cy0; cy <= cy1; cy++)
-                for (const end of cells.get(cellKey(layer.layer, cx, cy)) ?? []) {
-                    const { x, y } = graph.lineEnds[end];
-                    if (x >= x0 && x <= x1 && y >= y0 && y <= y1 && pointInRing(ring, [x, y]))
-                        ends.push(end);
-                }
-        return { ref, ends: ends.sort((p, q) => p - q) };
-    }));
-}

package/dist/lib/report.d.ts

@@ -1,49 +0,0 @@
-import { type Diagnostic, type Highlight } from './diagnostics.js';
-import type { PoiRef, Reachability } from './reachability.js';
-import type { WayfindingSource } from './types.js';
-/** What came of the compile, in one word. */
-export type Outcome = 'built' | 'built-with-gaps' | 'not-built';
-/** The kinds of problem a designer is shown. */
-export type ProblemKind = 'plan-invalid' | 'floor-not-built' | 'poi-not-connected' | 'network-split' | 'floors-not-connected' | 'nothing-to-build';
-/** One problem: a floor, the POI it touches, the reason in words, and where to look. */
-export interface Problem {
-    /** What kind of problem it is. */
-    readonly kind: ProblemKind;
-    /** The layer it belongs to; absent for whole-plan problems. */
-    readonly layer?: string;
-    /** Machine-readable cause within the kind; the designer reads {@link message}. */
-    readonly cause: string;
-    /** Ready English text: the floor, the names, the reason. */
-    readonly message: string;
-    /** The POI it touches, with the names the plan gave them. */
-    readonly poi: readonly PoiRef[];
-    /** Where to look, in plan units; empty when nothing exact is known. */
-    readonly highlight: readonly Highlight[];
-}
-/** What the designer reads about a compile. */
-export interface CompileReport {
-    /** What came of the compile. */
-    readonly outcome: Outcome;
-    /** One line for the whole plan. */
-    readonly summary: string;
-    /** Problems grouped by floor and reason. */
-    readonly problems: readonly Problem[];
-    /** Source POI only; transition pads are not counted. */
-    readonly counts: {
-        readonly poi: number;
-        readonly poiConnected: number;
-        readonly poiNotConnected: number;
-        readonly poiOnDetachedParts: number;
-        readonly networkParts: number;
-        readonly floorsWithoutFloor: number;
-    };
-}
-/**
- * Fold the compile's facts into what a designer reads: every problem is a diagnostic or a binding, grouped.
- * @param diagnostics Every fact of the compile.
- * @param reachability What the emitted graph connects.
- * @param source The plan in plan units, for the outlines a problem points at.
- * @returns The report.
- */
-export declare function buildReport(diagnostics: readonly Diagnostic[], reachability: Reachability, source: WayfindingSource): CompileReport;
-//# sourceMappingURL=report.d.ts.map