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

package/README.md

@@ -1,56 +1,3 @@
-# @expofp/wayfinding-source
+# Temporary Holding Version
 
-Turns plan data into the input of `@expofp/wayfinding-compiler`, and says what the data loses on the way.
-
-```ts
-import { assembleWayfindingSource } from '@expofp/wayfinding-source';
-import { compileWayfinding } from '@expofp/wayfinding-compiler';
-
-const { source, problems } = assembleWayfindingSource(plan); // plan: RawWayfindingSource
-const { graph, report } = compileWayfinding(source);
-// show `problems` (the plan data) and then `report.problems` (the generation) in one list
-```
-
-## Input: `RawWayfindingSource`
-
-- `units` — `m` or `ft`; anything else throws, no other units are supported.
-- `walls` — wall polylines by floor, flat `[x0, y0, x1, y1, …]` in plan units.
-- `poi` — every place a route may go to, stands included: `name` (a stand's number), `layer`, `rect`
-  before rotation, `rotate`, the POI `type` name (English), and `shape` — rings in plan units, sent only
-  when the drawn shape describes the POI better than its rectangle.
-- `unitScale` — 10 for a drawing before fp-ver 5, which drew in tenths; 1 when absent. Anything but a
-  finite number above zero throws, like an unsupported unit: both come from the host, not from the plan.
-- `anchors` — map anchors, to check the units against.
-- `transitions` — shafts, one stop per floor served, each naming its `kind`: `stairs`, `escalator` or
-  `elevator`, the kinds the Designer defines.
-
-## What it decides
-
-- **How a POI reads**, by its English type name. **Crossable** and **terminal** match a listed stem at
-  the start of a word, so `Toilets` and `Staircase` count and `Upstairs` does not. **Crossable** —
-  `entrance`, `exit`, `stair`, `elevator`, `lift` or `escalator`; a stair or escalator icon often stands
-  in an aisle, and its footprint must not block it. **Terminal** — `toilet`, `restroom`, `coat`, `stair`,
-  `elevator`, `lift` or `escalator`. **Entrance** — any type whose name contains `entrance`, as the viewer
-  reads it: a way into the building, which routes reach through the wall it stands across or next to
-  (the compiler's `entrance`). The POI's own name is never read. Type names in other languages are not
-  recognized: such a POI reads as a plain stand.
-- **Footprint** — the rectangle, rotated; with a `shape`, the shape as `parts` and the rectangle as `dock`.
-- **Floors** — one per wall group name; groups naming no floor are the one unnamed floor. When the plan
-  has POI and none of them stands on a floor the walls are drawn on, all walls and POI are read as one
-  floor — unless a shaft joins two of those floors: then they stay apart, and the POI are left out as
-  naming none of them.
-- **Shafts** — a shaft with no `kind` is left out. Only an elevator (`elevator`, `lift`) stays on
-  accessible-only routes: stairs, escalators and any kind not known are kept off them.
-- **Order** — each floor's POI by name, so the same plan gives the same source whatever order it lists them.
-- **Scale** — plan units per meter from `units` and `unitScale`.
-
-## What it reports
-
-`problems` — for the designer, grouped: POI left out (no rectangle, a coordinate that is not a number, a
-floor with no walls while other floors have them, or no floor of a plan whose floors shafts join), POI
-read on a floor other than the one they name (routes look for them on theirs), wall floors read as one
-because no POI stands on any of them (right for one floor drawn in several groups, wrong for separate
-floors — the data cannot tell), shafts with no kind or
-left with fewer than two floors, units the map anchors disagree with (by more than 2 %, the accuracy of
-placing an anchor by hand). `diagnostics` — every fact, for debug and tests. What the compiler's own
-validator checks is not repeated here.
+This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.

package/package.json

@@ -1,34 +1,6 @@
 {
   "name": "@expofp/wayfinding-source",
-  "version": "0.0.0-experimental.3b0db16",
-  "type": "module",
-  "description": "ExpoFP SDK internal: assembles the wayfinding compiler input from plan data and reports what the data loses",
-  "homepage": "https://developer.expofp.com/",
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
-  "sideEffects": false,
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    "./package.json": "./package.json",
-    ".": {
-      "@expofp/source": "./src/index.ts",
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
-    }
-  },
-  "dependencies": {
-    "tslib": "^2.3.0",
-    "@expofp/geometry": "0.0.0-experimental.3b0db16",
-    "@expofp/wayfinding-compiler": "0.0.0-experimental.3b0db16"
-  },
-  "files": [
-    "dist",
-    "!**/*.tsbuildinfo",
-    "!**/*.map"
-  ]
+  "version": "0.0.0-stage",
+  "stub": true,
+  "description": "Temporary package placeholder for staged publishing"
 }

package/dist/index.d.ts

@@ -1,4 +0,0 @@
-export { assembleWayfindingSource, type SourceAssembly } from './lib/assemble.js';
-export { isEntrance } from './lib/poi-kinds.js';
-export type { RawPoi, RawPoiRef, RawTransition, RawTransitionStop, RawWayfindingSource, SourceDiagnostic, SourceHighlight, SourceProblem, SourceProblemKind, } from './lib/types.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,3 +0,0 @@
-// Public API: plan data in; the compiler's input and a report on the data out.
-export { assembleWayfindingSource } from './lib/assemble.js';
-export { isEntrance } from './lib/poi-kinds.js';

package/dist/lib/assemble.d.ts

@@ -1,25 +0,0 @@
-import type { WayfindingSource } from '@expofp/wayfinding-compiler';
-import type { RawWayfindingSource, SourceDiagnostic, SourceProblem } from './types.js';
-/** The compiler input, and what the plan data lost on the way in. */
-export interface SourceAssembly {
-    /** The compiler input. Same plan → byte-identical source. */
-    readonly source: WayfindingSource;
-    /** What a designer is told: grouped, in words. */
-    readonly problems: readonly SourceProblem[];
-    /** Every fact of the assembly, one per object. */
-    readonly diagnostics: readonly SourceDiagnostic[];
-}
-/**
- * Assemble the compiler's input from the plan as its author holds it: each POI becomes a destination, the
- * walls are grouped by floor, and shafts keep the stops that name a floor. Pure.
- *
- * Every loss is a diagnostic — a POI with no rectangle, with a coordinate that is not a number, or on a
- * floor with no walls, POI that name no floor of a plan whose floors shafts join, a shaft with no kind, a
- * floorless stop, a shaft left with one floor, units the anchors disagree with — and those that
- * cost routes are also problems for the designer.
- * @param raw The plan as its author holds it.
- * @returns The compiler input, the problems and the diagnostics.
- * @throws {Error} When the units are neither meters nor feet.
- */
-export declare function assembleWayfindingSource(raw: RawWayfindingSource): SourceAssembly;
-//# sourceMappingURL=assemble.d.ts.map

package/dist/lib/assemble.js

@@ -1,388 +0,0 @@
-import { Rect } from '@expofp/geometry';
-import { isAccessible, isCrossable, isEntrance, isTerminal } from './poi-kinds.js';
-import { anchoredUnitsPerMeter, SCALE_TOLERANCE, unitsPerMeter } from './scale.js';
-/** How many names a message spells out before it counts the rest. */
-const NAMES_SHOWN = 8;
-/**
- * Names as a sentence tail: the first few in full, the rest counted.
- * @param refs The POI.
- * @returns `A, B and 3 more`.
- */
-function names(refs) {
-    const shown = refs
-        .slice(0, NAMES_SHOWN)
-        .map((ref) => (ref.name === '' ? 'unnamed POI' : ref.name));
-    const rest = refs.length - shown.length;
-    return rest > 0 ? `${shown.join(', ')} and ${rest} more` : shown.join(', ');
-}
-const floorName = (layer) => (layer === '' ? 'The floor' : `Floor "${layer}"`);
-/**
- * A POI's rectangle as a ring, rotated.
- * @param poi The POI.
- * @returns The four corners, or nothing when it has no rectangle.
- */
-function cornersOf(poi) {
-    if (!poi.rect)
-        return null;
-    const { minX, minY, maxX, maxY } = poi.rect;
-    return Rect.fromMinMax({ x: minX, y: minY }, { x: maxX, y: maxY }, poi.rotate ?? 0)
-        .corners()
-        .map((p) => [p.x, p.y]);
-}
-/**
- * Assemble the compiler's input from the plan as its author holds it: each POI becomes a destination, the
- * walls are grouped by floor, and shafts keep the stops that name a floor. Pure.
- *
- * Every loss is a diagnostic — a POI with no rectangle, with a coordinate that is not a number, or on a
- * floor with no walls, POI that name no floor of a plan whose floors shafts join, a shaft with no kind, a
- * floorless stop, a shaft left with one floor, units the anchors disagree with — and those that
- * cost routes are also problems for the designer.
- * @param raw The plan as its author holds it.
- * @returns The compiler input, the problems and the diagnostics.
- * @throws {Error} When the units are neither meters nor feet.
- */
-export function assembleWayfindingSource(raw) {
-    const scale = unitsPerMeter(raw);
-    const problems = [];
-    const diagnostics = [];
-    // The source keys a stored compile, so each floor's destinations are sorted by name, not input order.
-    const byId = (a, b) => {
-        if (a.id === b.id)
-            return 0;
-        return a.id < b.id ? -1 : 1;
-    };
-    const destByLayer = new Map();
-    const refsByLayer = new Map();
-    const allDestinations = [];
-    const noRect = [];
-    const notFinite = [];
-    raw.poi.forEach((poi, index) => {
-        const layer = poi.layer ?? '';
-        const ref = { layer, index, name: poi.name };
-        const rect = cornersOf(poi);
-        if (!rect) {
-            noRect.push(ref);
-            diagnostics.push({
-                code: 'poi-no-rect',
-                severity: 'warning',
-                message: 'the POI has no rectangle and is left out',
-                layer,
-                poi: ref,
-            });
-            return;
-        }
-        // The compiler joins the drawn pieces and the rect into one footprint. `dock` is the rect alone: convex,
-        // as a containment test on the graph's ends requires, and where routes arrive.
-        const shape = poi.shape?.length
-            ? poi.shape.map((ring) => ring.map(([x, y]) => [x, y]))
-            : [];
-        // A rectangle of no area is the compiler's to report; a point that is not a number leaves the POI out.
-        if (![rect, ...shape].every((ring) => ring.every(([x, y]) => Number.isFinite(x) && Number.isFinite(y)))) {
-            notFinite.push(ref);
-            diagnostics.push({
-                code: 'poi-not-finite',
-                severity: 'warning',
-                message: 'the POI rectangle or shape has a coordinate that is not a number; it is left out',
-                layer,
-                poi: ref,
-            });
-            return;
-        }
-        const destination = {
-            id: poi.name,
-            polygon: rect,
-            ...(shape.length ? { parts: shape, dock: rect } : {}),
-            crossable: isCrossable(poi.type),
-            terminal: isTerminal(poi.type),
-            entrance: isEntrance(poi.type),
-        };
-        diagnostics.push({
-            code: 'poi-kind',
-            severity: 'info',
-            message: 'how the POI reads to the compiler',
-            layer,
-            poi: ref,
-            facts: {
-                crossable: destination.crossable === true,
-                terminal: destination.terminal === true,
-                entrance: destination.entrance === true,
-                shape: shape.length > 0,
-            },
-        });
-        const onFloor = destByLayer.get(layer);
-        if (onFloor) {
-            onFloor.push(destination);
-            refsByLayer.get(layer).push(ref);
-        }
-        else {
-            destByLayer.set(layer, [destination]);
-            refsByLayer.set(layer, [ref]);
-        }
-        allDestinations.push(destination);
-    });
-    if (noRect.length)
-        problems.push({
-            kind: 'poi-left-out',
-            cause: 'no-rect',
-            message: `${noRect.length} POI ${noRect.length === 1 ? 'has' : 'have'} no rectangle and ${noRect.length === 1 ? 'is' : 'are'} left out of the routes: ${names(noRect)}.`,
-            poi: noRect,
-            highlight: [],
-        });
-    if (notFinite.length)
-        problems.push({
-            kind: 'poi-left-out',
-            cause: 'not-finite',
-            message: `${notFinite.length} POI ${notFinite.length === 1 ? 'has a coordinate' : 'have coordinates'} that ${notFinite.length === 1 ? 'is' : 'are'} not a number and ${notFinite.length === 1 ? 'is' : 'are'} left out of the routes: ${names(notFinite)}.`,
-            poi: notFinite,
-            highlight: [],
-        });
-    // One layer per id: several wall groups may share a floor, and groups naming none are the unnamed floor.
-    const wallsByLayer = new Map();
-    for (const group of raw.walls) {
-        const layer = group.layer ?? '';
-        const runs = wallsByLayer.get(layer) ?? [];
-        for (const run of group.polylines)
-            runs.push([...run]);
-        wallsByLayer.set(layer, runs);
-    }
-    const wallFloors = [...wallsByLayer.keys()];
-    // No POI stands on any floor the walls are drawn on.
-    const noneOnWalls = allDestinations.length > 0 && !wallFloors.some((layer) => destByLayer.has(layer));
-    // A shaft between two of the wall floors makes them floors of their own, not one floor drawn in groups.
-    const stacked = (raw.transitions ?? []).some((t) => new Set(t.points.flatMap((p) => p.layer !== undefined && wallsByLayer.has(p.layer) ? [p.layer] : [])).size > 1);
-    // Otherwise walls and POI name one floor differently, and every wall group is read as that one floor.
-    const oneFloor = noneOnWalls && !stacked;
-    const layers = oneFloor
-        ? [
-            {
-                layer: wallFloors[0] ?? '',
-                walls: [...wallsByLayer.values()].reduce((all, runs) => all.concat(runs), []),
-                destinations: [...allDestinations].sort(byId),
-            },
-        ]
-        : [...wallsByLayer].map(([layer, walls]) => ({
-            layer,
-            walls,
-            destinations: [...(destByLayer.get(layer) ?? [])].sort(byId),
-        }));
-    if (oneFloor && wallsByLayer.size > 0) {
-        const floor = layers[0].layer;
-        // Right when one floor is drawn in several groups (BG and FG); wrong when the groups are floors of
-        // their own, whose walls then lie on top of one another. The data cannot tell the two apart.
-        if (wallFloors.length > 1) {
-            diagnostics.push({
-                code: 'floors-merged',
-                severity: 'warning',
-                message: 'no POI stands on a floor the walls are drawn on and no transition joins those floors, so every wall group is read as one floor',
-                layer: floor,
-                facts: { floors: wallFloors },
-            });
-            problems.push({
-                kind: 'floors-merged',
-                layer: floor,
-                cause: 'no-poi-on-wall-floors',
-                message: `The walls are drawn on ${wallFloors.length} floors (${wallFloors
-                    .map((name) => `"${name}"`)
-                    .join(', ')}) and no POI stands on any of them, so they are read as one floor. If they are separate floors, put each POI on its floor or join the floors with a transition.`,
-                poi: [],
-                highlight: [],
-            });
-        }
-        // A POI is looked for on the floor it names, so a POI naming another floor than
-        // the merged one is never found, however well it is docked.
-        const mismatched = [];
-        for (const [layer, refs] of refsByLayer)
-            if (layer !== '' && layer !== floor)
-                mismatched.push(...refs);
-        if (mismatched.length) {
-            for (const ref of mismatched)
-                diagnostics.push({
-                    code: 'poi-floor-mismatch',
-                    severity: 'warning',
-                    message: `the POI names floor "${ref.layer}" but stands on floor "${floor}"; it is looked for on floor "${ref.layer}"`,
-                    layer: floor,
-                    poi: ref,
-                });
-            problems.push({
-                kind: 'poi-floor-mismatch',
-                layer: floor,
-                cause: 'named-floor-not-drawn',
-                message: `${mismatched.length} POI ${mismatched.length === 1 ? 'names a floor' : 'name floors'} the walls are not drawn on (${[
-                    ...new Set(mismatched.map((ref) => `"${ref.layer}"`)),
-                ].join(', ')}); ${mismatched.length === 1 ? 'it is' : 'they are'} read on floor "${floor}", where routes cannot find ${mismatched.length === 1 ? 'it' : 'them'}: ${names(mismatched)}.`,
-                poi: mismatched,
-                highlight: outlinesOf(raw, mismatched, floor),
-            });
-        }
-    }
-    // Floors joined by shafts, and no POI on any of them: the POI name no floor the plan draws.
-    if (noneOnWalls && stacked) {
-        const refs = [...refsByLayer.values()].flat();
-        for (const ref of refs)
-            diagnostics.push({
-                code: 'poi-floor-not-drawn',
-                severity: 'warning',
-                message: 'the POI names no floor the walls are drawn on and is left out',
-                layer: ref.layer,
-                poi: ref,
-            });
-        problems.push({
-            kind: 'poi-left-out',
-            cause: 'floor-not-drawn',
-            message: `${refs.length} POI name no floor the walls are drawn on (${wallFloors
-                .map((floor) => `"${floor}"`)
-                .join(', ')}), so ${refs.length === 1 ? 'it is' : 'they are'} left out of the routes: ${names(refs)}.`,
-            poi: refs,
-            highlight: [],
-        });
-    }
-    else if (!oneFloor)
-        for (const [layer, refs] of refsByLayer) {
-            // A POI on a floor no walls are drawn on never reaches the compiler: there is no floor for it.
-            if (wallsByLayer.has(layer))
-                continue;
-            for (const ref of refs)
-                diagnostics.push({
-                    code: 'poi-floor-without-walls',
-                    severity: 'warning',
-                    message: 'the POI stands on a floor with no walls and is left out',
-                    layer,
-                    poi: ref,
-                });
-            problems.push({
-                kind: 'poi-left-out',
-                layer,
-                cause: 'floor-without-walls',
-                message: `${floorName(layer)} has no walls; its ${refs.length} POI ${refs.length === 1 ? 'is' : 'are'} left out of the routes: ${names(refs)}.`,
-                poi: refs,
-                highlight: outlinesOf(raw, refs, layer),
-            });
-        }
-    const transitions = assembleTransitions(raw, problems, diagnostics);
-    const measured = anchoredUnitsPerMeter(raw.anchors ?? []);
-    if (measured !== null && Math.abs(measured / scale - 1) > SCALE_TOLERANCE) {
-        const facts = { measured: +measured.toFixed(3), declared: +scale.toFixed(3) };
-        diagnostics.push({
-            code: 'scale-mismatch',
-            severity: 'warning',
-            message: "the map anchors measure a scale the plan's units do not declare",
-            facts,
-        });
-        problems.push({
-            kind: 'scale-mismatch',
-            cause: 'anchors-disagree',
-            message: `The map anchors measure ${facts.measured} plan units per meter, but the plan declares ${facts.declared}; check its units.`,
-            poi: [],
-            highlight: [],
-        });
-    }
-    return {
-        source: { layers, transitions, unitsPerMeter: scale },
-        problems,
-        diagnostics,
-    };
-}
-/**
- * The rectangles of some POI on their floor, for a problem to point at.
- * @param raw The raw source the POI are listed in.
- * @param refs The POI.
- * @param layer The floor to draw them on.
- * @returns One bounds highlight per POI that has a rectangle.
- */
-function outlinesOf(raw, refs, layer) {
-    const out = [];
-    for (const ref of refs) {
-        const ring = cornersOf(raw.poi[ref.index]);
-        if (!ring)
-            continue;
-        const xs = ring.map(([x]) => x);
-        const ys = ring.map(([, y]) => y);
-        out.push({
-            type: 'bounds',
-            layer,
-            box: [Math.min(...xs), Math.min(...ys), Math.max(...xs), Math.max(...ys)],
-        });
-    }
-    return out;
-}
-/**
- * The plan's shafts in the compiler's shape. A stop binds by position, not by `id`, which an export may
- * leave meaningless. A shaft names its kind, and its kind says whether it is accessible.
- * @param raw The raw source.
- * @param problems Where the designer's problems go.
- * @param diagnostics Where the facts go.
- * @returns One entry per shaft that names its kind, stops with a floor only.
- */
-function assembleTransitions(raw, problems, diagnostics) {
-    const transitions = [];
-    for (const transition of raw.transitions ?? []) {
-        const name = transition.id ? `Transition "${transition.id}"` : 'A transition';
-        const id = transition.id ?? '';
-        const kind = transition.kind?.trim();
-        // The kind prices the shaft and tells it from a walk: without one there is no shaft to build.
-        if (!kind) {
-            diagnostics.push({
-                code: 'transition-kind-missing',
-                severity: 'warning',
-                message: 'the transition names no kind and is left out',
-                transition: id,
-            });
-            problems.push({
-                kind: 'floors-not-connected',
-                cause: 'kind-missing',
-                message: `${name} names no kind (stairs, escalator, elevator…) and is left out; the floors it joined stay unconnected.`,
-                poi: [],
-                highlight: [],
-            });
-            continue;
-        }
-        const points = transition.points.filter((p) => p.layer !== undefined);
-        const floorless = transition.points.length - points.length;
-        if (floorless)
-            diagnostics.push({
-                code: 'transition-stop-no-floor',
-                severity: 'warning',
-                message: `${floorless} stop(s) of the transition name no floor and are left out`,
-                transition: id,
-                facts: { stops: floorless },
-            });
-        // A shaft left with one floor is the one problem reported; the floorless stop is its reason.
-        if (points.length < 2) {
-            diagnostics.push({
-                code: 'transition-dropped',
-                severity: 'warning',
-                message: 'the transition keeps fewer than two stops and is left out',
-                transition: id,
-                facts: { stops: points.length },
-            });
-            problems.push({
-                kind: 'floors-not-connected',
-                cause: 'transition-dropped',
-                message: `${name} serves fewer than two floors and is left out; the floors it joined stay unconnected.`,
-                poi: [],
-                highlight: [],
-            });
-            continue;
-        }
-        if (floorless)
-            problems.push({
-                kind: 'floors-not-connected',
-                cause: 'stop-no-floor',
-                message: `${name}: ${floorless} ${floorless === 1 ? 'stop has' : 'stops have'} no floor and ${floorless === 1 ? 'is' : 'are'} left out.`,
-                poi: [],
-                highlight: [],
-            });
-        transitions.push({
-            ...(transition.id != null ? { id: transition.id } : {}),
-            kind,
-            points: points.map((p) => ({
-                ...(p.id != null ? { id: p.id } : {}),
-                layer: p.layer,
-                x: p.x,
-                y: p.y,
-            })),
-            ...(!isAccessible(kind) && { accessible: false }),
-        });
-    }
-    return transitions;
-}

package/dist/lib/poi-kinds.d.ts

@@ -1,25 +0,0 @@
-/**
- * Whether a route ends at this POI type rather than going round it.
- * @param type The POI type's name.
- * @returns True when one connection is the whole approach.
- */
-export declare function isTerminal(type: string | undefined): boolean;
-/**
- * Whether a route may pass through this POI type.
- * @param type The POI type's name.
- * @returns True when the route may pass straight through it.
- */
-export declare function isCrossable(type: string | undefined): boolean;
-/**
- * Whether this POI type is a way into the building: its English name contains "entrance".
- * @param type The POI type's name.
- * @returns True when routes reach the POI through the wall it stands across or next to.
- */
-export declare function isEntrance(type: string | undefined): boolean;
-/**
- * Whether an accessible-only route may take a transition of this kind.
- * @param kind The transition's kind.
- * @returns True for an elevator; false for stairs, an escalator and any kind it does not know.
- */
-export declare function isAccessible(kind: string): boolean;
-//# sourceMappingURL=poi-kinds.d.ts.map

package/dist/lib/poi-kinds.js

@@ -1,70 +0,0 @@
-/**
- * POI types a route passes through: their footprints stay walkable, so an entrance in a doorway is the way
- * in, and a stair icon standing in an aisle does not block it. Matched as the start of a word of the
- * English type name, since type ids differ per plan.
- */
-const CROSSABLE_POI_TYPES = ['entrance', 'exit', 'stair', 'elevator', 'lift', 'escalator'];
-/**
- * POI types a visitor walks up to rather than around — a toilet, a cloakroom, a lift or stair door. One
- * connection serves them.
- */
-const TERMINAL_POI_TYPES = ['toilet', 'restroom', 'coat', 'stair', 'elevator', 'lift', 'escalator'];
-/**
- * The transition kinds a wheelchair can use, of the Designer's `stairs`, `escalator` and `elevator`.
- * A kind not named here is taken for stepped: an unknown one must not open an accessible route.
- */
-const STEP_FREE_TRANSITION_KINDS = ['elevator', 'lift'];
-/**
- * The words of a name, lowercased, so `Bag-Check` and `bag check` read alike. English only: a word in
- * another script holds no stem.
- * @param name The name.
- * @returns Its words.
- */
-function words(name) {
-    return name
-        .toLowerCase()
-        .split(/[^a-z0-9]+/)
-        .filter(Boolean);
-}
-/**
- * Whether a name holds one of the stems as a whole word or the start of one: `Toilets` and `Staircase`
- * do, `Upstairs` does not.
- * @param name The name.
- * @param stems The stems looked for.
- * @returns True when a word starts with a stem.
- */
-function namesOneOf(name, stems) {
-    return words(name ?? '').some((word) => stems.some((stem) => word.startsWith(stem)));
-}
-/**
- * Whether a route ends at this POI type rather than going round it.
- * @param type The POI type's name.
- * @returns True when one connection is the whole approach.
- */
-export function isTerminal(type) {
-    return namesOneOf(type, TERMINAL_POI_TYPES);
-}
-/**
- * Whether a route may pass through this POI type.
- * @param type The POI type's name.
- * @returns True when the route may pass straight through it.
- */
-export function isCrossable(type) {
-    return namesOneOf(type, CROSSABLE_POI_TYPES);
-}
-/**
- * Whether this POI type is a way into the building: its English name contains "entrance".
- * @param type The POI type's name.
- * @returns True when routes reach the POI through the wall it stands across or next to.
- */
-export function isEntrance(type) {
-    return /entrance/i.test(type ?? '');
-}
-/**
- * Whether an accessible-only route may take a transition of this kind.
- * @param kind The transition's kind.
- * @returns True for an elevator; false for stairs, an escalator and any kind it does not know.
- */
-export function isAccessible(kind) {
-    return namesOneOf(kind, STEP_FREE_TRANSITION_KINDS);
-}

package/dist/lib/scale.d.ts

@@ -1,20 +0,0 @@
-import { type GeoAnchor } from '@expofp/geometry';
-import type { RawWayfindingSource } from './types.js';
-/**
- * How far a measured scale may sit from the declared one: placing an anchor by hand is worth a percent,
- * while a mistaken unit is off by 228% (feet for meters) or 900% (tenths).
- */
-export declare const SCALE_TOLERANCE = 0.02;
-/**
- * Plan units per meter, from the declared units.
- * @param raw The raw source.
- * @returns Plan units per meter.
- */
-export declare function unitsPerMeter(raw: RawWayfindingSource): number;
-/**
- * Plan units per meter measured from the map anchors, independent of the declared units.
- * @param anchors The anchors.
- * @returns The measured scale, or null with fewer than two usable anchors.
- */
-export declare function anchoredUnitsPerMeter(anchors: readonly GeoAnchor[]): number | null;
-//# sourceMappingURL=scale.d.ts.map

package/dist/lib/scale.js

@@ -1,42 +0,0 @@
-import { haversineDistance } from '@expofp/geometry';
-const FEET_PER_METER = 3.280839895;
-/**
- * How far a measured scale may sit from the declared one: placing an anchor by hand is worth a percent,
- * while a mistaken unit is off by 228% (feet for meters) or 900% (tenths).
- */
-export const SCALE_TOLERANCE = 0.02;
-/**
- * Plan units per meter, from the declared units.
- * @param raw The raw source.
- * @returns Plan units per meter.
- */
-export function unitsPerMeter(raw) {
-    const units = String(raw.units).toLowerCase().trim();
-    const scale = raw.unitScale ?? 1;
-    // Both come from the host, not from the plan: a bad value is a caller's bug, not a designer's
-    // problem, so it throws rather than being reported.
-    if (units !== 'm' && units !== 'ft')
-        throw new Error(`Unsupported plan units "${String(raw.units)}": only m and ft are supported.`);
-    if (!(Number.isFinite(scale) && scale > 0))
-        throw new Error(`Unsupported unitScale ${String(scale)}: a finite number above zero is required.`);
-    return (units === 'm' ? 1 : FEET_PER_METER) * scale;
-}
-/**
- * Plan units per meter measured from the map anchors, independent of the declared units.
- * @param anchors The anchors.
- * @returns The measured scale, or null with fewer than two usable anchors.
- */
-export function anchoredUnitsPerMeter(anchors) {
-    const usable = anchors.filter((a) => [a.local.x, a.local.y, a.geo.lat, a.geo.lng].every((value) => Number.isFinite(value)));
-    const readings = [];
-    for (let i = 0; i < usable.length; i++)
-        for (let k = i + 1; k < usable.length; k++) {
-            const meters = haversineDistance(usable[i].geo, usable[k].geo);
-            const units = Math.hypot(usable[k].local.x - usable[i].local.x, usable[k].local.y - usable[i].local.y);
-            if (meters > 0 && units > 0)
-                readings.push(units / meters);
-        }
-    if (!readings.length)
-        return null;
-    return readings.reduce((sum, reading) => sum + reading, 0) / readings.length;
-}

package/dist/lib/types.d.ts

@@ -1,130 +0,0 @@
-import type { GeoAnchor } from '@expofp/geometry';
-/** A POI as the plan holds it — a stand, a toilet, an entrance: every place a route may go to. */
-export interface RawPoi {
-    /** The name the plan shows (a stand's number); it becomes the compiler's destination id. */
-    readonly name: string;
-    /** The floor it stands on; absent — the unnamed floor. */
-    readonly layer?: string;
-    /** Its rectangle before rotation, in plan units; absent — the POI is left out of the routes. */
-    readonly rect?: {
-        readonly minX: number;
-        readonly minY: number;
-        readonly maxX: number;
-        readonly maxY: number;
-    };
-    /** Rotation of {@link rect} about its center, in radians, clockwise. */
-    readonly rotate?: number;
-    /**
-     * The POI type's name as the plan writes it — "Toilets Male", "Entrances"; English only. Absent, or
-     * in another language — a plain stand.
-     */
-    readonly type?: string;
-    /**
-     * The drawn shape as rings (triangles or polygons) in plan units, already rotated and placed; sent only
-     * when it describes the POI better than {@link rect}. Absent — the rectangle.
-     */
-    readonly shape?: readonly (readonly (readonly [number, number])[])[];
-}
-/** One stop of a vertical connection — where a shaft opens onto a floor. */
-export interface RawTransitionStop {
-    /** Where it stands, x, in plan units. */
-    readonly x: number;
-    /** Where it stands, y, in plan units. */
-    readonly y: number;
-    /** The authoring tool's own label for the stop. */
-    readonly id?: string;
-    /** The floor it opens onto; a stop without one is left out. */
-    readonly layer?: string;
-}
-/** One vertical connection — a shaft, with a stop on every floor it serves. */
-export interface RawTransition {
-    /** One stop per floor served. */
-    readonly points: readonly RawTransitionStop[];
-    /** The authoring tool's own id for the shaft. */
-    readonly id?: string;
-    /**
-     * `stairs`, `escalator` or `elevator`, the kinds the Designer defines; absent — the transition is left
-     * out. Only an elevator or a lift is taken by accessible-only routes.
-     */
-    readonly kind?: string;
-}
-/** A plan as its author holds it: floors of walls, POI with their rectangles, shafts, units. */
-export interface RawWayfindingSource {
-    /** What the drawing measures in; any other value throws. */
-    readonly units: 'm' | 'ft';
-    /** Wall polylines by floor: flat `[x0, y0, x1, y1, …]` runs in plan units. */
-    readonly walls: readonly {
-        /** The group's polylines. */
-        readonly polylines: readonly (readonly number[])[];
-        /** The floor the group is drawn on; absent — the unnamed floor. */
-        readonly layer?: string;
-    }[];
-    /** Every place a route may go to, stands included. */
-    readonly poi: readonly RawPoi[];
-    /**
-     * Plan units per drawing unit — 10 for a drawing before fp-ver 5, which drew in tenths. Default 1;
-     * anything but a finite number above zero throws.
-     */
-    readonly unitScale?: number;
-    /**
-     * Map anchors — a plan point (`local`, in plan units) and the place on Earth it sits at (`geo`); two or
-     * more measure the scale, and the declared units are checked against it.
-     */
-    readonly anchors?: readonly GeoAnchor[];
-    /** Vertical connections, one per shaft. */
-    readonly transitions?: readonly RawTransition[];
-}
-/** A POI by its place in {@link RawWayfindingSource.poi}, with its name. */
-export interface RawPoiRef {
-    /** The floor it stands on. */
-    readonly layer: string;
-    /** Position in `RawWayfindingSource.poi`. */
-    readonly index: number;
-    /** The name the plan gave it. */
-    readonly name: string;
-}
-/** Where to look on the plan, in plan units. */
-export type SourceHighlight = {
-    readonly type: 'bounds';
-    readonly layer: string;
-    readonly box: readonly [number, number, number, number];
-} | {
-    readonly type: 'point';
-    readonly layer: string;
-    readonly at: readonly [number, number];
-};
-/** The kinds of plan-data problem a designer is shown. */
-export type SourceProblemKind = 'poi-left-out' | 'poi-floor-mismatch' | 'floors-merged' | 'floors-not-connected' | 'scale-mismatch';
-/** One problem with the plan data, shaped like the compiler's report `Problem`. */
-export interface SourceProblem {
-    /** What kind of problem it is. */
-    readonly kind: SourceProblemKind;
-    /** The floor it belongs to; absent for whole-plan problems. */
-    readonly layer?: string;
-    /** Machine-readable cause within the kind. */
-    readonly cause: string;
-    /** Ready English text. */
-    readonly message: string;
-    /** The POI it touches. */
-    readonly poi: readonly RawPoiRef[];
-    /** Where to look, in plan units; empty when nothing exact is known. */
-    readonly highlight: readonly SourceHighlight[];
-}
-/** One fact of the assembly. Plain data. */
-export interface SourceDiagnostic {
-    /** Catalog code. */
-    readonly code: string;
-    /** `warning` — something is lost; `info` — how something was read. */
-    readonly severity: 'warning' | 'info';
-    /** One English sentence, technical. */
-    readonly message: string;
-    /** The floor it belongs to, when it belongs to one. */
-    readonly layer?: string;
-    /** The POI it is about, when there is one. */
-    readonly poi?: RawPoiRef;
-    /** The transition it is about, by its id. */
-    readonly transition?: string;
-    /** The assembly's own numbers and names. */
-    readonly facts?: Readonly<Record<string, number | string | boolean | readonly string[]>>;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/lib/types.js

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