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

package/dist/lib/floor-grids.js

@@ -1,185 +0,0 @@
-// The floor a layer's network grows over: the walkable pieces a route can serve, and one router grid
-// per direction the destinations are drawn in — the plan's over the whole floor, a turned direction's
-// over the halls turned its way.
-import { rayHit } from './doorways.js';
-import { frameRunning, framesOf, PLAN, toFrame, turnedInto } from './geom/frames.js';
-import { boundsOf, boxesOverlap, outerRingsOf, pointInRing, signedArea, vertexMean, } from './geom/primitives.js';
-import { NODE_SNAP } from './graph-types.js';
-import { buildMaskCtx, openDoorMiddle } from './mask.js';
-import { MIN_PASS } from './network-sizes.js';
-import { standsOn, WALL_HALF_WIDTH } from './walkable.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 function servedFloor(rings, destinations, owners) {
-    const pieces = outerRingsOf(rings);
-    const reach = WALL_HALF_WIDTH + MIN_PASS;
-    const atDoors = [];
-    for (const sides of owners.values())
-        for (const { door } of sides)
-            for (const s of [1, -1])
-                atDoors.push([door.mid[0] + door.nx * s * reach, door.mid[1] + door.ny * s * reach]);
-    // A destination stands on a piece within `NODE_SNAP` of it at most: boxes apart rule the pair out
-    // before the piece's contour is walked.
-    const standing = destinations.map((d) => {
-        const ring = d.dock ?? d.polygon;
-        const [x0, y0, x1, y1] = boundsOf(ring);
-        return { ring, box: [x0 - NODE_SNAP, y0 - NODE_SNAP, x1 + NODE_SNAP, y1 + NODE_SNAP] };
-    });
-    const served = new Set(pieces.filter((piece) => {
-        const pieceBox = boundsOf(piece);
-        return (standing.some(({ ring, box }) => boxesOverlap(pieceBox, box) && standsOn(piece, ring)) ||
-            atDoors.some((p) => pointInRing(piece, p)));
-    }));
-    const kept = rings.filter((ring) => {
-        if (pieces.includes(ring))
-            return served.has(ring);
-        // A hole belongs to the smallest piece around it.
-        const around = pieces
-            .filter((piece) => pointInRing(piece, ring[0]))
-            .sort((a, b) => Math.abs(signedArea(a)) - Math.abs(signedArea(b)))[0];
-        return around !== undefined && served.has(around);
-    });
-    return { rings: kept, dropped: pieces.length - served.size };
-}
-/**
- * Groups rings whose bounds, grown by `reach`, meet.
- * @param rings The rings.
- * @param reach Growth of each ring's box.
- * @returns Each group's box and its ring indices.
- */
-function groupedBoxes(rings, reach) {
-    const groups = [];
-    rings.forEach((ring, index) => {
-        const [x0, y0, x1, y1] = boundsOf(ring);
-        let box = [x0 - reach, y0 - reach, x1 + reach, y1 + reach];
-        let members = [index];
-        let merged = true;
-        // Merge until stable: the grown box may meet groups it missed before.
-        while (merged) {
-            merged = false;
-            for (let i = groups.length - 1; i >= 0; i--)
-                if (boxesOverlap(box, groups[i].box)) {
-                    const g = groups.splice(i, 1)[0];
-                    box = [
-                        Math.min(box[0], g.box[0]),
-                        Math.min(box[1], g.box[1]),
-                        Math.max(box[2], g.box[2]),
-                        Math.max(box[3], g.box[3]),
-                    ];
-                    members = [...members, ...g.members];
-                    merged = true;
-                }
-        }
-        groups.push({ box, members });
-    });
-    return groups;
-}
-/**
- * Whether a group stands in a hall turned its way: of the walls seen from its stands — the first wall
- * along each of the direction's four ways from each stand's middle, however far — more length runs along
- * its direction than along the plan's axes, so the long walls that make the hall outweigh a column or a
- * jamb. Each wall is read as the raster can tell it over its length; one too short to tell the two apart
- * counts for neither.
- * @param stands The group's rings.
- * @param frame The direction.
- * @param walls The layer's wall segments.
- * @param cfg Network sizes.
- * @returns True for a turned hall.
- */
-function turnedHall(stands, frame, walls, cfg) {
-    const ways = [
-        [frame.cos, frame.sin],
-        [-frame.cos, -frame.sin],
-        [-frame.sin, frame.cos],
-        [frame.sin, -frame.cos],
-    ];
-    let own = 0;
-    let square = 0;
-    for (const ring of stands) {
-        const middle = vertexMean(ring);
-        for (const [dx, dy] of ways) {
-            const met = rayHit(middle, dx, dy, walls);
-            if (!met)
-                continue;
-            const [ax, ay, bx, by] = walls[met.index];
-            const [wx, wy] = [bx - ax, by - ay];
-            const length = Math.hypot(wx, wy);
-            const along = frameRunning([frame], wx, wy, cfg.cs, length) === 0;
-            const axial = frameRunning([PLAN], wx, wy, cfg.cs, length) === 0;
-            if (along && !axial)
-                own += length;
-            else if (axial && !along)
-                square += length;
-        }
-    }
-    return own > square;
-}
-/**
- * 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 function floorGrids(floor, doorSides, destinations, wallLines, doors, cfg) {
-    // Masked like walls: a two-point ring fills nothing but closes every cell it crosses.
-    const masked = [
-        ...floor,
-        ...doorSides.map(([x0, y0, x1, y1]) => [
-            [x0, y0],
-            [x1, y1],
-        ]),
-    ];
-    const directions = framesOf(destinations.map((d) => d.dock ?? d.polygon), cfg.cs);
-    // Each destination's direction. One without a frame is reached on the plan's grid, gets no
-    // framing, and holds every line at its tips.
-    const drawnIn = new Map();
-    const grids = [{ frame: directions[0].frame, ctx: buildMaskCtx(masked, cfg) }];
-    for (const ring of directions[0].rings)
-        drawnIn.set(ring, directions[0].frame);
-    for (const { frame, rings } of directions.slice(1)) {
-        const groups = groupedBoxes(turnedInto(rings, frame), cfg.stub).filter((group) => group.members.length >= 2 &&
-            turnedHall(group.members.map((i) => rings[i]), frame, wallLines, cfg));
-        if (!groups.length)
-            continue;
-        // One grid over all the direction's groups, so aisles between halls turned alike follow it too.
-        const box = groups.reduce((b, { box: g }) => [
-            Math.min(b[0], g[0]),
-            Math.min(b[1], g[1]),
-            Math.max(b[2], g[2]),
-            Math.max(b[3], g[3]),
-        ], groups[0].box);
-        grids.push({ frame, ctx: buildMaskCtx(turnedInto(masked, frame), cfg, box) });
-        for (const group of groups)
-            for (const i of group.members)
-                drawnIn.set(rings[i], frame);
-    }
-    const frameOfDest = (d) => drawnIn.get(d.dock ?? d.polygon);
-    // The directions that got a grid; every pass works in these.
-    const frames = [...new Set(grids.map((grid) => grid.frame))];
-    // Every doorway's throat is passable at its middle, however narrow the gap: routes and lines pass
-    // there, and only there. The jambs stay closed.
-    for (const door of doors) {
-        const width = Math.hypot(door.gap[2] - door.gap[0], door.gap[3] - door.gap[1]);
-        const throat = Math.min(MIN_PASS + cfg.cs, width / 2 - WALL_HALF_WIDTH);
-        if (throat <= 0)
-            continue;
-        for (const { frame, ctx: grid } of grids)
-            openDoorMiddle(grid, ...toFrame(frame, door.mid[0], door.mid[1]), throat);
-    }
-    return { grids, frames, frameOfDest };
-}

package/dist/lib/framing.d.ts

@@ -1,20 +0,0 @@
-import { type AisleAxis } from './axes.js';
-import { type Frame } from './geom/frames.js';
-import type { Segment } from './geom/types.js';
-import { type RouteNetworkDestination } from './graph-types.js';
-import type { NetworkStore } from './network-store.js';
-import type { Stub } from './stubs.js';
-/**
- * Framing, per direction: the row along each aisle's axis through its tips, and each destination's
- * tips chained into a perimeter (destinations with two or more stubs).
- * @param store The network; extended in place.
- * @param stubs The stubs of destinations that get framing.
- * @param destinations Their footprints, for the perimeter's angular order.
- * @param mayLay Whether a link may be laid.
- * @param frames The directions the layer is drawn in.
- * @param axisOf Each stub's aisle axis.
- * @param cs The raster cell: what it cannot tell apart lies on one line.
- * @param snap A corridor's width: an aisle's axis nearer than that to a rung's line joins its stubs itself.
- */
-export declare function frameTips(store: NetworkStore, stubs: readonly Stub[], destinations: readonly RouteNetworkDestination[], mayLay: (seg: Segment) => boolean, frames: readonly Frame[], axisOf: ReadonlyMap<Stub, AisleAxis>, cs: number, snap: number): void;
-//# sourceMappingURL=framing.d.ts.map

