@expofp/wayfinding-compiler 0.0.0-bootstrap.0 → 0.0.0-stage

package/dist/lib/entries.d.ts

@@ -1,123 +0,0 @@
-import { type Blockers } from './blockers.js';
-import type { DoorSide } from './doorways.js';
-import type { Frame } from './geom/frames.js';
-import type { Vec2 } from './geom/types.js';
-import { type RouteNetworkDestination } from './graph-types.js';
-import { type NetworkSizes } from './network-sizes.js';
-/** A stub grown from one face: the foot it leaves from and the tip it reaches. */
-export interface Whisker {
-    /** Destination id. */
-    readonly id: string;
-    /** Way-in kind it grew from. */
-    readonly kind: WayIn['kind'];
-    /** Foot x, on the face. */
-    readonly mx: number;
-    /** Foot y. */
-    readonly my: number;
-    /** Tip x. */
-    tx: number;
-    /** Tip y. */
-    ty: number;
-    /** Unit normal out of the destination, x. */
-    readonly nx: number;
-    /** Normal y. */
-    readonly ny: number;
-    /** Dock end, from {@link WayIn.to}. */
-    readonly to: Vec2;
-    /** Dock side, from {@link WayIn.edge}. */
-    readonly edge?: number;
-    /** Direction the destination is drawn in; none for a stand set at its own angle. */
-    readonly frame?: Frame;
-}
-/**
- * The tips of whiskers.
- * @param list The whiskers.
- * @returns One point per whisker.
- */
-export declare function tipPoints(list: readonly Whisker[]): Vec2[];
-/**
- * Moves tips whose vertex was merged into another by noding.
- * @param list The whiskers.
- * @param moved New position by old tip key.
- */
-export declare function followTips(list: readonly Whisker[], moved: ReadonlyMap<string, Vec2>): void;
-/** One way into a destination: where its stub leaves and which way. */
-export interface WayIn {
-    /** A side of the outline or dock ring, or one of its doorways. */
-    readonly kind: 'face' | 'door';
-    /** Foot x: where a dock side's normal meets the outline, or the doorway's middle. */
-    readonly mx: number;
-    /** Foot y. */
-    readonly my: number;
-    /** Unit normal out of the destination, x. */
-    readonly nx: number;
-    /** Normal y. */
-    readonly ny: number;
-    /** Free run from the foot along the normal; `Infinity` when nothing stands ahead. */
-    readonly depth: number;
-    /**
-     * How far the aisle in front of the face reaches: to what stands across half its width or more (see
-     * {@link frontDepth}). Absent when nothing stands across.
-     */
-    readonly front?: number;
-    /** The destinations standing across the aisle, when something does. */
-    readonly across?: readonly string[];
-    /** The face's width: its side's length. */
-    readonly width: number;
-    /** Dock end, inside the dock ring (the outline when there is none). */
-    readonly to: Vec2;
-    /** Ring side the dock ends on. */
-    readonly edge?: number;
-}
-/**
- * Destinations whose outline the way in's ray meets within `reach`, before any wall. The own outline is
- * ignored.
- * @param way The way in, at its foot, pointing out.
- * @param ownId Destination the way in belongs to.
- * @param blockers What the ray may meet.
- * @param reach How far ahead to look.
- * @returns The ids, each once.
- */
-export declare function standingBefore(way: Pick<WayIn, 'mx' | 'my' | 'nx' | 'ny'>, ownId: string, blockers: Blockers, reach: number): string[];
-/**
- * Stub length with open floor ahead: half the free run, at most `cfg.stub`.
- * @param way The way in.
- * @param cfg Network sizes.
- * @returns The length.
- */
-export declare function stubLength(way: WayIn, cfg: NetworkSizes): number;
-/**
- * Every way into a destination: dock-ring sides (or outline edges) with room in front, then its doorways.
- * @param d The destination.
- * @param owners Doorway sides by the destination they open into.
- * @param blockers What a run out of it may not cross.
- * @param cfg Network sizes.
- * @param onFloor Whether a point is walkable floor.
- * @returns The ways in, faces first.
- */
-export declare function waysInto(d: RouteNetworkDestination, owners: ReadonlyMap<string, readonly DoorSide[]>, blockers: Blockers, cfg: NetworkSizes, onFloor?: (x: number, y: number) => boolean): WayIn[];
-/**
- * Whether a doorway dock turns at the doorway's middle: its end is off the tip–doorway line, and the
- * doorway stands clear of the destination's outline.
- * @param d The destination.
- * @param way The way in.
- * @param tip Where the dock leaves from.
- * @param to Where it ends.
- * @returns True when the dock turns at the doorway's middle.
- */
-export declare function turnsInDoorway(d: RouteNetworkDestination, way: Pick<WayIn, 'kind' | 'mx' | 'my'>, tip: Vec2, to: Vec2): boolean;
-/**
- * The way in's dock, when lawful: its end lies inside the ring the destination is reached through, and the run crosses no
- * wall, no other outline and, from a face, no doorway gap.
- * @param d The destination.
- * @param way The way in.
- * @param tip The stub's tip.
- * @param blockers What the run may not cross.
- * @param taken Ring sides already docked by this destination's other stubs.
- * @returns The dock end and ring side, or null.
- */
-export declare function dockFor(d: RouteNetworkDestination, way: Pick<WayIn, 'kind' | 'mx' | 'my' | 'nx' | 'ny' | 'to' | 'edge'>, tip: Vec2, blockers: Blockers, taken?: ReadonlySet<number>): {
-    to: Vec2;
-    edge?: number;
-} | null;
-//# sourceMappingURL=entries.d.ts.map

