@riebeckite/plugin-map 0.0.6

package/dist/src/parse.d.ts

@@ -0,0 +1,35 @@
+import type { MapCoordinates, MapData } from "./types.js";
+/**
+ * Parses a fenced `map` code block into a notation-neutral {@link MapData}.
+ *
+ * The body is a small, dependency-free key/value format:
+ *
+ * ```text
+ * center: 35.6812, 139.7671
+ * zoom: 13
+ * label: Tokyo Station
+ * markers:
+ *   - 35.6812, 139.7671 | Tokyo Station
+ *   - 35.6586, 139.7454 | Tokyo Tower | A lattice tower
+ * ```
+ *
+ * A bare `lat, lng` line is treated as an implicit marker, so a single-point
+ * map can be written as just the coordinates. Returns `null` when the body
+ * contains neither a marker nor a center, which the rehype transformer reports
+ * as an invalid block.
+ */
+export declare function parseMapSource(source: string): MapData | null;
+/**
+ * Normalizes a frontmatter value into {@link MapData}.
+ *
+ * Accepts a coordinate string (`"35.68, 139.76"`), a `[lat, lng]` pair, an
+ * array of markers, or an object with `lat`/`lng` (or `latitude`/`longitude`),
+ * `zoom`, `label`, `tiles`, `attribution`, `image`, and `markers`.
+ */
+export declare function normalizeMapInput(value: unknown): MapData | null;
+/** Formats coordinates for display (`35.6812, 139.7671`). */
+export declare function formatCoordinates(coordinates: MapCoordinates): string;
+/** Builds a human-readable label for the whole map. */
+export declare function describeMap(data: MapData): string;
+/** Builds an OpenStreetMap link centered on the coordinates. */
+export declare function openStreetMapUrl(coordinates: MapCoordinates, zoom: number): string;

package/dist/src/rehype.d.ts

@@ -0,0 +1,11 @@
+import type { HastNode, MapOptions } from "./types.js";
+/**
+ * Replaces every fenced `map` code block with a map figure, and prepends a
+ * figure for the configured frontmatter property when present.
+ *
+ * The figure carries the resolved map data in `data-rr-map-payload` and a
+ * static fallback (coordinates, place, OpenStreetMap links) so the page is
+ * usable without JavaScript. `initMap` upgrades each figure to an interactive
+ * Leaflet map in the browser.
+ */
+export declare function rehypeMap(options?: MapOptions): (tree: HastNode, file: unknown) => void;