package/dist/lib/framing.js

@@ -1,187 +0,0 @@
-// Framing: the row along each aisle's axis through its tips, the rungs between stubs facing each
-// other across an aisle, and each destination's tips chained into a perimeter with square corners.
-import { aisleAxes, tipInFrame } from './axes.js';
-import { placeIn, toFrame } from './geom/frames.js';
-import { vertexMean } from './geom/primitives.js';
-import { NODE_SNAP } from './graph-types.js';
-/**
- * Framing, per direction: the row along each aisle's axis through its tips, and each destination's
- * tips chained into a perimeter (destinations with two or more stubs).
- * @param store The network; extended in place.
- * @param stubs The stubs of destinations that get framing.
- * @param destinations Their footprints, for the perimeter's angular order.
- * @param mayLay Whether a link may be laid.
- * @param frames The directions the layer is drawn in.
- * @param axisOf Each stub's aisle axis.
- * @param cs The raster cell: what it cannot tell apart lies on one line.
- * @param snap A corridor's width: an aisle's axis nearer than that to a rung's line joins its stubs itself.
- */
-export function frameTips(store, stubs, destinations, mayLay, frames, axisOf, cs, snap) {
-    for (const frame of frames)
-        frameTipsIn(store, stubs.filter((s) => s.frame === frame), destinations, mayLay, frame, axisOf, cs, snap);
-}
-/**
- * {@link frameTips} in one frame: coordinates are read and links laid along its axes.
- * @param store The network; extended in place.
- * @param stubs The stubs of this direction.
- * @param destinations Their footprints.
- * @param mayLay Whether a link may be laid.
- * @param frame The frame.
- * @param axisOf Each stub's aisle axis.
- * @param cs The raster cell: what it cannot tell apart lies on one line.
- * @param snap A corridor's width: an aisle's axis nearer than that to a rung's line joins its stubs itself.
- */
-function frameTipsIn(store, stubs, destinations, mayLay, frame, axisOf, cs, snap) {
-    const read = (x, y) => toFrame(frame, x, y);
-    const axes = [...new Set(axisOf.values())].filter((axis) => axis.frame === frame);
-    const place = (u, v) => placeIn(frame, u, v);
-    const free = (u0, v0, u1, v1) => mayLay([...place(u0, v0), ...place(u1, v1)]);
-    const addLink = (u0, v0, u1, v1) => {
-        if (Math.hypot(u1 - u0, v1 - v0) < 0.3)
-            return true;
-        if (!free(u0, v0, u1, v1))
-            return false;
-        store.add(...place(u0, v0), ...place(u1, v1));
-        return true;
-    };
-    // Rows: each aisle's line through its tips, laid between neighbors along it.
-    const byAxis = new Map();
-    /** Along span each axis's row was laid over: tips joined later widen it. */
-    const laidSpan = new Map();
-    for (const s of stubs) {
-        const axis = axisOf.get(s);
-        if (!axis)
-            continue;
-        const list = byAxis.get(axis);
-        if (list)
-            list.push(s);
-        else
-            byAxis.set(axis, [s]);
-    }
-    for (const [axis, list] of byAxis) {
-        const pts = list
-            .map((s) => {
-            const [u, v] = read(s.tx, s.ty);
-            return axis.horiz ? { along: u, c: v } : { along: v, c: u };
-        })
-            .sort((p, q) => p.along - q.along);
-        const at = (along, c) => axis.horiz ? [along, c] : [c, along];
-        if (pts.length >= 2)
-            laidSpan.set(axis, [pts[0].along, pts[pts.length - 1].along]);
-        for (let i = 0; i + 1 < pts.length; i++) {
-            const a = pts[i];
-            const b = pts[i + 1];
-            const gap = b.along - a.along;
-            if (gap <= NODE_SNAP)
-                continue;
-            if (!addLink(...at(a.along, axis.c), ...at(b.along, axis.c)))
-                continue;
-            // A tip that could not reach the axis gets a leg to it.
-            if (Math.abs(a.c - axis.c) > NODE_SNAP)
-                addLink(...at(a.along, a.c), ...at(a.along, axis.c));
-            if (Math.abs(b.c - axis.c) > NODE_SNAP)
-                addLink(...at(b.along, b.c), ...at(b.along, axis.c));
-        }
-    }
-    // Rungs: stubs that face each other on one line across an aisle are joined straight — the shortest
-    // way between the two stands, and the line both stubs run along. An aisle's axis running their way
-    // within a corridor's width hosts the rung: it lays onto that line (legs bring the tips over), and
-    // only the parts its row has not laid yet — one line per aisle, never a second one beside it.
-    const rungs = new Map();
-    for (const s of stubs) {
-        const { horiz, c, along } = tipInFrame(frame, s.tx, s.ty, s.nx, s.ny);
-        const [nu, nv] = read(s.nx, s.ny);
-        const list = rungs.get(!horiz) ?? [];
-        // On the line along the stub: across is where the stub stands, along is where its tip is.
-        list.push({ stub: s, c: along, along: c, out: Math.sign(horiz ? nv : nu) });
-        rungs.set(!horiz, list);
-    }
-    for (const [horiz, tips] of rungs)
-        for (const line of aisleAxes(tips, cs, 0, () => 0)) {
-            const at = (along, c) => (horiz ? [along, c] : [c, along]);
-            const hosts = axes
-                .filter((axis) => axis.horiz === horiz && Math.abs(axis.c - line.c) <= snap)
-                .sort((p, q) => Math.abs(p.c - line.c) - Math.abs(q.c - line.c));
-            const host = hosts[0];
-            const c = host ? host.c : line.c;
-            for (let i = 0; i + 1 < line.tips.length; i++) {
-                const a = line.tips[i];
-                const b = line.tips[i + 1];
-                const gap = b.along - a.along;
-                // Facing: each stub points at the other.
-                if (a.out <= 0 || b.out >= 0 || gap <= NODE_SNAP)
-                    continue;
-                const row = host && laidSpan.get(host);
-                // The parts the host's row has not laid yet.
-                const parts = [];
-                if (row && row[0] < b.along && a.along < row[1]) {
-                    if (a.along < row[0])
-                        parts.push([a.along, row[0]]);
-                    if (row[1] < b.along)
-                        parts.push([row[1], b.along]);
-                }
-                else
-                    parts.push([a.along, b.along]);
-                let laid = true;
-                for (const [from, to] of parts)
-                    if (to - from > NODE_SNAP)
-                        laid = addLink(...at(from, c), ...at(to, c)) && laid;
-                if (!laid)
-                    continue;
-                if (host)
-                    laidSpan.set(host, [
-                        Math.min(row ? row[0] : a.along, a.along),
-                        Math.max(row ? row[1] : b.along, b.along),
-                    ]);
-                if (Math.abs(a.c - c) > NODE_SNAP)
-                    addLink(...at(a.along, a.c), ...at(a.along, c));
-                if (Math.abs(b.c - c) > NODE_SNAP)
-                    addLink(...at(b.along, b.c), ...at(b.along, c));
-            }
-        }
-    // Perimeter: chain each destination's tips in angular order, with axis L-corners.
-    const byPoi = new Map();
-    for (const w of stubs) {
-        const [qx, qy] = read(w.tx, w.ty);
-        // Direction from the face normal: a short stub's rounded run would be zero.
-        const [nu, nv] = read(w.nx, w.ny);
-        if (!byPoi.has(w.id))
-            byPoi.set(w.id, []);
-        byPoi.get(w.id).push({
-            qx,
-            qy,
-            nx: Math.round(nu),
-            ny: Math.round(nv),
-        });
-    }
-    const destById = new Map(destinations.map((d) => [d.id, d]));
-    for (const [id, tips] of byPoi) {
-        if (tips.length < 2)
-            continue;
-        const d = destById.get(id);
-        if (!d)
-            continue;
-        const [cx, cy] = read(...vertexMean(d.polygon));
-        tips.sort((a, b) => Math.atan2(a.qy - cy, a.qx - cx) - Math.atan2(b.qy - cy, b.qx - cx));
-        for (let i = 0; i < tips.length; i++) {
-            if (tips.length === 2 && i === 1)
-                break;
-            const a = tips[i];
-            const b = tips[(i + 1) % tips.length];
-            if (Math.abs(a.qx - b.qx) <= cs || Math.abs(a.qy - b.qy) <= cs) {
-                addLink(a.qx, a.qy, b.qx, b.qy);
-                continue;
-            }
-            const hTip = a.ny !== 0 ? a : b.ny !== 0 ? b : null;
-            const vTip = a.nx !== 0 ? a : b.nx !== 0 ? b : null;
-            if (!hTip || !vTip || hTip === vTip)
-                continue;
-            if (!free(hTip.qx, hTip.qy, vTip.qx, hTip.qy))
-                continue;
-            if (!free(vTip.qx, hTip.qy, vTip.qx, vTip.qy))
-                continue;
-            addLink(hTip.qx, hTip.qy, vTip.qx, hTip.qy);
-            addLink(vTip.qx, hTip.qy, vTip.qx, vTip.qy);
-        }
-    }
-}

