@kahwee/sf-map-svg 0.3.0 → 1.0.0

package/dist/data/types.d.ts

@@ -0,0 +1,117 @@
+export type Position = readonly [number, number, ...number[]];
+export type Bounds = readonly [number, number, number, number];
+export type Geometry = {
+    readonly type: 'Point';
+    readonly coordinates: Position;
+} | {
+    readonly type: 'LineString' | 'MultiPoint';
+    readonly coordinates: readonly Position[];
+} | {
+    readonly type: 'Polygon';
+    readonly coordinates: readonly (readonly Position[])[];
+} | {
+    readonly type: 'MultiLineString';
+    readonly coordinates: readonly (readonly Position[])[];
+} | {
+    readonly type: 'MultiPolygon';
+    readonly coordinates: readonly (readonly (readonly Position[])[])[];
+} | {
+    readonly type: 'GeometryCollection';
+    readonly geometries: readonly Geometry[];
+};
+export interface Feature<P = Readonly<Record<string, unknown>>> {
+    readonly type: 'Feature';
+    readonly id: string;
+    readonly bbox: Bounds;
+    readonly properties: P;
+    readonly geometry: Geometry;
+}
+export interface DataSource {
+    readonly id: string;
+    readonly title: string;
+    readonly url: string;
+    readonly retrievedAt: string;
+    readonly definitionYear?: number;
+    readonly licenseUrl: string;
+}
+export interface Definition {
+    readonly kind: string;
+    readonly year?: number;
+    readonly description: string;
+}
+export interface FeatureCollection<P = Readonly<Record<string, unknown>>> {
+    readonly type: 'FeatureCollection';
+    readonly schemaVersion: 1;
+    readonly id: string;
+    readonly title: string;
+    readonly coordinateSystem: string;
+    readonly definition: Definition;
+    readonly sources: readonly DataSource[];
+    readonly topology?: {
+        readonly policy: 'disjoint-interiors';
+        readonly sharedBoundariesAllowed: boolean;
+        readonly method: string;
+        readonly tool: string;
+        readonly processedAt: string;
+        readonly sourceOverlapPairs: number;
+    };
+    readonly features: readonly Feature<P>[];
+}
+export type NeighborhoodSource = 'sf-find' | 'analysis' | 'realtor';
+export interface NeighborhoodProperties {
+    readonly name: string;
+    readonly canonicalName: string;
+    readonly sourceName: string;
+    readonly aliases: readonly string[];
+    readonly definitionSource: NeighborhoodSource;
+    readonly nameSources: readonly string[];
+    readonly note?: string;
+    readonly sourceCode?: string;
+    readonly realtorDistrict?: string;
+}
+export interface NeighborhoodEntry extends NeighborhoodProperties {
+    readonly id: string;
+    readonly source: NeighborhoodSource;
+    readonly file: string;
+    readonly bbox: Bounds;
+}
+export interface DistrictProperties {
+    readonly district: number;
+    readonly name: string;
+    readonly year: 2002 | 2012 | 2022;
+    readonly label: Position;
+    readonly labelPoints: readonly Position[];
+    readonly displayExtras: Geometry | null;
+}
+export interface Catalog {
+    readonly schemaVersion: 1;
+    readonly description: string;
+    readonly datasets: readonly {
+        readonly id: string;
+        readonly file: string;
+        readonly title: string;
+        readonly featureCount: number;
+        readonly definition: Definition;
+        readonly sources: readonly DataSource[];
+    }[];
+    readonly neighborhoods: readonly NeighborhoodEntry[];
+}
+export type NeighborhoodFeature = Feature<NeighborhoodProperties>;
+export type PolygonGeometry = Extract<Geometry, {
+    readonly type: 'Polygon';
+}>;
+export type MultiPolygonGeometry = Extract<Geometry, {
+    readonly type: 'MultiPolygon';
+}>;
+export interface LandmarkProperties {
+    readonly name: string;
+    readonly label: Position;
+    readonly offset: readonly [number, number];
+    readonly anchor: 'middle' | 'start' | 'end';
+}
+export interface KeyRoadProperties {
+    readonly name: string;
+    readonly sourceNames: readonly string[];
+    readonly label: Position;
+    readonly segmentIds: readonly string[];
+}

