@expofp/schema 0.0.0-experimental.cf063fc

package/dist/lib/venues.js

@@ -0,0 +1,150 @@
+import * as z from 'zod';
+/**
+ * The multi-venue contract (docs/specs/multi-venue-data-contract.md, currently
+ * Revision 4).
+ *
+ * `VenueSchema` is deliberately the PERMISSIVE shape the config parses with —
+ * a malformed venue must not fail the plan. Venues arrive inside `data.js`
+ * alongside everything else, so a strict `ConfigSchema.parse` would throw on
+ * one bad `order` and take the whole floor plan down with it. The loose shape
+ * here lets the payload through; per-venue enforcement of the published
+ * contract (every documented constraint, plus diagnostics) lives in the
+ * imperative parser at `packages/floorplan/src/data/venues.ts`, which is the
+ * contract's one source of truth — not a zod schema.
+ *
+ * **Hand-sync is the accepted permanent cost, not a pending TODO.** Three
+ * copies encode the contract's rules and each must be updated together:
+ *
+ * 1. `packages/floorplan/src/data/venues.ts` — runtime parsing + diagnostics
+ * 2. `docs/specs/validate-venues.mjs` — the export gate (Guard 2, §12)
+ * 3. `docs/specs/multi-venue-data-contract.schema.json` — structural schema
+ *
+ * An earlier TODO here proposed generating 2 and 3 from a strict zod schema in
+ * this module. That schema was deleted as dead code (it had zero consumers and
+ * had already drifted from the parser), so the TODO went with it: the parser
+ * enforces referential and geometric rules that no JSON Schema can express,
+ * which is why it — not zod — is the source of truth.
+ *
+ * What keeps the copies honest is
+ * `packages/floorplan/src/data/validate-venues.test.ts`, which runs all three
+ * implementations over shared fixtures and asserts they agree on the `code`,
+ * `effect` and `path` of every diagnostic. `message` and `consequence` are
+ * deliberately excluded, so either implementation may reword its prose freely.
+ * Add a parity case there whenever you add a rule.
+ */
+/** A point in floor-plan projected coordinates. */
+export const VenuePointSchema = z.object({
+    /** Horizontal coordinate. */
+    x: z.number(),
+    /** Vertical coordinate. */
+    y: z.number(),
+});
+/** How an auxiliary venue layer is drawn. */
+export const VenueRenderModeSchema = z.enum(['scene', 'marker']);
+/**
+ * Upper size bound for an aux layer: a pixel size, or `'detail'` to track the
+ * venue's own detail cutoff instead of a fixed number.
+ */
+export const VenueSizeBoundSchema = z.union([z.number().min(0), z.literal('detail')]);
+/** One level of a venue, bound to a plan layer. */
+export const VenueLevelSchema = z.looseObject({
+    /** Plan layer name carrying this level's drawing. */
+    layer: z.string().min(1),
+    /** Storey index; orders the level list and need not start at 0. */
+    ordinal: z.int(),
+    /** Display name; falls back to the layer name. */
+    name: z.string().min(1).optional(),
+    /** Level shown when the venue is first focused. */
+    initial: z.boolean().optional(),
+});
+/** A non-level layer a venue draws — a replacing scene or a marker. */
+export const VenueAuxLayerSchema = z.looseObject({
+    /** Plan layer name carrying the drawing. */
+    layer: z.string().min(1),
+    render: VenueRenderModeSchema,
+    /** When a `scene` layer suppresses the procedural venue scene (default true). */
+    replacesDefault: z.boolean().optional(),
+    /**
+     * Whether this layer's artwork stands in for the venue name label while it is
+     * visible. Defaults to `replacesDefault` on a `scene` layer — map-scaled
+     * contour artwork letters itself — and to `false` on a `marker`.
+     */
+    suppressesLabel: z.boolean().optional(),
+    /** Hide the layer below this projected size in pixels. */
+    minSizePx: z.number().min(0).optional(),
+    /** Hide the layer above this projected size in pixels. */
+    maxSizePx: VenueSizeBoundSchema.optional(),
+});
+/**
+ * A venue entrance: the authored point where a venue meets the outside world.
+ *
+ * Plan-local on one of the venue's own levels, and therefore geo-projectable
+ * through the plan's GPS anchors — which is what lets a cross-venue journey
+ * hand a maps app a door rather than the middle of a building footprint. The
+ * wayfinding engine never learns the concept: an entrance reaches it as an
+ * ordinary route endpoint, exactly as a kiosk anchor does.
+ *
+ * A venue may author several; the SDK chooses between them by cost and never
+ * asks the visitor to pick. Authoring none is permanent, supported behavior —
+ * such a venue keeps marker-point targeting forever.
+ */
+export const VenueEntranceSchema = z.looseObject({
+    /** Plan layer of the venue level this door sits on. */
+    layer: z.string().min(1),
+    /** Where the door is, in plan-local coordinates. */
+    point: VenuePointSchema,
+    /** Display name — "North Door". Falls back to the venue's own name. */
+    name: z.string().min(1).optional(),
+});
+/**
+ * The plan's whole-campus frame (Revision 9): an axis-aligned rectangle in
+ * plan-local coordinates, with no angle. Plan-wide although a venue carries it
+ * — the first carrier by `order` wins. A usable one has finite members and a
+ * positive `width` and `height`; that, like every venue constraint, is the
+ * parser's to enforce (`campus-viewbox-invalid`), not this schema's.
+ */
+export const VenueCampusViewboxSchema = z.looseObject({
+    x: z.number(),
+    y: z.number(),
+    width: z.number(),
+    height: z.number(),
+});
+/**
+ * The shape the config parses with: same fields, no constraints. Anything
+ * structurally venue-like survives into the payload so the quarantine — not the
+ * parser — decides what to drop.
+ */
+export const VenueSchema = z.looseObject({
+    id: z.string(),
+    name: z.string(),
+    /**
+     * Contractually required (§9): a producer must author it on every venue.
+     * Optional here only because this shape is permissive by design — the parser
+     * falls back to array position and reports `venue-order-invalid` when one is
+     * missing or unusable.
+     */
+    order: z.number().optional(),
+    levels: z.array(VenueLevelSchema.partial()).optional(),
+    contour: z.array(VenuePointSchema).optional(),
+    markerPoint: VenuePointSchema.optional(),
+    detailMinSizePx: z.number().optional(),
+    /** The marker ⇄ scene edge (§4, Revision 5). Defaults to 60 when absent or unusable. */
+    markerMaxSizePx: z.number().optional(),
+    layers: z.array(VenueAuxLayerSchema.partial()).optional(),
+    entrances: z.array(VenueEntranceSchema.partial()).optional(),
+    campusViewbox: VenueCampusViewboxSchema.partial().optional(),
+});
+/** Wire version of the multi-venue payload. Revision 2 defines version 1. */
+export const VenuesVersionSchema = z.literal(1);
+/**
+ * The venue-bearing slice of the `data.js` payload, as the parser receives it.
+ *
+ * Both fields are optional and the object is loose: callers hand the whole data
+ * module over, and a plan with no venues omits them entirely. A payload that
+ * carries `venues` under a version the runtime does not know is the parser's
+ * problem to report, not a reason to reject the shape here.
+ */
+export const VenuePayloadSchema = z.looseObject({
+    venuesVersion: VenuesVersionSchema.optional(),
+    venues: z.array(VenueSchema).optional(),
+});