package/dist/lib/geom/boolean-ops.d.ts

@@ -1,21 +0,0 @@
-import type { Ring } from './types.js';
-/**
- * Polygon boolean operations the compiler needs, so the backend is one swappable adapter. Rings are in
- * meters; the adapter owns any integer scaling.
- */
-export interface BooleanOps {
-    /** Union of all rings into non-overlapping outers and holes (NonZero). Feed positively wound rings. */
-    union(rings: readonly Ring[]): Ring[];
-    /** `subject − clip` (NonZero). */
-    difference(subject: readonly Ring[], clip: readonly Ring[]): Ring[];
-    /** `subject ∩ clip` (NonZero). */
-    intersect(subject: readonly Ring[], clip: readonly Ring[]): Ring[];
-    /** Net area in m²: holes, wound the other way, subtract. */
-    area(rings: readonly Ring[]): number;
-    /**
-     * One rectangle per segment of an open polyline, at the given half-width, un-unioned: small
-     * strips keep the nearby-wall lookup by bounding box tight, and the caller unions all walls once.
-     */
-    offsetSegments(polyline: Ring, halfWidth: number): Ring[];
-}
-//# sourceMappingURL=boolean-ops.d.ts.map

package/dist/lib/geom/boolean-ops.js

@@ -1 +0,0 @@
-export {};