package/dist/lib/entries.js

@@ -1,448 +0,0 @@
-// Ways into a destination: the faces and doorways a stub leaves from, and where its dock ends.
-import { blockerGrid, BlockerKind, freeRun } from './blockers.js';
-import { pointKey } from './geom/point-key.js';
-import { onOutline, pointInRing, pointSegmentDistance, rayVsSegment, ringEdges, segmentsCross, signedArea, vertexMean, } from './geom/primitives.js';
-import { NODE_SNAP } from './graph-types.js';
-import { MIN_PASS } from './network-sizes.js';
-import { freeRunOf, frontDepth } from './strip.js';
-import { WALL_HALF_WIDTH } from './walkable.js';
-/**
- * The tips of whiskers.
- * @param list The whiskers.
- * @returns One point per whisker.
- */
-export function tipPoints(list) {
-    return list.map((w) => [w.tx, w.ty]);
-}
-/**
- * Moves tips whose vertex was merged into another by noding.
- * @param list The whiskers.
- * @param moved New position by old tip key.
- */
-export function followTips(list, moved) {
-    for (const w of list) {
-        const to = moved.get(pointKey(w.tx, w.ty));
-        if (to)
-            [w.tx, w.ty] = to;
-    }
-}
-/**
- * Where a dock through a doorway ends going in square: just past where the doorway's inward normal
- * enters the dock ring.
- * @param ring Convex ring to land in.
- * @param mx Doorway point x.
- * @param my Doorway point y.
- * @param nx Doorway normal x, out of the destination.
- * @param ny Doorway normal y, out of the destination.
- * @returns The dock end, or null when the normal misses the ring.
- */
-function dockTipOnNormal(ring, mx, my, nx, ny) {
-    // Ray into the destination: p(t) = m - n·t. Crossings behind the start tell whether it is already in
-    // the ring.
-    const hits = [];
-    const hit = [0, 0];
-    for (let i = 0; i < ring.length; i++) {
-        const a = ring[i];
-        const b = ring[(i + 1) % ring.length];
-        // An edge running along the ray is never crossed by it.
-        if (!rayVsSegment(hit, mx, my, -nx, -ny, a[0], a[1], b[0], b[1]))
-            continue;
-        const [t, s] = hit;
-        if (s >= 0 && s <= 1)
-            hits.push(t);
-    }
-    // A ray through a vertex crosses both edges that meet there, at one distance: that is one crossing.
-    const once = hits.sort((a, b) => a - b).filter((t, i, all) => i === 0 || t - all[i - 1] > 1e-9);
-    const ahead = once.filter((t) => t > NODE_SNAP);
-    if (!ahead.length)
-        return null;
-    // A ring drawn as the footprint or wider holds the doorway already: the stub only has to go far enough
-    // in to read as inside. Otherwise it enters at the first crossing.
-    const inRing = once.some((t) => Math.abs(t) <= NODE_SNAP) || once.filter((t) => t < -NODE_SNAP).length % 2;
-    const near = inRing ? 0 : ahead[0];
-    // Where the ray leaves the ring (the far side, for a convex ring).
-    const far = (inRing ? ahead[0] : ahead[1]) ?? near;
-    // Just past the near edge: clear of a wall drawn along it, so containment never reads the tip as on the
-    // boundary, and short of crossing the footprint. Half the span when the ring is shallower.
-    const t = Math.min(near + WALL_HALF_WIDTH * 2, (near + far) / 2);
-    return [+(mx - nx * t).toFixed(2), +(my - ny * t).toFixed(2)];
-}
-/**
- * Whether a segment crosses a wall where a pass spans it: an entrance's dock goes through the wall
- * inside its opening and nowhere else.
- * @param leg The segment.
- * @param wall The wall it crosses.
- * @param passes The spans it may cross.
- * @returns True when the crossing lies on one of the passes.
- */
-function crossesAtPass(leg, wall, passes) {
-    const hit = [0, 0];
-    if (!rayVsSegment(hit, leg[0], leg[1], leg[2] - leg[0], leg[3] - leg[1], ...wall))
-        return false;
-    const x = leg[0] + (leg[2] - leg[0]) * hit[0];
-    const y = leg[1] + (leg[3] - leg[1]) * hit[0];
-    return passes.some((pass) => pointSegmentDistance(x, y, ...pass) <= WALL_HALF_WIDTH);
-}
-/**
- * Whether a stub stays within its destination: it crosses no wall but through a pass of its own, and
- * crosses the outline at most once (a concave footprint would otherwise be left and re-entered
- * through its notch).
- * @param d The destination; none to skip the outline check.
- * @param chain The stub as emitted, from the whisker tip inward.
- * @param grid The blockers' index.
- * @param passes Wall spans the destination's dock may cross: an entrance's openings.
- * @returns True when the stub is clear.
- */
-function stubIsClear(d, chain, grid, passes = []) {
-    const poly = d?.polygon ?? [];
-    let outline = 0;
-    for (let k = 0; k + 1 < chain.length; k++) {
-        const leg = [chain[k][0], chain[k][1], chain[k + 1][0], chain[k + 1][1]];
-        if (grid.crossing(leg, BlockerKind.Wall).some((wall) => !crossesAtPass(leg, wall, passes)))
-            return false;
-        for (let i = 0; i < poly.length; i++) {
-            const a = poly[i];
-            const b = poly[(i + 1) % poly.length];
-            if (segmentsCross(leg, [a[0], a[1], b[0], b[1]]))
-                outline++;
-        }
-    }
-    return outline <= 1;
-}
-/**
- * Destinations whose outline the way in's ray meets within `reach`, before any wall. The own outline is
- * ignored.
- * @param way The way in, at its foot, pointing out.
- * @param ownId Destination the way in belongs to.
- * @param blockers What the ray may meet.
- * @param reach How far ahead to look.
- * @returns The ids, each once.
- */
-export function standingBefore(way, ownId, blockers, reach) {
-    const hit = [0, 0];
-    const along = (seg, from) => {
-        if (!rayVsSegment(hit, way.mx, way.my, way.nx, way.ny, seg[0], seg[1], seg[2], seg[3]))
-            return Infinity;
-        const [t, u] = hit;
-        return u < -1e-9 || u > 1 + 1e-9 || t <= from ? Infinity : Math.max(0, t);
-    };
-    // Nearest wall along the ray: anything past it is not in the way.
-    let wall = reach;
-    for (const seg of blockers.walls)
-        wall = Math.min(wall, along(seg, -NODE_SNAP));
-    const found = new Set();
-    for (const poi of blockers.solid) {
-        if (poi.id === ownId)
-            continue;
-        for (const edge of poi.edges)
-            if (along(edge, -NODE_SNAP) <= wall)
-                found.add(poi.id);
-    }
-    return [...found];
-}
-/**
- * Stub length with open floor ahead: half the free run, at most `cfg.stub`.
- * @param way The way in.
- * @param cfg Network sizes.
- * @returns The length.
- */
-export function stubLength(way, cfg) {
-    return Math.min(cfg.stub, way.depth / 2);
-}
-/**
- * Ways in laid from a ring (the dock ring, or the outline when there is none): the dock ends at each
- * side's middle and the side's outward normal carries it to the outline, where the foot stands — dock end,
- * foot and tip on one line. A side is dropped when that line crosses a wall or another outline, or the
- * outline is blocked where the line leaves it.
- * @param d The destination.
- * @param dock Ring the ways in are laid from.
- * @param blockers What stands around it.
- * @param minSide Shorter sides hold no stub.
- * @param freeMiddle Use the middle of a side's free part rather than of its length.
- * @returns The ways in, at most one per side.
- */
-function dockFaces(d, dock, blockers, minSide, freeMiddle) {
-    const ccw = signedArea(dock) > 0;
-    // A crossable destination is floor up to its dock ring, so the ring is its outline.
-    const poly = d.crossable ? dock : d.polygon;
-    const out = [];
-    const hit = [0, 0];
-    for (const [index, edge] of ringEdges(dock).entries()) {
-        const ex = edge[2] - edge[0];
-        const ey = edge[3] - edge[1];
-        const el = Math.hypot(ex, ey);
-        if (!el || el < minSide)
-            continue;
-        const s = ccw ? 1 : -1;
-        const nx = (s * ey) / el;
-        const ny = (s * -ex) / el;
-        // On the own outline, enter a face half taken by a neighbor where it is still open.
-        const free = freeMiddle ? freeRunOf(edge, [-nx, -ny], blockers, d.id) : [0, 1];
-        const open = (free[1] - free[0]) * el >= 2 * MIN_PASS ? free : [0, 1];
-        const along = (open[0] + open[1]) / 2;
-        const on = [edge[0] + ex * along, edge[1] + ey * along];
-        const inset = Math.min(WALL_HALF_WIDTH * 2, acrossRing(dock, on, [-nx, -ny], index) / 2);
-        const to = [+(on[0] - nx * inset).toFixed(2), +(on[1] - ny * inset).toFixed(2)];
-        // Where the normal leaves the footprint and through which edge; a side on or outside the outline has
-        // its foot on itself.
-        const hits = [];
-        for (let i = 0; i < poly.length; i++) {
-            const a = poly[i];
-            const b = poly[(i + 1) % poly.length];
-            if (!rayVsSegment(hit, on[0], on[1], nx, ny, a[0], a[1], b[0], b[1]))
-                continue;
-            const [t, u] = hit;
-            if (u >= 0 && u <= 1 && t >= -NODE_SNAP)
-                hits.push({ t: Math.max(0, t), i });
-        }
-        hits.sort((p, q) => p.t - q.t);
-        const inside = pointInRing(poly, on) || (hits.length > 0 && hits[0].t <= NODE_SNAP);
-        const leave = inside ? hits[0] : undefined;
-        if (inside && !leave)
-            continue;
-        const t = leave?.t ?? 0;
-        const mx = +(on[0] + nx * t).toFixed(2);
-        const my = +(on[1] + ny * t).toFixed(2);
-        const body = [to[0], to[1], mx, my];
-        const grid = blockerGrid(blockers);
-        if (grid.crosses(body, BlockerKind.Wall))
-            continue;
-        // A dock side drawn past the footprint counts only when no wall separates it from the destination.
-        if (!inside) {
-            const middle = vertexMean(d.polygon);
-            const across = [to[0], to[1], middle[0], middle[1]];
-            if (grid.crosses(across, BlockerKind.Wall))
-                continue;
-        }
-        if (grid.crosses(body, BlockerKind.Solid, d.id))
-            continue;
-        // A person's width of outline around the foot must be open.
-        const side = leave
-            ? [poly[leave.i][0], poly[leave.i][1], ...poly[(leave.i + 1) % poly.length]]
-            : edge;
-        const sx = side[2] - side[0];
-        const sy = side[3] - side[1];
-        const sl = Math.hypot(sx, sy);
-        const at = ((mx - side[0]) * sx + (my - side[1]) * sy) / (sl * sl);
-        const lo = Math.max(0, at - MIN_PASS / sl);
-        const hi = Math.min(1, at + MIN_PASS / sl);
-        const window = [
-            side[0] + sx * lo,
-            side[1] + sy * lo,
-            side[0] + sx * hi,
-            side[1] + sy * hi,
-        ];
-        const wl = Math.hypot(window[2] - window[0], window[3] - window[1]);
-        const seen = wl ? freeRunOf(window, [-nx, -ny], blockers, d.id) : [0, 0];
-        if (seen[1] - seen[0] < 1 - 1e-6)
-            continue;
-        const depth = freeRun(mx, my, nx, ny, d.id, d.crossable ? 'skip' : 'ahead', true, blockers);
-        const { depth: front, across } = frontDepth(side, [nx, ny], blockers, d.id, depth);
-        out.push({
-            kind: 'face',
-            mx,
-            my,
-            nx,
-            ny,
-            depth,
-            ...(isFinite(front) && { front, across }),
-            width: sl,
-            to,
-            edge: index,
-        });
-    }
-    return out;
-}
-/**
- * A dock end on the ring side facing a point, just inside: the nearest point (a person's width clear of
- * the corners) or the side's middle.
- * @param ring The dock ring.
- * @param from The point faced.
- * @param nearest Nearest point rather than the middle.
- * @returns The dock end, or null when no side faces the point.
- */
-function sideFacing(ring, from, nearest) {
-    const ccw = signedArea(ring) > 0;
-    let best = null;
-    for (const [index, edge] of ringEdges(ring).entries()) {
-        const ex = edge[2] - edge[0];
-        const ey = edge[3] - edge[1];
-        const el = Math.hypot(ex, ey);
-        if (!el)
-            continue;
-        const s = ccw ? 1 : -1;
-        const nx = (s * ey) / el;
-        const ny = (s * -ex) / el;
-        const margin = nearest ? Math.min(el / 2, MIN_PASS) : el / 2;
-        const along = Math.min(el - margin, Math.max(margin, ((from[0] - edge[0]) * ex + (from[1] - edge[1]) * ey) / el));
-        const on = [edge[0] + (ex * along) / el, edge[1] + (ey * along) / el];
-        const score = (from[0] - on[0]) * nx + (from[1] - on[1]) * ny;
-        if (score <= 0 || (best && score <= best.score))
-            continue;
-        const inset = Math.min(WALL_HALF_WIDTH * 2, acrossRing(ring, on, [-nx, -ny], index) / 2);
-        best = { score, to: [+(on[0] - nx * inset).toFixed(2), +(on[1] - ny * inset).toFixed(2)] };
-    }
-    return best?.to ?? null;
-}
-/**
- * Where a dock through a doorway ends: square along its normal when that enters the ring; otherwise on the
- * side facing the doorway — at the nearest point when lawful, else at the middle.
- * @param dock The dock ring.
- * @param from Doorway point the dock leaves from.
- * @param nx Doorway normal x, out of the destination.
- * @param ny Doorway normal y, out of the destination.
- * @param lawful Whether a dock may run to a point.
- * @returns The dock end, or null when no side faces the doorway.
- */
-function doorDockEnd(dock, from, nx, ny, lawful) {
-    const square = dockTipOnNormal(dock, from[0], from[1], nx, ny);
-    if (square)
-        return square;
-    const near = sideFacing(dock, from, true);
-    return near && lawful(near) ? near : sideFacing(dock, from, false);
-}
-/**
- * Every way into a destination: dock-ring sides (or outline edges) with room in front, then its doorways.
- * @param d The destination.
- * @param owners Doorway sides by the destination they open into.
- * @param blockers What a run out of it may not cross.
- * @param cfg Network sizes.
- * @param onFloor Whether a point is walkable floor.
- * @returns The ways in, faces first.
- */
-export function waysInto(d, owners, blockers, cfg, onFloor = () => true) {
-    const out = [];
-    // Faces are read once; the strict and fallback passes below only filter them. Without a dock ring the
-    // outline is used, and its short sides (a curve's) hold no stub.
-    const ring = d.dock && d.dock.length >= 3 ? d.dock : d.polygon;
-    const own = ring !== d.dock;
-    const faces = ring.length >= 3 ? dockFaces(d, ring, blockers, own ? cfg.pitch : 0, own) : [];
-    if (faces.length) {
-        // An endless run may just be off the walkable area: check the floor where the stub would stand.
-        const standsOnFloor = (way) => {
-            const run = stubLength(way, cfg);
-            return onFloor(way.mx + way.nx * run, way.my + way.ny * run);
-        };
-        const collect = (minDepth) => faces.filter((way) => way.depth >= minDepth && standsOnFloor(way));
-        // Strict first (nothing within `open` ahead); fall back to `clear` for a tightly packed destination.
-        const strict = collect(cfg.open);
-        out.push(...(strict.length ? strict : collect(cfg.clear)));
-    }
-    // Doorways: the own outline does not stop the run (a footprint over its own wall is an overshot carve).
-    for (const { door, nx, ny } of owners.get(d.id) ?? []) {
-        // The nearest point only suits a dock that turns in the doorway.
-        const lawful = (at) => {
-            const way = { kind: 'door', mx: door.mid[0], my: door.mid[1], nx, ny, to: at };
-            const tip = [door.mid[0] + nx, door.mid[1] + ny];
-            return turnsInDoorway(d, way, tip, at) && dockFor(d, way, tip, blockers) !== null;
-        };
-        const to = ring.length >= 3 ? doorDockEnd(ring, door.mid, nx, ny, lawful) : null;
-        if (!to)
-            continue;
-        const depth = freeRun(door.mid[0], door.mid[1], nx, ny, d.id, 'skip', false, blockers);
-        // The aisle ahead is read over the doorway's width; the face is the footprint side it opens from.
-        const { depth: front, across } = frontDepth(door.gap, [nx, ny], blockers, d.id, depth);
-        const sides = ringEdges(d.polygon);
-        const side = sides[edgeNearest(sides, door.mid)];
-        out.push({
-            kind: 'door',
-            mx: door.mid[0],
-            my: door.mid[1],
-            nx,
-            ny,
-            depth,
-            ...(isFinite(front) && { front, across }),
-            width: Math.hypot(side[2] - side[0], side[3] - side[1]),
-            to,
-            edge: edgeNearest(ringEdges(ring), to),
-        });
-    }
-    return out;
-}
-/**
- * How far a ring reaches straight in from a point on one of its sides.
- * @param ring The ring.
- * @param from The point, on `side`.
- * @param inward The side's inward unit normal.
- * @param side Side the point stands on; not counted.
- * @returns Distance to the nearest other side; 0 when none is met.
- */
-function acrossRing(ring, from, inward, side) {
-    const hit = [0, 0];
-    let near = Infinity;
-    for (let i = 0; i < ring.length; i++) {
-        if (i === side)
-            continue;
-        const a = ring[i];
-        const b = ring[(i + 1) % ring.length];
-        if (!rayVsSegment(hit, from[0], from[1], inward[0], inward[1], a[0], a[1], b[0], b[1]))
-            continue;
-        const [t, u] = hit;
-        if (u >= 0 && u <= 1 && t > NODE_SNAP && t < near)
-            near = t;
-    }
-    return isFinite(near) ? near : 0;
-}
-/**
- * The ring edge nearest a point.
- * @param edges The ring's edges.
- * @param at The point.
- * @returns Its index.
- */
-function edgeNearest(edges, at) {
-    let best = 0;
-    let near = Infinity;
-    for (const [i, e] of edges.entries()) {
-        const d = pointSegmentDistance(at[0], at[1], e[0], e[1], e[2], e[3]);
-        if (d < near) {
-            near = d;
-            best = i;
-        }
-    }
-    return best;
-}
-/**
- * Whether a doorway dock turns at the doorway's middle: its end is off the tip–doorway line, and the
- * doorway stands clear of the destination's outline.
- * @param d The destination.
- * @param way The way in.
- * @param tip Where the dock leaves from.
- * @param to Where it ends.
- * @returns True when the dock turns at the doorway's middle.
- */
-export function turnsInDoorway(d, way, tip, to) {
-    return (way.kind === 'door' &&
-        pointSegmentDistance(way.mx, way.my, tip[0], tip[1], to[0], to[1]) > NODE_SNAP &&
-        !pointInRing(d.polygon, [way.mx, way.my]) &&
-        !onOutline(d.polygon, way.mx, way.my, NODE_SNAP));
-}
-/**
- * The way in's dock, when lawful: its end lies inside the ring the destination is reached through, and the run crosses no
- * wall, no other outline and, from a face, no doorway gap.
- * @param d The destination.
- * @param way The way in.
- * @param tip The stub's tip.
- * @param blockers What the run may not cross.
- * @param taken Ring sides already docked by this destination's other stubs.
- * @returns The dock end and ring side, or null.
- */
-export function dockFor(d, way, tip, blockers, taken) {
-    const ring = d.dock ?? d.polygon;
-    const to = way.to;
-    // One face stub per ring side; doorways are exempt.
-    if (ring.length < 3 || (way.kind === 'face' && way.edge !== undefined && taken?.has(way.edge)))
-        return null;
-    if (!pointInRing(ring, to))
-        return null;
-    const run = [tip[0], tip[1], to[0], to[1]];
-    // A turning doorway dock runs through the doorway's middle first.
-    const chain = turnsInDoorway(d, way, tip, to) ? [tip, [way.mx, way.my], to] : [tip, to];
-    const grid = blockerGrid(blockers);
-    if (!stubIsClear(d.crossable ? undefined : d, chain, grid, blockers.passes?.get(d.id)))
-        return null;
-    if (chain.slice(1).some((p, k) => grid.crosses([...chain[k], ...p], BlockerKind.Solid, d.id)))
-        return null;
-    if (way.kind === 'face' && grid.crosses(run, BlockerKind.Gap))
-        return null;
-    return { to, edge: way.edge };
-}

