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

package/dist/lib/attach.js

@@ -1,199 +0,0 @@
-// Attach: each stub ends where it first meets the network — a line, or another stub, which then
-// ends there too, so the meeting is a node. A stub that meets nothing is taken to the network by an
-// elbow to the nearest line a free way reaches, else by a raster path laid like a growth path; one
-// that cannot attach is retried from its destination's next way in.
-import { dockFor } from './entries.js';
-import { linkOnto, nearestFrame } from './geom/frames.js';
-import { POINT_EPS } from './geom/point-key.js';
-import { rayVsSegment, segmentsCross } from './geom/primitives.js';
-import { NODE_SNAP } from './graph-types.js';
-import { sideOf } from './stubs.js';
-/**
- * The first network line a ray meets. A line lying along the ray is met at its nearer end when that is
- * ahead, else at its far end.
- * @param store The network.
- * @param ox Ray origin x.
- * @param oy Ray origin y.
- * @param nx Ray direction x.
- * @param ny Ray direction y.
- * @param maxT How far to look.
- * @returns The segment id and distance, or null within `maxT`.
- */
-export function firstNetworkAlong(store, ox, oy, nx, ny, maxT) {
-    let best = null;
-    const hit = [0, 0];
-    const visit = (id, x0, y0, x1, y1) => {
-        let t = Infinity;
-        if (rayVsSegment(hit, ox, oy, nx, ny, x0, y0, x1, y1)) {
-            if (hit[1] >= -1e-9 && hit[1] <= 1 + 1e-9)
-                t = hit[0];
-        }
-        else if (Math.abs(-(x0 - ox) * ny + (y0 - oy) * nx) <= 0.01) {
-            const a0 = (x0 - ox) * nx + (y0 - oy) * ny;
-            const a1 = (x1 - ox) * nx + (y1 - oy) * ny;
-            const near = Math.min(a0, a1);
-            t = near > NODE_SNAP ? near : Math.max(a0, a1);
-        }
-        if (!isFinite(t) || t <= NODE_SNAP || t > maxT)
-            return;
-        if (!best || t < best.t - 1e-9)
-            best = { id, t };
-    };
-    // Only lines near the ray can meet it; both walks go in id order, so ties settle alike.
-    if (isFinite(maxT)) {
-        const ex = ox + nx * maxT;
-        const ey = oy + ny * maxT;
-        store.forEachNear(Math.min(ox, ex) - NODE_SNAP, Math.min(oy, ey) - NODE_SNAP, Math.max(ox, ex) + NODE_SNAP, Math.max(oy, ey) + NODE_SNAP, visit);
-    }
-    else
-        store.forEach(visit);
-    return best;
-}
-/**
- * Attaches every stub to the network, retrying a destination's next way in when one fails.
- * @param attaching What the attach reads and extends.
- * @returns The whiskers: the stubs attached, in the order they attached.
- */
-export function attachStubs(attaching) {
-    const { plan, store, connector, router, frames, blockers, destinationOf, mayLay, note } = attaching;
-    const whiskers = [];
-    /**
-     * Where a run from a foot first meets the network: a network line, or another stub crossing it
-     * away from that stub's foot and tip — whichever comes first. A crossed stub counts only when its
-     * tip is on the network and the rest of its run may be a line.
-     * @param ox Foot x.
-     * @param oy Foot y.
-     * @param dx Unit direction of the run, x.
-     * @param dy Unit direction, y.
-     * @param maxT How far along the run to look.
-     * @returns The distance along the run and how to join the network there, or null.
-     */
-    const meetingAlong = (ox, oy, dx, dy, maxT) => {
-        const met = firstNetworkAlong(store, ox, oy, dx, dy, maxT);
-        const hit = [0, 0];
-        let crossed = null;
-        for (const other of whiskers) {
-            const length = Math.hypot(other.tx - other.mx, other.ty - other.my);
-            if (!rayVsSegment(hit, ox, oy, dx, dy, other.mx, other.my, other.tx, other.ty))
-                continue;
-            const [t, s] = hit;
-            if (t <= NODE_SNAP || t > (met?.t ?? maxT))
-                continue;
-            if (s * length <= NODE_SNAP || (1 - s) * length <= NODE_SNAP)
-                continue;
-            if (!crossed || t < crossed.t - 1e-9)
-                crossed = { other, t };
-        }
-        if (crossed) {
-            const { other, t } = crossed;
-            const at = [+(ox + dx * t).toFixed(2), +(oy + dy * t).toFixed(2)];
-            // The crossed stub ends at the meeting, the rest of its run a line to its tip.
-            if (store.hasNode(other.tx, other.ty) && mayLay([at[0], at[1], other.tx, other.ty]))
-                return {
-                    t,
-                    joinAt: () => {
-                        connector.add([at[0], at[1], other.tx, other.ty]);
-                        [other.tx, other.ty] = at;
-                    },
-                };
-        }
-        return met && { t: met.t, joinAt: ([x, y]) => store.splitAt(met.id, x, y) };
-    };
-    /**
-     * The walkable router cell of a point on its direction's grid, else the plan's.
-     * @param x Point x.
-     * @param y Point y.
-     * @param frame The direction.
-     * @returns The cell, or -1 when off the floor.
-     */
-    const cellAt = (x, y, frame) => {
-        for (const f of [frame, frames[0]]) {
-            const cell = router.cellIn(x, y, f);
-            if (cell >= 0)
-                return router.ok[cell] ? cell : -1;
-        }
-        return -1;
-    };
-    /**
-     * Joins a tip standing off the network: an elbow to the nearest freely reachable line, else a
-     * raster path laid on the lines of its way.
-     * @param stub The stub.
-     * @returns True when joined.
-     */
-    const connectTip = (stub) => {
-        const tip = [stub.tx, stub.ty];
-        if (store.hasNode(tip[0], tip[1]))
-            return true;
-        // No network at all (a plan with one destination): the stub's own run is its line.
-        if (!store.size) {
-            const line = [stub.mx, stub.my, tip[0], tip[1]];
-            if (!mayLay(line))
-                return false;
-            connector.add(line);
-            return true;
-        }
-        // A link crosses no stub attached so far: a route would walk past that destination and back.
-        const clear = (seg) => mayLay(seg) && !whiskers.some((w) => segmentsCross(seg, [w.mx, w.my, w.tx, w.ty]));
-        const found = store.nearestLawful(tip[0], tip[1], (_, qx, qy) => clear([tip[0], tip[1], qx, qy]));
-        const link = found &&
-            linkOnto(frames[nearestFrame(frames, ...runOf(found.id))], tip, store.coords(found.id), found.at, clear);
-        if (found && link) {
-            store.splitAt(found.id, link.at[0], link.at[1]);
-            for (const leg of link.legs)
-                connector.add(leg);
-            return true;
-        }
-        // On the tip's own grid, so the path leaves square to its face.
-        const frame = stub.frame ?? frames[0];
-        const tipCell = cellAt(tip[0], tip[1], frame);
-        if (tipCell < 0)
-            return false;
-        // Search from the tip so the cost follows the path length, not the network size; reversed to
-        // run tip first.
-        const cells = router.route([tipCell], connector.onNetwork)?.reverse() ?? null;
-        const head = { at: tip, normal: [stub.nx, stub.ny], frame };
-        // Reaching the destination outweighs the whisker rule when its only way crosses one.
-        return (cells !== null && (connector.layPath(cells, head, clear) || connector.layPath(cells, head)));
-    };
-    const runOf = (id) => {
-        const [x0, y0, x1, y1] = store.coords(id);
-        return [x1 - x0, y1 - y0];
-    };
-    /** Sides of each destination a whisker already serves. */
-    const servedSides = new Map();
-    const pending = [...plan.stubs];
-    // A for-of walks the retries pushed while it runs.
-    for (const stub of pending) {
-        const d = destinationOf.get(stub.id);
-        const retry = () => {
-            const next = plan.retry(stub, servedSides, whiskers);
-            if (next)
-                pending.push(next);
-        };
-        // The tip stops at the first network line or stub within its reach.
-        const meeting = meetingAlong(stub.mx, stub.my, stub.nx, stub.ny, stub.reach + 1.1 * POINT_EPS);
-        if (meeting) {
-            const tip = [
-                +(stub.mx + stub.nx * meeting.t).toFixed(2),
-                +(stub.my + stub.ny * meeting.t).toFixed(2),
-            ];
-            // No lawful dock from the meeting, no way in.
-            if (!dockFor(d, stub.way, tip, blockers)) {
-                note(d.id, 'way-in-blocked', { at: tip });
-                retry();
-                continue;
-            }
-            meeting.joinAt(tip);
-            [stub.tx, stub.ty] = tip;
-        }
-        else if (!connectTip(stub)) {
-            note(d.id, router.cellsOf(stub.tx, stub.ty).some((c) => router.ok[c]) ? 'cut-off' : 'no-floor', { at: [stub.tx, stub.ty] });
-            retry();
-            continue;
-        }
-        whiskers.push(stub);
-        if (stub.kind === 'face')
-            servedSides.set(stub.id, (servedSides.get(stub.id) ?? new Set()).add(sideOf(stub.way)));
-    }
-    return whiskers;
-}