package/dist/src/types.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Public types for the Map plugin.
+ *
+ * This module is imported by the build-time transformer, the browser
+ * initializer, and the package entry point, so it must stay free of Node-only
+ * imports.
+ */
+/** A single latitude/longitude pair. */
+export type MapCoordinates = {
+    lat: number;
+    lng: number;
+};
+/** A marker on the map, optionally named. */
+export type MapMarker = MapCoordinates & {
+    /** Human-readable place name, shown in the popup and static fallback. */
+    label?: string;
+    /** Optional longer text shown in the marker popup. */
+    description?: string;
+};
+/**
+ * A parsed map specification. It is the notation-neutral seam of the plugin:
+ * the fenced-block parser and the frontmatter normalizer both produce it, and
+ * the figure emitter consumes it without knowing the input notation.
+ */
+export type MapData = {
+    /** Markers to draw, in document order. May be empty when only a view is set. */
+    markers: MapMarker[];
+    /** Explicit map center. Defaults to the first marker when omitted. */
+    center?: MapCoordinates;
+    /** Zoom level. Defaults to the plugin option when omitted. */
+    zoom?: number;
+    /** Human-readable place name for the whole map. */
+    label?: string;
+    /** Per-map tile URL template override. */
+    tiles?: string;
+    /** Per-map attribution override. */
+    attribution?: string;
+    /** Per-map static image URL (already resolved). */
+    image?: string;
+};
+/** Options accepted by the `map` plugin factory. */
+export type MapOptions = {
+    /** Fenced-code language to recognize. Defaults to `"map"`. */
+    language?: string;
+    /** Base CSS class applied to the figure. Defaults to `"rr-map"`. */
+    className?: string;
+    /** Map height in pixels. Defaults to `320`. */
+    height?: number;
+    /** Default zoom level (0–19). Defaults to `13`. */
+    zoom?: number;
+    /** Minimum zoom level forwarded to the tile layer. Defaults to `1`. */
+    minZoom?: number;
+    /** Maximum zoom level forwarded to the tile layer. Defaults to `19`. */
+    maxZoom?: number;
+    /**
+     * Tile URL template with `{z}`, `{x}`, `{y}` placeholders. Defaults to the
+     * OpenStreetMap standard tiles. See the README for the tile usage policy.
+     */
+    tileUrl?: string;
+    /**
+     * Attribution HTML required by the tile provider. Defaults to the
+     * OpenStreetMap attribution. Keep it visible on every map.
+     */
+    attribution?: string;
+    /** Render a `<details>` block holding the raw block source. Defaults to `true`. */
+    fallback?: boolean;
+    /**
+     * Render the static fallback (coordinates, place, OpenStreetMap links) that
+     * stays visible when JavaScript is disabled. Defaults to `true`.
+     */
+    staticFallback?: boolean;
+    /**
+     * Optional static image URL template with `{lat}`, `{lng}`, `{zoom}`, `{width}`
+     * and `{height}` placeholders. No default: a static map service usually needs
+     * a key, which site owners must supply themselves.
+     */
+    staticImageUrl?: string;
+    /** Frontmatter property holding map coordinates. Defaults to `"map"`. */
+    frontmatterKey?: string;
+};
+/** Options after defaults have been applied. */
+export type ResolvedMapOptions = {
+    language: string;
+    className: string;
+    height: number;
+    zoom: number;
+    minZoom: number;
+    maxZoom: number;
+    tileUrl: string;
+    attribution: string;
+    fallback: boolean;
+    staticFallback: boolean;
+    staticImageUrl: string | null;
+    frontmatterKey: string;
+};
+/** The JSON payload embedded in the figure and consumed by `initMap`. */
+export type MapPayload = {
+    markers: MapMarker[];
+    center: MapCoordinates;
+    zoom: number;
+    label: string | null;
+    tiles: string;
+    attribution: string;
+    image: string | null;
+};
+/** Options accepted by `initMap` when called programmatically. */
+export type MapClientOptions = {
+    /** Default tile URL when a figure does not carry its own. */
+    tileUrl?: string;
+    /** Default attribution when a figure does not carry its own. */
+    attribution?: string;
+    /** Default minimum zoom level. Defaults to `1`. */
+    minZoom?: number;
+    /** Default maximum zoom level. Defaults to `19`. */
+    maxZoom?: number;
+    /** ESM/UMD URL of the Leaflet script. Defaults to the pinned jsDelivr build. */
+    leafletScriptUrl?: string;
+    /** URL of the Leaflet stylesheet. Defaults to the pinned jsDelivr build. */
+    leafletStyleUrl?: string;
+    /** Preloaded Leaflet runtime, used to skip the network load. */
+    runtime?: MapRuntime;
+};
+/** The subset of the Leaflet API the initializer uses. */
+export type LeafletLayer = {
+    addTo(map: LeafletMap): LeafletLayer;
+    bindPopup?(content: string): LeafletLayer;
+};
+export type LeafletMap = {
+    setView(center: [number, number], zoom: number): LeafletMap;
+    fitBounds(bounds: unknown, options?: Record<string, unknown>): LeafletMap;
+    remove(): void;
+};
+export type MapRuntime = {
+    map(element: HTMLElement, options?: Record<string, unknown>): LeafletMap;
+    tileLayer(url: string, options?: Record<string, unknown>): LeafletLayer;
+    marker(coordinates: [number, number], options?: Record<string, unknown>): LeafletLayer;
+    latLngBounds(coordinates: Array<[number, number]>): unknown;
+};
+export type ElementNode = {
+    type: string;
+    tagName?: string;
+    properties?: Record<string, unknown>;
+    children?: HastNode[];
+};
+export type ParentNode = HastNode & {
+    children?: HastNode[];
+};
+export type TextNode = {
+    type: "text";
+    value: string;
+};
+export type RawNode = {
+    type: "raw";
+    value: string;
+};
+export type HastNode = ElementNode | TextNode | RawNode | {
+    type: string;
+    [key: string]: unknown;
+};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@riebeckite/plugin-map",
+  "version": "0.0.6",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "source": "./index.ts",
+      "default": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js",
+      "source": "./client.ts",
+      "default": "./dist/client.js"
+    },
+    "./style.css": "./style.css"
+  },
+  "dependencies": {
+    "@riebeckite/core": "0.0.6"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "README_ja.md",
+    "dist",
+    "style.css"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Rerurate514/riebeckite.git",
+    "directory": "packages/plugins/map"
+  },
+  "homepage": "https://github.com/Rerurate514/riebeckite#readme",
+  "bugs": {
+    "url": "https://github.com/Rerurate514/riebeckite/issues"
+  },
+  "description": "Interactive and static OpenStreetMap embeds for Riebeckite.",
+  "keywords": [
+    "riebeckite",
+    "plugin",
+    "map",
+    "openstreetmap",
+    "leaflet"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "sideEffects": [
+    "./style.css"
+  ],
+  "scripts": {
+    "build": "node ../../../scripts/build_package.mjs"
+  }
+}

