@johnmorrisdotca/kyogijo-stadiums 0.45.2 → 0.45.3

package/dist/walk.full.d.ts

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

package/dist/walk.full.js

@@ -0,0 +1,5 @@
+// Every district's walkable data, held for the drawing: `full.ts` imports this, so that every entry but the lean district has the data of every mask, as it always had. The lean district holds one district's only after `loadOutside`
+// has read its file (`walk.ts`). A bundler keeps this file for its effect: package.json lists it in `sideEffects`.
+import { WALK_DATA } from "./walk.data.js";
+import { registerWalk } from "./walk.js";
+registerWalk(WALK_DATA);

package/dist/walk.index.d.ts

@@ -0,0 +1,7 @@
+import type { WalkData } from "./walk.ts";
+export declare const WALK_INDEX: Readonly<Record<string, {
+    readonly venues: readonly string[];
+    readonly load: () => Promise<{
+        readonly WALK: WalkData;
+    }>;
+}>>;

package/dist/walk.index.js

@@ -0,0 +1,3 @@
+export const WALK_INDEX = {
+    "vancouver": { venues: ["bc-place:cfl", "rogers-arena"], load: () => import("./walk/vancouver.data.js") },
+};

package/dist/walk.js

@@ -1,11 +1,55 @@
 // The walkable mask of a district: the cells of a fine grid on the ground where a person may stand, worked out from the features OpenStreetMap maps round the venues (`walk.data.ts`, ODbL 1.0): the paths, sidewalks,
 // plazas, squares, parks and platforms people stand on, the apron of each venue's own ground, minus what stops a crowd (carriageways at the width their lanes give them, cycle tracks, railways, water and every building).
 // Pure arithmetic on typed arrays, in Node or in a page: data in, a grid out. Nothing is drawn here; the roads are never drawn, and the shape of a crowd on this mask is what shows where they are.
-import { WALK_DATA, WALK_UNIT } from "./walk.data.js";
+import { VENUE_INDEX } from "./venues.index.js";
+import { loadVenue } from "./venues.js";
+import { WALK_INDEX } from "./walk.index.js";
+/** The metres one whole number of the mask's coordinates is. */
+export const WALK_UNIT = 0.25;
 /** The side of a cell of the mask, in metres: half a metre, finer than the narrowest path and a person's width. */
 export const WALK_CELL = 0.5;
 /** The districts there are masks for. */