package/dist/lib/geom/clipper2-ops.d.ts

@@ -1,7 +0,0 @@
-import type { BooleanOps } from './boolean-ops.js';
-/**
- * {@link BooleanOps} on clipper2-ts — the only module importing it.
- * @returns A {@link BooleanOps} backed by clipper2-ts.
- */
-export declare function createClipper2Ops(): BooleanOps;
-//# sourceMappingURL=clipper2-ops.d.ts.map

package/dist/lib/geom/clipper2-ops.js

@@ -1,50 +0,0 @@
-import { areaPaths, difference, EndType, FillRule, inflatePaths, intersect, JoinType, union, } from 'clipper2-ts';
-/** Clipper2 works on integers: 1 mm precision at meter scale. */
-const SCALE = 1000;
-function toPoint([x, y]) {
-    return { x: Math.round(x * SCALE), y: Math.round(y * SCALE) };
-}
-function toPath(ring) {
-    return ring.map(toPoint);
-}
-function toPaths(rings) {
-    return rings.map(toPath);
-}
-function fromPath(path) {
-    return path.map((pt) => [pt.x / SCALE, pt.y / SCALE]);
-}
-function fromPaths(paths) {
-    return paths.map(fromPath);
-}
-/**
- * {@link BooleanOps} on clipper2-ts — the only module importing it.
- * @returns A {@link BooleanOps} backed by clipper2-ts.
- */
-export function createClipper2Ops() {
-    return {
-        union(rings) {
-            if (rings.length === 0)
-                return [];
-            return fromPaths(union(toPaths(rings), FillRule.NonZero));
-        },
-        difference(subject, clip) {
-            return fromPaths(difference(toPaths(subject), toPaths(clip), FillRule.NonZero));
-        },
-        intersect(subject, clip) {
-            return fromPaths(intersect(toPaths(subject), toPaths(clip), FillRule.NonZero));
-        },
-        area(rings) {
-            return Math.abs(areaPaths(toPaths(rings))) / (SCALE * SCALE);
-        },
-        offsetSegments(polyline, halfWidth) {
-            const delta = halfWidth * SCALE;
-            const quads = [];
-            for (let i = 0; i + 1 < polyline.length; i++) {
-                const seg = inflatePaths(toPaths([[polyline[i], polyline[i + 1]]]), delta, JoinType.Miter, EndType.Square);
-                for (const quad of seg)
-                    quads.push(fromPath(quad));
-            }
-            return quads;
-        },
-    };
-}