package/style.css

@@ -0,0 +1,107 @@
+.rr-map {
+  --rr-map-paper: var(--rb-color-paper, #ffffff);
+  --rr-map-ink: var(--rb-color-ink, #000000);
+  --rr-map-muted: var(--rb-color-muted, #69645c);
+  --rr-map-rule: var(
+    --rb-color-border,
+    color-mix(in srgb, var(--rr-map-ink) 18%, transparent)
+  );
+  --rr-map-accent: var(--rb-color-accent, #0b6e99);
+  margin: 2rem 0;
+  border: 1px solid var(--rr-map-rule);
+  background: color-mix(in srgb, var(--rr-map-paper) 96%, var(--rr-map-ink));
+  color: var(--rr-map-ink);
+}
+
+.rr-map__caption {
+  padding: 0.625rem 0.75rem;
+  border-bottom: 1px solid var(--rr-map-rule);
+  color: var(--rr-map-muted);
+  font-size: 0.875rem;
+}
+
+.rr-map__canvas {
+  height: 320px;
+  background: color-mix(in srgb, var(--rr-map-ink) 4%, transparent);
+}
+
+.rr-map:not([data-rr-map="rendered"]) .rr-map__canvas {
+  display: none;
+}
+
+.rr-map__canvas .leaflet-container {
+  background: transparent;
+  font: inherit;
+}
+
+.rr-map__static {
+  padding: 0.75rem 0.875rem 0.875rem;
+  border-top: 1px solid var(--rr-map-rule);
+}
+
+.rr-map__image {
+  display: block;
+  width: 100%;
+  height: auto;
+  margin-bottom: 0.75rem;
+  border: 1px solid var(--rr-map-rule);
+}
+
+.rr-map__place {
+  margin: 0 0 0.5rem;
+  font-weight: 600;
+}
+
+.rr-map__markers {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  display: grid;
+  gap: 0.25rem;
+}
+
+.rr-map__marker {
+  color: var(--rr-map-muted);
+  font-size: 0.875rem;
+}
+
+.rr-map__link {
+  color: var(--rr-map-accent);
+}
+
+.rr-map__attribution {
+  margin: 0.625rem 0 0;
+  color: var(--rr-map-muted);
+  font-size: 0.75rem;
+}
+
+.rr-map__fallback {
+  border-top: 1px solid var(--rr-map-rule);
+  color: var(--rr-map-muted);
+  font-size: 0.8125rem;
+}
+
+.rr-map__fallback summary {
+  cursor: pointer;
+  padding: 0.5rem 0.75rem;
+}
+
+.rr-map__fallback pre {
+  overflow: auto;
+  margin: 0 1rem;
+  padding: 0.75rem;
+  border-top: 1px solid var(--rr-map-rule);
+  color: var(--rr-map-ink);
+  background: color-mix(in srgb, var(--rr-map-ink) 6%, transparent);
+}
+
+.rr-map[data-rr-map="error"] .rr-map__static::before {
+  content: "The interactive map could not be loaded. ";
+  color: var(--rr-map-muted);
+}
+
+html[data-theme="dark"] .rr-map,
+html.dark .rr-map {
+  --rr-map-paper: var(--rb-color-ink, #000000);
+  --rr-map-ink: var(--rb-color-paper, #ffffff);
+}