package/dist/lib/floor-grids.d.ts

@@ -1,48 +0,0 @@
-import { type DoorSide, type Doorway } from './doorways.js';
-import { type Frame } from './geom/frames.js';
-import type { Ring, Segment } from './geom/types.js';
-import { type RouteNetworkDestination } from './graph-types.js';
-import { type NetworkSizes } from './network-sizes.js';
-import type { Grid } from './router.js';
-/**
- * The floor pieces a route can serve: an outer ring (with its holes) is kept when a destination or
- * transition stop stands in it, or a doorway into a destination opens onto it.
- * @param rings Walkable outer rings and holes (holes wound the other way).
- * @param destinations The layer's destinations, transition stops included.
- * @param owners Doorway sides by the destination they open into.
- * @returns The rings kept, and how many outer rings were left out.
- */
-export declare function servedFloor(rings: readonly Ring[], destinations: readonly RouteNetworkDestination[], owners: ReadonlyMap<string, readonly DoorSide[]>): {
-    rings: Ring[];
-    dropped: number;
-};
-/** The grids a layer's network is walked on, and the direction each destination is drawn in. */
-interface FloorGrids {
-    /** One grid per direction that got one, the plan's first. */
-    readonly grids: Grid[];
-    /** The directions that got a grid; every pass works in these. */
-    readonly frames: Frame[];
-    /**
-     * The direction a destination is drawn in; none for one reached on the plan's grid, which gets no
-     * framing and holds every line at its tips.
-     */
-    readonly frameOfDest: (d: RouteNetworkDestination) => Frame | undefined;
-}
-/**
- * One grid per direction the destinations are drawn in, walked as one raster, so a turned hall's
- * aisles run straight on its own grid. The plan's grid covers the whole floor; a turned direction's
- * grid covers its groups of two or more destinations whose reaches (a stub around each) meet and
- * which stand in a hall turned their way. A lone turned stand, or stands turned in a hall drawn
- * square, get no grid. Every doorway's throat is passable at its middle on every grid, however
- * narrow the gap: routes and lines pass there, and only there; the jambs stay closed.
- * @param floor The floor pieces a route can serve.
- * @param doorSides The closed sides of the doorways, masked like walls.
- * @param destinations The layer's destinations.
- * @param wallLines The layer's wall segments.
- * @param doors The layer's doorways.
- * @param cfg Network sizes.
- * @returns The grids, their directions, and each destination's direction.
- */
-export declare function floorGrids(floor: readonly Ring[], doorSides: readonly Segment[], destinations: readonly RouteNetworkDestination[], wallLines: readonly Segment[], doors: readonly Doorway[], cfg: NetworkSizes): FloorGrids;
-export {};
-//# sourceMappingURL=floor-grids.d.ts.map