package/dist/lib/geom/footprint.d.ts

@@ -1,26 +0,0 @@
-import type { BooleanOps } from './boolean-ops.js';
-import type { Ring } from './types.js';
-/**
- * How a footprint's ring was read off its drawn pieces: traced exactly, taken as the convex hull the
- * pieces fill, as a short axis-aligned trace, as their box (`bounds-oversized` when the mesh is too
- * fine to trace at all), or as the dock alone when the pieces enclose nothing.
- */
-export type FootprintShape = 'traced' | 'hull' | 'rectilinear' | 'bounds' | 'bounds-oversized' | 'dock';
-/**
- * The ring a route arrives at — the drawing joined with the dock rectangle — and the other drawn blocks.
- *
- * A piece identical to the dock is skipped: its shared edges would cancel out of the mesh outline. When
- * the drawing falls into blocks, the ring is the block the dock stands in; the rest come back in `drawn`
- * for the caller to carve.
- * @param parts The raw pieces, positioned, in meters.
- * @param ops Boolean backend.
- * @param dock The rectangle routes arrive at, if any.
- * @returns The ring to carve, how it was read, and the drawn blocks it does not cover (only with a
- *   dock).
- */
-export declare function footprintOf(parts: readonly Ring[], ops: BooleanOps, dock?: Ring): {
-    ring: Ring | null;
-    how?: FootprintShape;
-    drawn: Ring[];
-};
-//# sourceMappingURL=footprint.d.ts.map