package/dist/lib/axes.d.ts

@@ -1,76 +0,0 @@
-import { type Frame } from './geom/frames.js';
-/** A stub tip read in a frame: the line it lies on runs square to its stub. */
-interface TipOnAxis {
-    /** Coordinate across the aisle: the line the tip lies on. */
-    readonly c: number;
-    /** Coordinate along the aisle. */
-    readonly along: number;
-    /**
-     * Where across its line may lie: a comfortable clearance from its face and from what stands across.
-     * Absent for no bound.
-     */
-    readonly may?: readonly [number, number];
-}
-/** One aisle's line in a frame: along the frame's first axis (`horiz`) or its second. */
-export interface AisleAxis {
-    /** The frame. */
-    readonly frame: Frame;
-    /** The line runs along the frame's first axis; across is the second. */
-    readonly horiz: boolean;
-    /** The across coordinate. */
-    readonly c: number;
-    /** Where the line starts: as far back from the first tip as the floor is free along it. */
-    readonly lo: number;
-    /** Where the line ends: as far on from the last tip as the floor is free along it. */
-    readonly hi: number;
-}
-/** One aisle's axis: its across coordinate, its reach along, and its tips. */
-export interface Axis<T extends TipOnAxis> {
-    /** The across coordinate: the lower median of the tips', so half the stubs keep their length. */
-    readonly c: number;
-    /** Where the line starts along. */
-    readonly lo: number;
-    /** Where the line ends along. */
-    readonly hi: number;
-    /** The tips on it, in order along. */
-    readonly tips: T[];
-}
-/**
- * A point in a frame as `[along, across]` of a line orientation.
- * @param frame The frame.
- * @param horiz Lines along the frame's first axis.
- * @param x Plan x.
- * @param y Plan y.
- * @returns Along and across.
- */
-export declare function alongAcross(frame: Frame, horiz: boolean, x: number, y: number): [number, number];
-/**
- * Reads a tip into a frame.
- * @param frame The frame.
- * @param x Tip x.
- * @param y Tip y.
- * @param nx Stub direction x.
- * @param ny Stub direction y.
- * @returns Whether its line runs along the frame's first axis, and its coordinates across and along.
- */
-export declare function tipInFrame(frame: Frame, x: number, y: number, nx: number, ny: number): {
-    horiz: boolean;
-    c: number;
-    along: number;
-};
-/**
- * Groups the tips of one direction and orientation into aisles. Tips the raster cannot tell apart
- * across (within `align`) lie on one row; a row's line reaches along as far as the floor is free
- * beyond its end tips. A row joins the aisle whose rows all lie within `snap` of it across, since no
- * corridor fits between them, when their lines' reaches overlap along and one line may serve every
- * tip — the tips' bands keep two aisles that merely share open floor apart. The axis lies at the
- * lower median of the aisle's tips, within where every tip's line may lie.
- * @param tips The tips.
- * @param align Across distance within which tips lie on one row.
- * @param snap Across distance within which the rows of one aisle lie.
- * @param reach How far the floor is free along the row's line from a tip, forward (`1`) or back (`-1`).
- * @returns The aisles' axes.
- */
-export declare function aisleAxes<T extends TipOnAxis>(tips: readonly T[], align: number, snap: number, reach: (tip: T, sign: 1 | -1) => number): Axis<T>[];
-export {};
-//# sourceMappingURL=axes.d.ts.map