package/dist/lib/visibility.d.ts

@@ -0,0 +1,17 @@
+import * as z from 'zod';
+/**
+ * A map-chrome visibility request — the argument of `FloorPlan.setVisibility`
+ * and the `setVisibility` intent. Every field is optional, but the semantics
+ * are rebuild-not-merge (the legacy `?hide=` contract): a field set to `false`
+ * hides its element, and every omitted field resets to visible.
+ */
+export declare const VisibilitySchema: z.ZodObject<{
+    controls: z.ZodOptional<z.ZodBoolean>;
+    levels: z.ZodOptional<z.ZodBoolean>;
+    header: z.ZodOptional<z.ZodBoolean>;
+    overlay: z.ZodOptional<z.ZodBoolean>;
+    searchButtons: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export interface Visibility extends z.infer<typeof VisibilitySchema> {
+}
+//# sourceMappingURL=visibility.d.ts.map

package/dist/lib/visibility.js

@@ -0,0 +1,23 @@
+import * as z from 'zod';
+/**
+ * A map-chrome visibility request — the argument of `FloorPlan.setVisibility`
+ * and the `setVisibility` intent. Every field is optional, but the semantics
+ * are rebuild-not-merge (the legacy `?hide=` contract): a field set to `false`
+ * hides its element, and every omitted field resets to visible.
+ */
+export const VisibilitySchema = z.object({
+    /** The map controls (zoom buttons, …). */
+    controls: z.boolean().optional(),
+    /** The floor selector. */
+    levels: z.boolean().optional(),
+    /** The header bar — logos and the free/demo badge. */
+    header: z.boolean().optional(),
+    /** The overlay panel — search, lists, entity details. */
+    overlay: z.boolean().optional(),
+    /**
+     * The search-filter buttons row. Omitted, it follows `overlay`; an explicit
+     * `true` keeps the buttons while the overlay is hidden — clicking one opens
+     * the overlay on demand (`?visibility[overlay]=false&visibility[searchButtons]=true`).
+     */
+    searchButtons: z.boolean().optional(),
+});

package/dist/lib/wayfinding.d.ts

@@ -0,0 +1,104 @@
+import * as z from 'zod';
+/**
+ * Schema for the legacy `wf.data.js` wayfinding payload served next to
+ * `data.js`. Like `fp.svg.js` it is a `window`-assigning `.js` script,
+ * evaluated by `evalJsToJson` (`@expofp/utils`) and reached through a `.js`
+ * `$ref` by `resolve` (`@expofp/resolve`); the runtime consumes the graph in
+ * `wayfinding/adapters/graphDataSource.ts` (`lines` + `lineEnds`; `walls` has no
+ * consumer).
+ */
+/** A wayfinding graph vertex. `layer` is omitted on some virtual endpoints. */
+export declare const WfPointSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    layer: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/**
+ * One wayfinding graph edge — the raw form of `GraphLine`
+ * (`wayfinding/core/types.ts`); omitted booleans read as `false` and an omitted
+ * `weight` as the default line weight.
+ */
+export declare const WfLineSchema: z.ZodObject<{
+    p0: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        layer: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    p1: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        layer: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    weight: z.ZodOptional<z.ZodNumber>;
+    virtual: z.ZodOptional<z.ZodBoolean>;
+    unaccessible: z.ZodOptional<z.ZodBoolean>;
+    unidirection: z.ZodOptional<z.ZodBoolean>;
+    virtualLength: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+/** `__wfData`: the wayfinding graph. */
+export declare const WfDataSchema: z.ZodObject<{
+    lines: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        p0: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            layer: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+        p1: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            layer: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+        weight: z.ZodOptional<z.ZodNumber>;
+        virtual: z.ZodOptional<z.ZodBoolean>;
+        unaccessible: z.ZodOptional<z.ZodBoolean>;
+        unidirection: z.ZodOptional<z.ZodBoolean>;
+        virtualLength: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>>;
+    lineEnds: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        layer: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+    walls: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+}, z.core.$loose>;
+/** The evaluated `wf.data.js` payload. */
+export declare const WfDataJsSchema: z.ZodObject<{
+    __wfData: z.ZodOptional<z.ZodObject<{
+        lines: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            p0: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                layer: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>;
+            p1: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                layer: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>;
+            weight: z.ZodOptional<z.ZodNumber>;
+            virtual: z.ZodOptional<z.ZodBoolean>;
+            unaccessible: z.ZodOptional<z.ZodBoolean>;
+            unidirection: z.ZodOptional<z.ZodBoolean>;
+            virtualLength: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>>;
+        lineEnds: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            layer: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>;
+        walls: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/**
+ * A `$ref` to the expo's `wf.data.js`. The graph is not loaded eagerly:
+ * `resolve()` evaluates the ref on demand into a {@link WfDataJsSchema} payload.
+ */
+export declare const WfDataJsRefSchema: z.ZodObject<{
+    $ref: z.ZodString;
+}, z.core.$strip>;
+export type WfPoint = z.infer<typeof WfPointSchema>;
+export type WfLine = z.infer<typeof WfLineSchema>;
+export type WfData = z.infer<typeof WfDataSchema>;
+export type WfDataJs = z.infer<typeof WfDataJsSchema>;
+export type WfDataJsRef = z.infer<typeof WfDataJsRefSchema>;
+//# sourceMappingURL=wayfinding.d.ts.map

package/dist/lib/wayfinding.js

@@ -0,0 +1,52 @@
+import * as z from 'zod';
+/**
+ * Schema for the legacy `wf.data.js` wayfinding payload served next to
+ * `data.js`. Like `fp.svg.js` it is a `window`-assigning `.js` script,
+ * evaluated by `evalJsToJson` (`@expofp/utils`) and reached through a `.js`
+ * `$ref` by `resolve` (`@expofp/resolve`); the runtime consumes the graph in
+ * `wayfinding/adapters/graphDataSource.ts` (`lines` + `lineEnds`; `walls` has no
+ * consumer).
+ */
+/** A wayfinding graph vertex. `layer` is omitted on some virtual endpoints. */
+export const WfPointSchema = z.looseObject({
+    x: z.number(),
+    y: z.number(),
+    layer: z.string().optional(),
+});
+/**
+ * One wayfinding graph edge — the raw form of `GraphLine`
+ * (`wayfinding/core/types.ts`); omitted booleans read as `false` and an omitted
+ * `weight` as the default line weight.
+ */
+export const WfLineSchema = z.looseObject({
+    p0: WfPointSchema,
+    p1: WfPointSchema,
+    weight: z.number().optional(),
+    /** A virtual (floor-transition) link rather than a physical path segment. */
+    virtual: z.boolean().optional(),
+    /** Excluded when routing accessible-only. */
+    unaccessible: z.boolean().optional(),
+    /** One-way edge: no reverse link in oriented mode. */
+    unidirection: z.boolean().optional(),
+    /** Custom cost for virtual links ("Virtual length" in the designer). */
+    virtualLength: z.number().optional(),
+});
+/** `__wfData`: the wayfinding graph. */
+export const WfDataSchema = z.looseObject({
+    lines: z.array(WfLineSchema).optional(),
+    lineEnds: z.array(WfPointSchema).optional(),
+    walls: z.array(z.unknown()).optional(),
+});
+/** The evaluated `wf.data.js` payload. */
+export const WfDataJsSchema = z.looseObject({
+    __wfData: WfDataSchema.optional(),
+});
+/**
+ * A `$ref` to the expo's `wf.data.js`. The graph is not loaded eagerly:
+ * `resolve()` evaluates the ref on demand into a {@link WfDataJsSchema} payload.
+ */
+export const WfDataJsRefSchema = z
+    .object({
+    $ref: z.string(),
+})
+    .meta({ refSchema: WfDataJsSchema });

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@expofp/schema",
+  "version": "0.0.0-experimental.cf063fc",
+  "type": "module",
+  "description": "ExpoFP SDK internal: expo data schemas and types",
+  "homepage": "https://developer.expofp.com/",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "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",
+    "zod": "4.4.3"
+  },
+  "devDependencies": {
+    "@expofp/utils": "0.0.0-experimental.cf063fc"
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo",
+    "!**/*.map"
+  ]
+}