package/dist/data/types.js

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

package/dist/src/data.d.ts

@@ -0,0 +1,25 @@
+import type { Geometry, Position } from '../data/types.js';
+export interface DistrictRow {
+    id: number;
+    label: Position;
+    labelPoints: readonly Position[];
+    geometry: Geometry;
+    extras: Geometry | null;
+}
+declare const _default: {
+    coast: Geometry;
+    districts: {
+        2002: DistrictRow[];
+        2012: DistrictRow[];
+        2022: DistrictRow[];
+    };
+    neighborhoods: {
+        name: string;
+        geometry: Geometry;
+    }[];
+    highways: {
+        route: string;
+        geometry: Geometry;
+    }[];
+};
+export default _default;

package/{src → dist/src}/data.js

@@ -4,32 +4,29 @@ import coast from '../data/coast.json' with { type: 'json' };
 import districts2002 from '../data/districts-2002.json' with { type: 'json' };
 import districts2012 from '../data/districts-2012.json' with { type: 'json' };
 import districts2022 from '../data/districts-2022.json' with { type: 'json' };
-import neighborhoods from '../data/neighborhoods-realtor.json' with { type: 'json' };
 import highways from '../data/highways.json' with { type: 'json' };
+import neighborhoods from '../data/neighborhoods-realtor.json' with { type: 'json' };
 import { deepFreeze } from './immutable.js';
-
-const districtRows = (collection) =>
-  collection.features.map(({ geometry, properties }) => ({
+const districtRows = (collection) => collection.features.map(({ geometry, properties }) => ({
     id: properties.district,
     label: properties.label,
     labelPoints: properties.labelPoints,
     geometry,
     extras: properties.displayExtras,
-  }));
-
+}));
 export default deepFreeze({
-  coast: coast.features[0].geometry,
-  districts: {
-    2002: districtRows(districts2002),
-    2012: districtRows(districts2012),
-    2022: districtRows(districts2022),
-  },
-  neighborhoods: neighborhoods.features.map(({ geometry, properties }) => ({
-    name: properties.sourceName,
-    geometry,
-  })),
-  highways: highways.features.map(({ geometry, properties }) => ({
-    route: properties.route,
-    geometry,
-  })),
+    coast: coast.features[0].geometry,
+    districts: {
+        2002: districtRows(districts2002),
+        2012: districtRows(districts2012),
+        2022: districtRows(districts2022),
+    },
+    neighborhoods: neighborhoods.features.map(({ geometry, properties }) => ({
+        name: properties.sourceName,
+        geometry,
+    })),
+    highways: highways.features.map(({ geometry, properties }) => ({
+        route: properties.route,
+        geometry,
+    })),
 });

package/dist/src/explorer-layout.d.ts

@@ -0,0 +1,23 @@
+import type { Bounds, Geometry, Position } from '../data/index.js';
+type Project = (position: Position) => [number, number];
+export type View = [number, number, number];
+export interface LabelCandidate {
+    x: number;
+    y: number;
+    textWidth: number;
+    textHeight?: number;
+    offset?: number;
+}
+export type PlacedLabel<T> = T & {
+    left: number;
+    top: number;
+    box: Bounds;
+};
+export declare function projectedBounds(geometry: Geometry, project: Project): Bounds;
+/** Find an interior label anchor using even-odd scanline intervals, including holes. */
+export declare function interiorAnchor(geometry: Geometry, project: Project): [number, number] | undefined;
+export declare function clampView([x, y, size]: View): View;
+export declare function fitBounds([minX, minY, maxX, maxY]: Bounds, padding?: number): View;
+/** Candidates arrive in priority order and carry measured screen-pixel widths. */
+export declare function layoutLabels<T extends LabelCandidate>(candidates: readonly T[], width: number, height: number, obstacles?: readonly Bounds[]): PlacedLabel<T>[];
+export {};

package/dist/src/explorer-layout.js