package/dist/lib/axes.js

@@ -1,103 +0,0 @@
-// Aisle axes: the lines the stub tips of one direction define, one per aisle. A stub ends in the middle
-// of the aisle in front of its face, so the tips of the stands along an aisle lie on its line; the axis
-// is where that line goes, and every pass lays the aisle's line there.
-import { toFrame } from './geom/frames.js';
-/**
- * A point in a frame as `[along, across]` of a line orientation.
- * @param frame The frame.
- * @param horiz Lines along the frame's first axis.
- * @param x Plan x.
- * @param y Plan y.
- * @returns Along and across.
- */
-export function alongAcross(frame, horiz, x, y) {
-    const [u, v] = toFrame(frame, x, y);
-    return horiz ? [u, v] : [v, u];
-}
-/**
- * Reads a tip into a frame.
- * @param frame The frame.
- * @param x Tip x.
- * @param y Tip y.
- * @param nx Stub direction x.
- * @param ny Stub direction y.
- * @returns Whether its line runs along the frame's first axis, and its coordinates across and along.
- */
-export function tipInFrame(frame, x, y, nx, ny) {
-    const [nu, nv] = toFrame(frame, nx, ny);
-    const horiz = Math.abs(nv) > Math.abs(nu);
-    const [along, c] = alongAcross(frame, horiz, x, y);
-    return { horiz, c, along };
-}
-/**
- * Groups the tips of one direction and orientation into aisles. Tips the raster cannot tell apart
- * across (within `align`) lie on one row; a row's line reaches along as far as the floor is free
- * beyond its end tips. A row joins the aisle whose rows all lie within `snap` of it across, since no
- * corridor fits between them, when their lines' reaches overlap along and one line may serve every
- * tip — the tips' bands keep two aisles that merely share open floor apart. The axis lies at the
- * lower median of the aisle's tips, within where every tip's line may lie.
- * @param tips The tips.
- * @param align Across distance within which tips lie on one row.
- * @param snap Across distance within which the rows of one aisle lie.
- * @param reach How far the floor is free along the row's line from a tip, forward (`1`) or back (`-1`).
- * @returns The aisles' axes.
- */
-export function aisleAxes(tips, align, snap, reach) {
-    const sorted = [...tips].sort((a, b) => a.c - b.c || a.along - b.along);
-    const rows = [];
-    for (const tip of sorted) {
-        const row = rows[rows.length - 1];
-        if (row && tip.c - row[row.length - 1].c <= align)
-            row.push(tip);
-        else
-            rows.push([tip]);
-    }
-    const meet = (a, b) => [
-        Math.max(a[0], b[0]),
-        Math.min(a[1], b[1]),
-    ];
-    const span = rows.map((row) => {
-        const ordered = [...row].sort((a, b) => a.along - b.along);
-        const first = ordered[0];
-        const last = ordered[ordered.length - 1];
-        // Tips whose bands share no line still form the row: the line then stays among the tips.
-        const may = row.reduce((m, t) => (t.may ? meet(m, t.may) : m), [-Infinity, Infinity]);
-        return {
-            lo: first.along - reach(first, -1),
-            hi: last.along + reach(last, 1),
-            c: row.reduce((sum, t) => sum + t.c, 0) / row.length,
-            may: may[0] <= may[1] ? may : [row[0].c, row[row.length - 1].c],
-        };
-    });
-    const overlap = (i, j) => span[j].lo <= span[i].hi && span[i].lo <= span[j].hi;
-    // Rows come in order across, so an aisle's first row is its lowest: a row joins the nearest aisle
-    // whose first row is within `snap`, else starts one.
-    const aisles = [];
-    for (let i = 0; i < rows.length; i++) {
-        let home;
-        for (let k = aisles.length - 1; k >= 0 && span[i].c - span[aisles[k].rows[0]].c <= snap; k--) {
-            const may = meet(aisles[k].may, span[i].may);
-            if (may[0] <= may[1] && aisles[k].rows.some((j) => overlap(i, j))) {
-                home = aisles[k];
-                home.may = may;
-                break;
-            }
-        }
-        if (home)
-            home.rows.push(i);
-        else
-            aisles.push({ rows: [i], may: span[i].may });
-    }
-    return aisles.map(({ rows: members, may }) => {
-        const all = members.flatMap((i) => rows[i]);
-        const across = all.map((t) => t.c).sort((a, b) => a - b);
-        const ordered = [...all].sort((a, b) => a.along - b.along || a.c - b.c);
-        const median = across[Math.floor((across.length - 1) / 2)];
-        return {
-            c: Math.min(Math.max(median, may[0]), may[1]),
-            lo: Math.min(...members.map((i) => span[i].lo)),
-            hi: Math.max(...members.map((i) => span[i].hi)),
-            tips: ordered,
-        };
-    });
-}