-export const WALK_IDS = Object.freeze(Object.keys(WALK_DATA));
+export const WALK_IDS = Object.freeze(Object.keys(WALK_INDEX));
+/**
+ * The data of the districts held for the drawing. The full table (`walk.data.ts`, which `full.ts` registers) holds every district's; `loadOutside` holds the one a page is about to show a crowd for. The index (`walk.index.ts`) lists the
+ * districts and their venues without holding any data, so that asking whether a venue has a crowd outside reads none.
+ */
+const HELD = new Map();
+/** Hold districts' data for the drawing, under their keys: a later one with a key replaces the earlier. */
+export function registerWalk(table) {
+    for (const [id, data] of Object.entries(table))
+        HELD.set(id, data);
+}
+/** The data of a district, if it is held. */
+export const heldWalk = (id) => HELD.get(id);
+/** The data of a district, which a crowd outside is made from; throws, saying how to have it, where it is not held. */
+export function walkDataOf(id) {
+    const found = HELD.get(id);
+    if (found !== undefined)
+        return found;
+    if (!Object.hasOwn(WALK_INDEX, id))
+        throw new Error(`no walkable mask ${id}: the masks are ${WALK_IDS.join(", ")}`);
+    throw new Error(`the walkable mask ${id} is not read yet: await loadOutside(venues) before the first call of this entry's crowd outside, or use an entry that holds every district (the main entry, or the district entry)`);
+}
+const reading = new Map();
+/** A district's data, read from its own file the first time and held for the drawing after: asking again gives the same promise. A key that is not a district rejects, naming the ones there are. */
+export function loadWalk(id) {
+    const held = HELD.get(id);
+    if (held !== undefined)
+        return Promise.resolve(held);
+    const found = reading.get(id);
+    if (found !== undefined)
+        return found;
+    if (!Object.hasOwn(WALK_INDEX, id))
+        return Promise.reject(new Error(`no walkable mask ${id}: the masks are ${WALK_IDS.join(", ")}`));
+    const promise = WALK_INDEX[id].load().then((module) => {
+        HELD.set(id, module.WALK);
+        return module.WALK;
+    });
+    reading.set(id, promise);
+    promise.catch(() => reading.delete(id));
+    return promise;
+}
 /** A path from its packed form: the first point, then the step to each next one, in metres. */
 export function unpack(packed, from = 0) {
     const out = [];
@@ -74,7 +118,7 @@ function strokeLine(mask, line, half, value) {
 }
 const masks = new Map();
 /**
- * The mask of a district, rasterised from `WALK_DATA` (and kept for the next call): the walkable areas and the paths at their width, the apron round each venue, then the carriageways, cycle tracks, railways, water and buildings cut out
+ * The mask of a district, rasterised from the district's data (`walk/<district>.data.ts`, held by `loadOutside` or by the full table; and kept for the next call): the walkable areas and the paths at their width, the apron round each venue, then the carriageways, cycle tracks, railways, water and buildings cut out
  * of them, and the venues' own buildings last. A person stands in a cell with value 1, and nowhere else.
  */
 export function walkMask(id, extras) {
@@ -82,9 +126,7 @@ export function walkMask(id, extras) {
     const kept = masks.get(key);
     if (kept !== undefined)
         return kept;
-    const data = WALK_DATA[id];
-    if (data === undefined)
-        throw new Error(`no walkable mask ${id}: the masks are ${WALK_IDS.join(", ")}`);
+    const data = walkDataOf(id);
     const [west, south, east, north] = data.box;
     const width = Math.ceil((east - west) / WALK_CELL);
     const height = Math.ceil((north - south) / WALK_CELL);
@@ -117,4 +159,24 @@ export function walkable(mask, x, y) {
     return col >= 0 && row >= 0 && col < mask.width && row < mask.height && mask.cells[row * mask.width + col] === 1;
 }
 /** The mask a set of venues stand on, if there is one: the first mask that names one of them (by id, whatever configuration). */
-export const walkIdFor = (venueIds) => WALK_IDS.find((id) => WALK_DATA[id].venues.some((key) => venueIds.includes(key.split(":")[0])));
+export const walkIdFor = (venueIds) => WALK_IDS.find((id) => WALK_INDEX[id].venues.some((key) => venueIds.includes(key.split(":")[0])));
+/**
+ * The walkable ground the crowd outside some venues stands on, read from its file and held for the drawing: await it before `planDistrict`, `drawDistrict`, `mountDistrict` or `mountDistrictTurn` of the lean district with `outside` asked for
+ * (the district entry holds every district's data and needs no call), and the outline of each arena of the ground (the crowd keeps out of the buildings of the venues that are not shown too). It reads nothing for venues that no mask names, so a page may call it for every choice of venues; asking again reads nothing.
+ * @example
+ * ```ts
+ * import { loadOutside, loadVenueDataFor, outsideCrowd, planDistrict } from "@johnmorrisdotca/kyogijo-stadiums/district-lean";
+ * const venues = ["bc-place:cfl", "rogers-arena"];
+ * await Promise.all([loadVenueDataFor(venues), loadOutside(venues)]);
+ * console.log(outsideCrowd(planDistrict({ venues, outside: { level: 25 } }))?.venues.length);
+ * // 2
+ * ```
+ */
+export async function loadOutside(venues) {
+    const id = walkIdFor(venues.map((key) => key.split(":")[0]));
+    if (id === undefined)
+        return;
+    // The crowd keeps out of every building the ground has, those of venues that are not shown too: an arena of the ground has its outline read with the ground.
+    const outlines = WALK_INDEX[id].venues.map((key) => key.split(":")[0]).filter((one) => Object.hasOwn(VENUE_INDEX, one));
+    await Promise.all([loadWalk(id), ...outlines.map(loadVenue)]);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johnmorrisdotca/kyogijo-stadiums",
-  "version": "0.45.2",
+  "version": "0.45.3",
   "description": "Kyogijo Stadiums 競技場, 40 sports' surfaces as SVG, drawn to scale from the rulebooks: NFL, CFL and IFAF football fields, an NHL rink, an NBA court, MLB ballparks, soccer pitches, curling sheets, athletics stadiums, speed skating, short track and figure skating rinks, swimming pools, water polo fields, diving wells, artistic swimming areas, and the courts and fields of tennis, volleyball (indoor, beach and sitting), badminton, pickleball, table tennis, padel, squash, racquetball, sepak takraw, teqball, roundnet, netball, lacrosse, rugby, Australian football, Gaelic games, cricket, field hockey and handball, and the budo of judo, karate, kendo, sumo and kyudo with a dojo of tatami laid as real units, the MMA cage, with each team's name and logo on its side and the score in the middle, stands and a crowd, a pageant of flags, and a 3D view. Light and dark, accessible, a compact badge for lists, a helper for React and a custom element. Zero dependencies.",
   "keywords": [
     "sports",
@@ -71,7 +71,12 @@
     "./dist/full.js",
     "./dist/arenas.js",
     "./dist/parks.js",
-    "./dist/grounds.js"
+    "./dist/grounds.js",
+    "./dist/venues.all.js",
+    "./dist/walk.full.js",
+    "./dist/strings.js",
+    "./dist/strings.en.js",
+    "./dist/strings.ja.js"
   ],
   "main": "./dist/index.js",
   "module": "./dist/index.js",