@@ -0,0 +1,72 @@
+import { positions } from './geometry.js';
+export function projectedBounds(geometry, project) {
+    return positions(geometry)
+        .map(project)
+        .reduce((b, [x, y]) => [Math.min(b[0], x), Math.min(b[1], y), Math.max(b[2], x), Math.max(b[3], y)], [Infinity, Infinity, -Infinity, -Infinity]);
+}
+/** Find an interior label anchor using even-odd scanline intervals, including holes. */
+export function interiorAnchor(geometry, project) {
+    if (geometry.type !== 'Polygon' && geometry.type !== 'MultiPolygon')
+        return undefined;
+    const polygons = geometry.type === 'Polygon' ? [geometry.coordinates] : geometry.coordinates;
+    let best;
+    let bestScore = -Infinity;
+    for (const polygon of polygons) {
+        const rings = polygon.map((ring) => ring.map(project));
+        const ys = rings[0].map((p) => p[1]);
+        const lo = Math.min(...ys), hi = Math.max(...ys);
+        for (let step = 1; step < 32; step++) {
+            const y = lo + ((hi - lo) * step) / 32;
+            const intersections = [];
+            for (const ring of rings) {
+                for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+                    const a = ring[i], b = ring[j];
+                    if (a[1] > y !== b[1] > y)
+                        intersections.push(a[0] + ((y - a[1]) * (b[0] - a[0])) / (b[1] - a[1]));
+                }
+            }
+            intersections.sort((a, b) => a - b);
+            for (let i = 0; i + 1 < intersections.length; i += 2) {
+                const width = intersections[i + 1] - intersections[i];
+                const score = width * (1 - Math.abs(step - 16) / 64);
+                if (width > 0 && score > bestScore) {
+                    bestScore = score;
+                    best = [(intersections[i] + intersections[i + 1]) / 2, y];
+                }
+            }
+        }
+    }
+    return best;
+}
+export function clampView([x, y, size]) {
+    size = Math.max(800 / 12, Math.min(800, size));
+    return [Math.max(0, Math.min(800 - size, x)), Math.max(0, Math.min(800 - size, y)), size];
+}
+export function fitBounds([minX, minY, maxX, maxY], padding = 0.18) {
+    const size = Math.max(800 / 12, Math.min(800, Math.max(maxX - minX, maxY - minY) * (1 + padding * 2)));
+    return clampView([(minX + maxX - size) / 2, (minY + maxY - size) / 2, size]);
+}
+/** Candidates arrive in priority order and carry measured screen-pixel widths. */
+export function layoutLabels(candidates, width, height, obstacles = []) {
+    const placed = [];
+    for (const candidate of candidates) {
+        const { x, y, textWidth, textHeight = 15, offset = 0 } = candidate;
+        const alternatives = offset
+            ? [
+                [x + offset, y - textHeight / 2],
+                [x - offset - textWidth, y - textHeight / 2],
+                [x - textWidth / 2, y - offset - textHeight],
+            ]
+            : [[x - textWidth / 2, y - textHeight / 2]];
+        for (const [left, top] of alternatives) {
+            const box = [left - 3, top - 3, left + textWidth + 3, top + textHeight + 3];
+            if (box[0] < 2 || box[1] < 2 || box[2] > width - 2 || box[3] > height - 2)
+                continue;
+            if ([...obstacles, ...placed.map((item) => item.box)].some((b) => box[0] < b[2] && box[2] > b[0] && box[1] < b[3] && box[3] > b[1]))
+                continue;
+            placed.push({ ...candidate, left, top, box });
+            break;
+        }
+    }
+    return placed;
+}

package/dist/src/explorer.d.ts

@@ -0,0 +1,4 @@
+import type { NeighborhoodExplorerElement, NeighborhoodExplorerOptions } from './types.js';
+export type { ExplorerMode, NeighborhoodExplorerElement, NeighborhoodExplorerOptions, } from './types.js';
+/** Create an offline, browser-only neighborhood explorer. Call destroy() before disposal. */
+export declare function createNeighborhoodExplorer({ source, mode, labels, neighborhood, year, theme, interface: chrome, layers, selectableNeighborhoods, labelSize, fitPadding, markers: initialMarkers, markerRadius, markerHitSize, markerColor, selectedMarkerColor, onMarkerActivate, }?: NeighborhoodExplorerOptions): NeighborhoodExplorerElement;