package/dist/lib/blockers.d.ts

@@ -1,134 +0,0 @@
-import type { Doorway } from './doorways.js';
-import type { Box, Ring, Segment } from './geom/types.js';
-import { type RouteNetworkDestination } from './graph-types.js';
-/** What a straight run may not cross: walls, outlines of non-crossable destinations, doorway gaps. */
-export interface Blockers {
-    /** Wall segments. */
-    readonly walls: readonly Segment[];
-    /** Outline edges of every destination not walked through, by id. */
-    readonly solid: readonly {
-        readonly id: string;
-        readonly edges: readonly Segment[];
-    }[];
-    /** Doorway gaps; a stub from a face may not pass through one. */
-    readonly gaps: readonly Segment[];
-    /** Destinations entered through doorways: the walls they line stand in for their outlines. */
-    readonly walled: ReadonlySet<string>;
-    /** Wall spans an entrance's dock may cross — its openings — by the entrance's id. */
-    readonly passes?: ReadonlyMap<string, readonly Segment[]>;
-}
-/** What a blocker segment is. */
-export declare enum BlockerKind {
-    Wall = 0,
-    Solid = 1,
-    Gap = 2
-}
-/**
- * Blocker segments bucketed by the cells their bounds cover. It only narrows the candidates: a segment it
- * leaves out has bounds apart from the query's, so no test could hold for it.
- */
-export declare class SegmentGrid {
-    /** Every blocker segment, in {@link Blockers} order: walls, then outlines, then gaps. */
-    readonly segs: Segment[];
-    /** What each segment is. */
-    readonly from: BlockerKind[];
-    /** Owning destination of a solid edge; empty for walls and gaps. */
-    readonly owner: string[];
-    private readonly cells;
-    private readonly seen;
-    private stamp;
-    /** Bounds of the filed cells, so a ray knows when it has left them all. */
-    private c0;
-    private c1;
-    private r0;
-    private r1;
-    constructor(blockers: Blockers);
-    private cover;
-    /**
-     * Walk the cells a ray passes through, nearest first, handing each segment once.
-     * @param ox Ray origin x.
-     * @param oy Ray origin y.
-     * @param nx Ray direction x.
-     * @param ny Ray direction y.
-     * @param from Ray parameter to start at.
-     * @param visit Gets a cell's new segments and the parameter where the ray leaves it; true stops.
-     */
-    alongRay(ox: number, oy: number, nx: number, ny: number, from: number, visit: (ids: readonly number[], leaves: number) => boolean): void;
-    /**
-     * Segments whose bounds meet a box, each once, in {@link Blockers} order.
-     * @param x0 Box min x.
-     * @param y0 Box min y.
-     * @param x1 Box max x.
-     * @param y1 Box max y.
-     * @returns Their positions in {@link segs}.
-     */
-    near(x0: number, y0: number, x1: number, y1: number): number[];
-    /**
-     * Whether a segment crosses any blocker of one kind (exact `segmentsCross` on the candidates).
-     * @param seg The segment.
-     * @param from Blocker kind.
-     * @param except Destination whose own edges do not count.
-     * @returns True when one crosses it.
-     */
-    crosses(seg: Segment, from: BlockerKind, except?: string): boolean;
-    /**
-     * The blockers of one kind a segment crosses (exact `segmentsCross` on the candidates).
-     * @param seg The segment.
-     * @param from Blocker kind.
-     * @param except Destination whose own edges do not count.
-     * @returns The blockers crossed.
-     */
-    crossing(seg: Segment, from: BlockerKind, except?: string): Segment[];
-}
-/**
- * Walls and outlines whose bounds meet a box.
- * @param blockers The blockers.
- * @param box The box.
- * @returns Each segment with its owning destination; no owner for a wall.
- */
-export declare function blockersNear(blockers: Blockers, box: Box): {
-    readonly seg: Segment;
-    readonly owner?: string;
-}[];
-/**
- * The index of a blockers object, built once and kept with it.
- * @param blockers The blockers.
- * @returns Their index.
- */
-export declare function blockerGrid(blockers: Blockers): SegmentGrid;
-/**
- * Whether a segment crosses a wall, a closed doorway side or the outline of a destination nobody
- * walks through: the rule every network line keeps.
- * @param blockers The blockers.
- * @param seg The segment.
- * @returns True when it crosses one.
- */
-export declare function crossesBlocker(blockers: Blockers, seg: Segment): boolean;
-/**
- * What a run out of a destination may not cross, read once for the layer.
- * @param destinations Every destination on the layer.
- * @param walls The layer's wall segments.
- * @param doors The layer's doorways.
- * @param drawn The rest of each destination's drawing, by the destination's id.
- * @param walled Destinations entered through doorways: the walls they line stand in for them.
- * @param passes Wall spans an entrance's dock may cross, by the entrance's id.
- * @returns The blockers.
- */
-export declare function blockersOf(destinations: readonly RouteNetworkDestination[], walls: readonly Segment[], doors: readonly Doorway[], drawn?: readonly {
-    readonly id: string;
-    readonly ring: Ring;
-}[], walled?: ReadonlySet<string>, passes?: ReadonlyMap<string, readonly Segment[]>): Blockers;
-/**
- * How far a ray runs before it meets a blocker, by exact intersection, and what it met.
- * @param ox Ray origin x.
- * @param oy Ray origin y.
- * @param nx Ray direction x.
- * @param ny Ray direction y.
- * @param ownId Destination the ray leaves.
- * @param own `'skip'` ignores its outline; `'ahead'` counts only the outline ahead of the start.
- * @param withGaps Whether a doorway gap stops the ray.
- * @param blockers What the ray may meet.
- * @returns The distance, or `Infinity` when the ray meets nothing.
- */
-export declare function freeRun(ox: number, oy: number, nx: number, ny: number, ownId: string, own: 'skip' | 'ahead', withGaps: boolean, blockers: Blockers): number;
-//# sourceMappingURL=blockers.d.ts.map