@osm-editor-kit/osm-editor-links 0.0.0-stage → 0.1.0-alpha.1

package/README.md

@@ -1,3 +1,70 @@
-# Temporary Holding Version
+# `@osm-editor-kit/osm-editor-links`
 
-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.
+> [!NOTE]
+> This package is an **alpha** release and still under active development. APIs may change; install with the npm `alpha` dist-tag.
+
+## What it does
+
+- Link lists for one OSM element, one changeset or one user: the OSM website, history, editors, viewers and JOSM, with a stable `id` and an English label per link
+- `linksIn` keeps the links offered at a country (for example TILDA only in Germany)
+- Deep links to osm.org element and changeset pages, web editors (iD, Rapid), JOSM remote control, OSM API map downloads, Mapillary, OSM Deep History, OSMCha and TILDA inspector URLs
+- OSM type helpers and a JOSM link-click handler
+
+## Link lists
+
+```ts
+import { elementLinks, changesetLinks, userLinks, linksIn } from '@osm-editor-kit/osm-editor-links'
+
+elementLinks({ type: 'way', id: 123, loc: { lat: 52.5, lng: 13.4 } })
+// osm-history, osm, deep-history, pewu, id, rapid, josm, level0,
+// mapillary, panoramax, tilda (tilda only with countries ['de'])
+
+changesetLinks({ id: 42 }) // osm-changeset, osmcha, achavi, resultmaps, osm-revert, josm, level0
+userLinks({ name: 'Anna Müller' }) // osm-user, hdyc, osmcha-user, missingmaps
+```
+
+Each link is `{ id, label, url, countries?, josm? }`. Apps translate by `id` and fall back to `label`. A link with `josm: true` opens with `handleJosmLinkClick` (JOSM remote control) instead of a new tab.
+
+Pass `server` to edit on another OSM website, for example the development server `https://master.apis.dev.openstreetmap.org`. The default is `https://www.openstreetmap.org`. Other servers get only their own links (element history and object page, changeset page, user profile); third-party tools only read production data.
+
+```ts
+const links = elementLinks({ type: 'way', id: 123, loc: { lat: 52.5, lng: 13.4 } })
+const offered = linksIn(links, ['de']) // keeps TILDA; with ['fr'] it is dropped
+```
+
+## Other helpers
+
+```ts
+import {
+  osmOrgUrl,
+  osmEditIdUrl,
+  josmLoadObjectUrl,
+  idEditorUrl,
+  getUrl,
+  mapillaryUrl,
+  osmchaChangesetUrl,
+  tildaInspectorUrl,
+  handleJosmLinkClick,
+  osmProdUrl,
+} from '@osm-editor-kit/osm-editor-links'
+
+osmOrgUrl({ osmType: 'way', osmId: 123 }) // → https://www.openstreetmap.org/way/123
+osmEditIdUrl({ osmType: 'way', osmId: 123, hashtags: 'TILDA' })
+
+josmLoadObjectUrl({ osmType: 'way', osmId: 123 }) // http://127.0.0.1:8111/load_object?…
+idEditorUrl({ center: { lat: 52.47, lng: 13.44 }, zoom: 16 })
+
+getUrl({ west: 13.4, south: 52.4, east: 13.5, north: 52.5 }, false) // OSM API map bbox URL
+mapillaryUrl({ lat: 52.47, lng: 13.44 }, { dateFrom: '2024-01-01' })
+
+osmchaChangesetUrl(12345)
+tildaInspectorUrl({
+  regionSlug: 'radinfra',
+  map: { zoom: 16, lat: 52.47, lng: 13.44 },
+  features: { sourceId: 'atlas_bikelanes', featureId: 123, coords: [13.44, 52.47] },
+})
+
+await handleJosmLinkClick(event) // JOSM remote-control link click (fetches the link, no navigation)
+```
+
+Depends on `@osm-editor-kit/osm-data` for shared map bounds and OSM object types.

package/dist/editor-template.d.ts

@@ -0,0 +1,14 @@
+import type { LatLngLiteral } from '@osm-editor-kit/osm-data';
+import type { OsmObjectType } from './osm-type';
+export type EditorUrlTemplateVars = {
+    zoom?: number;
+    center: LatLngLiteral;
+    osmType?: OsmObjectType | null;
+    osmId?: number | string | null;
+    editorId?: string | number | null;
+};
+/**
+ * Fill `{zoom}`, `{latitude}`, `{longitude}`, `{short_osm_type}`, `{long_osm_type}`,
+ * `{editor_id}`, `{osm_id}` placeholders in an editor URL template (TILDA-style).
+ */
+export declare function fillEditorUrlTemplate(urlTemplate: string, vars: EditorUrlTemplateVars): string;

package/dist/editors.d.ts

@@ -0,0 +1,43 @@
+import type { LatLngLiteral } from '@osm-editor-kit/osm-data';
+import { type OsmNode, type OsmRelation, type OsmWay } from '@osm-editor-kit/osm-data';
+import { josmUrl } from './hosts';
+import type { OsmObjectType } from './osm-type';
+export { josmUrl };
+type IdEditorUrlProps = {
+    center?: LatLngLiteral;
+    zoom?: number;
+    background?: string;
+    osmObjectType?: OsmRelation['type'] | OsmWay['type'] | OsmNode['type'];
+    osmObjectId?: number | string;
+};
+/** iD hosted on ideditor-release.netlify.app (parking-lanes default). */
+export declare function idEditorUrl({ center, zoom, background, osmObjectType, osmObjectId, }: IdEditorUrlProps): string;
+type OsmEditIdUrlProps = {
+    osmType: OsmObjectType | null | undefined;
+    osmId: number | string | null | undefined;
+    comment?: string;
+    hashtags?: string;
+    source?: string;
+};
+/** Official OSM.org iD edit URL (TILDA-style, with optional hashtags). */
+export declare function osmEditIdUrl({ osmType, osmId, comment, hashtags, source, }: OsmEditIdUrlProps): string | undefined;
+export declare function osmEditRapidUrl(options: {
+    osmType: OsmObjectType | null | undefined;
+    osmId: number | string | null | undefined;
+    hashtags?: string;
+    locale?: string;
+}): string | undefined;
+export declare function osmEditKyleKiwiIdUrl(options: {
+    osmType: OsmObjectType | null | undefined;
+    osmId: number | string | null | undefined;
+    hashtags?: string;
+    locale?: string;
+}): string | undefined;
+/** JOSM remote control `load_object` for a single OSM element. */
+export declare function josmLoadObjectUrl(options: {
+    osmType: OsmObjectType | null | undefined;
+    osmId: number | string | null | undefined;
+    changesetHashtags?: string;
+}): string | undefined;
+/** Prefix for JOSM `import?url=` (Overpass / map download). Same as `josmUrl`. */
+export declare function josmImportUrl(): string;

package/dist/history.d.ts

@@ -0,0 +1,6 @@
+import type { OsmObjectType } from './osm-type';
+/** OSM Deep History viewer (TILDA “Änderungshistorie”). */
+export declare function osmDeepHistoryUrl(options: {
+    osmType: OsmObjectType | null | undefined;
+    osmId: number | string | null | undefined;
+}): string | undefined;

package/dist/hosts.d.ts

@@ -0,0 +1,23 @@
+/** JOSM remote-control base for `import?url=` (Overpass / map download). */
+export declare const josmRemoteBase = "http://127.0.0.1:8111";
+/** @deprecated Prefer `josmImportUrl` / `josmLoadObjectUrl`; kept for existing callers. */
+export declare const josmUrl = "http://127.0.0.1:8111/import?url=";
+export declare const osmProdUrl = "https://www.openstreetmap.org";
+/** Production OSM API host (OAuth, map downloads, changeset upload). */
+export declare const osmProdApiUrl = "https://api.openstreetmap.org";
+export declare const osmDevUrl = "https://master.apis.dev.openstreetmap.org";
+export declare const osmchaBase = "https://osmcha.org";
+export declare const tildaGeoBase = "https://tilda-geo.de";
+export declare const osmDeepHistoryBase = "https://osmlab.github.io/osm-deep-history";
+/** Third-party viewers and editors, used by the link lists. */
+export declare const pewuHistoryBase = "https://pewu.github.io/osm-history";
+export declare const rapidBase = "https://rapideditor.org";
+export declare const level0Base = "http://level0.osmz.ru";
+export declare const mapillaryBase = "https://www.mapillary.com";
+export declare const panoramaxBase = "https://api.panoramax.xyz";
+export declare const tildaViewerBase = "https://viewer.tilda-geo.de";
+export declare const achaviBase = "https://overpass-api.de/achavi";
+export declare const resultMapsBase = "https://resultmaps.neis-one.org";
+export declare const osmRevertBase = "https://revert.monicz.dev";
+export declare const hdycBase = "https://hdyc.neis-one.org";
+export declare const missingMapsBase = "https://www.missingmaps.org";

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { fillEditorUrlTemplate, type EditorUrlTemplateVars } from './editor-template';
+export { idEditorUrl, josmImportUrl, josmLoadObjectUrl, josmUrl, osmEditIdUrl, osmEditKyleKiwiIdUrl, osmEditRapidUrl, } from './editors';
+export { osmDeepHistoryUrl } from './history';
+export { josmRemoteBase, osmchaBase, osmDeepHistoryBase, osmDevUrl, osmProdApiUrl, osmProdUrl, tildaGeoBase, } from './hosts';
+export { handleJosmLinkClick } from './josm';
+export { changesetLinks, elementLinks, linksIn, userLinks, type ChangesetLinksOptions, type ElementLinksOptions, type OsmLink, type UserLinksOptions, } from './link-lists';
+export { getUrl } from './map-download-url';
+export { mapillaryRecentPanosUrl, mapillaryUrl, type MapillaryUrlOptions } from './mapillary';
+export { osmChangesetUrl, osmObjectHistoryUrl, osmOrgUrl, type OsmTypeId } from './osm-object';
+export { longOsmType, shortOsmType, toLongOsmType, toShortOsmType, type OsmObjectType, type OsmShortType, } from './osm-type';
+export { osmchaChangesetUrl, osmchaFiltersUrl, type OsmchaFiltersInput, type OsmchaFilterValue, } from './osmcha';
+export { serializeTildaFeaturesParam, TILDA_INFRA_PRESETS, TILDA_SOURCE_NUMERIC_IDS, tildaInfraSourceNumericId, tildaInspectorUrl, tildaInspectorUrlForInfra, tildaSourceIdFromNumeric, tildaSourceNumericId, type TildaFeatureCoord, type TildaFeatureParam, type TildaInfra, type TildaInfraPreset, type TildaInspectorForInfraOptions, type TildaInspectorUrlOptions, type TildaMapPosition, } from './tilda';

package/dist/index.js

@@ -0,0 +1,419 @@
+// src/osm-type.ts
+var longOsmType = {
+  W: "way",
+  N: "node",
+  R: "relation",
+  w: "way",
+  n: "node",
+  r: "relation",
+  way: "way",
+  node: "node",
+  relation: "relation"
+};
+var shortOsmType = {
+  way: "w",
+  node: "n",
+  relation: "r",
+  w: "w",
+  n: "n",
+  r: "r",
+  W: "w",
+  N: "n",
+  R: "r"
+};
+function toLongOsmType(type) {
+  return longOsmType[type];
+}
+function toShortOsmType(type) {
+  return shortOsmType[type];
+}
+
+// src/editor-template.ts
+function fillEditorUrlTemplate(urlTemplate, vars) {
+  const short = vars.osmType ? toShortOsmType(vars.osmType) ?? "" : "";
+  return urlTemplate.replaceAll("{zoom}", vars.zoom?.toString() ?? "19").replaceAll("{latitude}", String(vars.center.lat)).replaceAll("{longitude}", String(vars.center.lng)).replaceAll("{short_osm_type}", short).replaceAll("{long_osm_type}", vars.osmType ?? "").replaceAll("{editor_id}", vars.editorId != null ? String(vars.editorId) : "").replaceAll("{osm_id}", vars.osmId != null ? String(vars.osmId) : "");
+}
+
+// src/hosts.ts
+var josmRemoteBase = "http://127.0.0.1:8111";
+var josmUrl = `${josmRemoteBase}/import?url=`;
+var osmProdUrl = "https://www.openstreetmap.org";
+var osmProdApiUrl = "https://api.openstreetmap.org";
+var osmDevUrl = "https://master.apis.dev.openstreetmap.org";
+var osmchaBase = "https://osmcha.org";
+var tildaGeoBase = "https://tilda-geo.de";
+var osmDeepHistoryBase = "https://osmlab.github.io/osm-deep-history";
+var pewuHistoryBase = "https://pewu.github.io/osm-history";
+var rapidBase = "https://rapideditor.org";
+var level0Base = "http://level0.osmz.ru";
+var mapillaryBase = "https://www.mapillary.com";
+var panoramaxBase = "https://api.panoramax.xyz";
+var tildaViewerBase = "https://viewer.tilda-geo.de";
+var achaviBase = "https://overpass-api.de/achavi";
+var resultMapsBase = "https://resultmaps.neis-one.org";
+var osmRevertBase = "https://revert.monicz.dev";
+var hdycBase = "https://hdyc.neis-one.org";
+var missingMapsBase = "https://www.missingmaps.org";
+
+// src/editors.ts
+function idEditorUrl({
+  center,
+  zoom,
+  background,
+  osmObjectType,
+  osmObjectId
+}) {
+  const params = {
+    disable_features: "boundaries",
+    photo_overlay: "streetside,mapillary,kartaview"
+  };
+  if (zoom && center) params.map = `${zoom}/${center.lat}/${center.lng}`;
+  if (background) params.background = background;
+  if (osmObjectType && osmObjectId) params.id = `${osmObjectType.charAt(0)}${osmObjectId}`;
+  const hashUrlParams = new URLSearchParams(params);
+  return `https://ideditor-release.netlify.app/#${hashUrlParams.toString()}`;
+}
+function osmEditIdUrl({
+  osmType,
+  osmId,
+  comment,
+  hashtags,
+  source
+}) {
+  if (!osmType || osmId == null || osmId === "") return void 0;
+  const url = new URL("https://www.openstreetmap.org/edit");
+  url.searchParams.append(osmType, String(osmId));
+  const hashParams = new URLSearchParams();
+  if (comment) hashParams.append("comment", comment);
+  if (source) hashParams.append("source", source);
+  if (hashtags) hashParams.append("hashtags", hashtags);
+  const hash = hashParams.toString();
+  return hash ? `${url.toString()}#${hash}` : url.toString();
+}
+function osmEditRapidUrl(options) {
+  const { osmType, osmId, hashtags = "TILDA", locale = "de" } = options;
+  if (!osmType || osmId == null || osmId === "") return void 0;
+  const short = toShortOsmType(osmType);
+  if (!short) return void 0;
+  return `https://rapideditor.org/edit#id=${short}${osmId}&disable_features=boundaries&locale=${locale}&hashtags=${hashtags}`;
+}
+function osmEditKyleKiwiIdUrl(options) {
+  const { osmType, osmId, hashtags = "TILDA", locale = "en" } = options;
+  if (!osmType || osmId == null || osmId === "") return void 0;
+  const short = toShortOsmType(osmType);
+  if (!short) return void 0;
+  return `https://kyle.kiwi/iD/#id=${short}${osmId}&locale=${locale}&disable_features=boundaries&hashtags=${hashtags}`;
+}
+function josmLoadObjectUrl(options) {
+  const { osmType, osmId, changesetHashtags = "TILDA" } = options;
+  if (!osmType || osmId == null || osmId === "") return void 0;
+  const short = toShortOsmType(osmType);
+  if (!short) return void 0;
+  const url = new URL(`${josmRemoteBase}/load_object`);
+  url.searchParams.set("objects", `${short}${osmId}`);
+  if (changesetHashtags) url.searchParams.set("changeset_hashtags", changesetHashtags);
+  return url.toString();
+}
+function josmImportUrl() {
+  return josmUrl;
+}
+
+// src/history.ts
+function osmDeepHistoryUrl(options) {
+  const { osmType, osmId } = options;
+  if (!osmType || osmId == null || osmId === "") return void 0;
+  return `${osmDeepHistoryBase}/#/${osmType}/${osmId}`;
+}
+
+// src/josm.ts
+async function handleJosmLinkClick(e) {
+  const anchor = e.target instanceof Element ? e.target.closest("a") : null;
+  if (!anchor) return;
+  await fetch(anchor.href);
+  e.preventDefault();
+}
+
+// src/osm-object.ts
+function osmOrgUrl({ osmType, osmId }, server = osmProdUrl) {
+  if (!osmType || osmId == null || osmId === "") return void 0;
+  return `${server}/${osmType}/${osmId}`;
+}
+function osmObjectHistoryUrl({ osmType, osmId }, server = osmProdUrl) {
+  if (!osmType || osmId == null || osmId === "") return void 0;
+  return `${server}/${osmType}/${osmId}/history`;
+}
+function osmChangesetUrl(changesetId, server = osmProdUrl) {
+  return `${server}/changeset/${changesetId}`;
+}
+
+// src/osmcha.ts
+function osmchaChangesetUrl(changesetId) {
+  return `${osmchaBase}/changesets/${changesetId}`;
+}
+function toFilterEntries(value) {
+  if (typeof value === "string") {
+    return [{ label: value, value }];
+  }
+  return value;
+}
+function osmchaFiltersUrl(filters) {
+  const encoded = {};
+  for (const [key, value] of Object.entries(filters)) {
+    if (value == null) continue;
+    encoded[key] = toFilterEntries(value);
+  }
+  const json = JSON.stringify(encoded);
+  return `${osmchaBase}/?filters=${encodeURIComponent(json)}`;
+}
+
+// src/link-lists.ts
+function link(id, label, url, extra) {
+  return url === void 0 ? void 0 : { id, label, url, ...extra };
+}
+function present(links) {
+  return links.filter((item) => item !== void 0);
+}
+function website(server) {
+  const base = (server ?? osmProdUrl).replace(/\/+$/, "");
+  return { base, production: base === osmProdUrl };
+}
+function elementLinks({ type, id, loc, zoom = 17, server }) {
+  const { base, production } = website(server);
+  const object = { osmType: type, osmId: id };
+  const links = [
+    link("osm-history", "OpenStreetMap history", osmObjectHistoryUrl(object, base)),
+    link("osm", "OpenStreetMap", osmOrgUrl(object, base))
+  ];
+  if (production) {
+    links.push(
+      link("deep-history", "OSM Deep History", osmDeepHistoryUrl(object)),
+      link("pewu", "PeWu history", id === "" ? void 0 : `${pewuHistoryBase}/#/${type}/${id}`),
+      link("id", "iD", osmEditIdUrl(object)),
+      link(
+        "rapid",
+        "Rapid",
+        id === "" ? void 0 : `${rapidBase}/edit#id=${shortOsmType[type]}${id}`
+      ),
+      link("josm", "JOSM", josmLoadObjectUrl({ osmType: type, osmId: id, changesetHashtags: "" }), {
+        josm: true
+      }),
+      link("level0", "Level0", id === "" ? void 0 : `${level0Base}/?url=${type}/${id}`)
+    );
+    if (loc) {
+      const { lat, lng } = loc;
+      links.push(
+        link(
+          "mapillary",
+          "Mapillary",
+          `${mapillaryBase}/app/?${new URLSearchParams({ lat: String(lat), lng: String(lng), z: String(zoom) })}`
+        ),
+        link("panoramax", "Panoramax", `${panoramaxBase}/?focus=map&map=${zoom}/${lat}/${lng}`),
+        link("tilda", "TILDA Viewer", `${tildaViewerBase}/?map=${zoom}/${lat}/${lng}`, {
+          countries: ["de"]
+        })
+      );
+    }
+  }
+  return present(links);
+}
+function changesetLinks({ id, server }) {
+  if (id === "") return [];
+  const { base, production } = website(server);
+  const links = [
+    link("osm-changeset", "OpenStreetMap changeset", osmChangesetUrl(id, base))
+  ];
+  if (production) {
+    links.push(
+      link("osmcha", "OSMCha", osmchaChangesetUrl(id)),
+      link("achavi", "achavi", `${achaviBase}/?changeset=${id}&relations=true`),
+      link("resultmaps", "ResultMaps", `${resultMapsBase}/osm-change-viz?c=${id}`),
+      link("osm-revert", "osm-revert", `${osmRevertBase}/?changesets=${id}`),
+      link("josm", "JOSM", `${josmImportUrl()}${osmProdUrl}/api/0.6/changeset/${id}/download`, {
+        josm: true
+      }),
+      link("level0", "Level0", `${level0Base}/?url=changeset/${id}`)
+    );
+  }
+  return present(links);
+}
+function userLinks({ name, server }) {
+  if (name === "") return [];
+  const { base, production } = website(server);
+  const encoded = encodeURIComponent(name);
+  const links = [
+    link("osm-user", "OpenStreetMap profile", `${base}/user/${encoded}`)
+  ];
+  if (production) {
+    links.push(
+      link("hdyc", "How did you contribute", `${hdycBase}/?${encoded}`),
+      link("osmcha-user", "OSMCha changesets", osmchaFiltersUrl({ users: name })),
+      link("missingmaps", "Missing Maps", `${missingMapsBase}/users/#/${encoded}`)
+    );
+  }
+  return present(links);
+}
+function linksIn(links, countryCodes) {
+  const codes = new Set(countryCodes.map((code) => code.toLowerCase()));
+  return links.filter(
+    (item) => !item.countries || item.countries.some((code) => codes.has(code.toLowerCase()))
+  );
+}
+
+// src/map-download-url.ts
+function getUrl(bounds, useDevServer) {
+  const bbox = [bounds.west, bounds.south, bounds.east, bounds.north].join(",");
+  return (useDevServer ? osmDevUrl : osmProdApiUrl) + "/api/0.6/map?bbox=" + bbox;
+}
+
+// src/mapillary.ts
+var MAPILLARY_RECENT_PANOS_YEARS = 3;
+function mapillaryUrl(center, options) {
+  const trafficSign = options?.trafficSign === false ? void 0 : options?.trafficSign ?? "all";
+  const params = new URLSearchParams({
+    lat: String(center.lat),
+    lng: String(center.lng),
+    z: String(options?.zoom ?? 17),
+    focus: "map"
+  });
+  if (trafficSign) params.set("trafficSign", trafficSign);
+  if (options?.dateFrom) params.set("dateFrom", options.dateFrom);
+  if (options?.dateTo) params.set("dateTo", options.dateTo);
+  if (options?.panosOnly) params.set("panos", "true");
+  return `https://www.mapillary.com/app/?${params.toString()}`;
+}
+function mapillaryRecentPanosUrl(center, options) {
+  const referenceDate = options?.referenceDate ?? /* @__PURE__ */ new Date();
+  const years = options?.years ?? MAPILLARY_RECENT_PANOS_YEARS;
+  const dateTo = formatMapillaryUtcDate(referenceDate);
+  const dateFromDate = new Date(referenceDate);
+  dateFromDate.setUTCFullYear(dateFromDate.getUTCFullYear() - years);
+  return mapillaryUrl(center, {
+    dateFrom: formatMapillaryUtcDate(dateFromDate),
+    dateTo,
+    panosOnly: true
+  });
+}
+function formatMapillaryUtcDate(date) {
+  return date.toISOString().slice(0, 10);
+}
+
+// src/tilda/sources.ts
+var TILDA_SOURCE_NUMERIC_IDS = {
+  1: "osm_notes",
+  2: "lars_parking",
+  3: "lars_parking_debug",
+  4: "lars_parking_points",
+  5: "lars_parking_areas",
+  6: "lars_parking_stats",
+  7: "atlas_boundaries",
+  8: "atlas_presenceStats",
+  9: "accidents_unfallatlas",
+  10: "atlas_bikelanes",
+  11: "atlas_bikeroutes",
+  12: "atlas_roads",
+  13: "atlas_roadsPathClasses",
+  14: "atlas_publicTransport",
+  15: "atlas_poiClassification",
+  16: "atlas_places",
+  17: "atlas_barriers",
+  18: "atlas_landuse",
+  19: "atlas_bicycleParking",
+  20: "atlas_trafficSigns",
+  21: "mapillary_coverage",
+  22: "atlas_bikelanesPresence",
+  23: "atlas_bikeSuitability",
+  24: "atlas_todos_lines",
+  25: "atlas_aggregated_lengths",
+  26: "tilda_parkings",
+  27: "tilda_parkings_cutouts",
+  28: "tilda_parkings_quantized",
+  30: "tilda_parkings_no",
+  31: "tilda_parkings_off_street",
+  32: "tilda_parkings_off_street_quantized"
+};
+var sourceIdToNumeric = new Map(
+  Object.entries(TILDA_SOURCE_NUMERIC_IDS).map(([id, name]) => [name, Number(id)])
+);
+function tildaSourceNumericId(sourceId) {
+  return sourceIdToNumeric.get(sourceId);
+}
+function tildaSourceIdFromNumeric(numericId) {
+  return TILDA_SOURCE_NUMERIC_IDS[numericId];
+}
+
+// src/tilda/features-param.ts
+var COORD_PRECISION = 6;
+function roundCoord(n) {
+  const factor = 10 ** COORD_PRECISION;
+  return String(Math.round(n * factor) / factor);
+}
+function resolveNumericSourceId(sourceId) {
+  if (typeof sourceId === "number") return sourceId;
+  if (/^\d+$/.test(sourceId)) return Number(sourceId);
+  return tildaSourceNumericId(sourceId);
+}
+function serializeOneFeature(feature) {
+  const numericId = resolveNumericSourceId(feature.sourceId);
+  if (numericId == null) return void 0;
+  const id = String(feature.featureId);
+  if (feature.coords.kind === "point") {
+    const { lon, lat } = feature.coords;
+    return `${numericId}|${id}|${roundCoord(lon)}|${roundCoord(lat)}`;
+  }
+  const { minLon, minLat, maxLon, maxLat } = feature.coords;
+  return `${numericId}|${id}|${roundCoord(minLon)}|${roundCoord(minLat)}|${roundCoord(maxLon)}|${roundCoord(maxLat)}`;
+}
+function serializeTildaFeaturesParam(features) {
+  const list = Array.isArray(features) ? features : [features];
+  const parts = list.map(serializeOneFeature).filter((p) => p != null);
+  if (parts.length === 0) return void 0;
+  return parts.join(",");
+}
+
+// src/tilda/inspector.ts
+var TILDA_INFRA_PRESETS = {
+  bikelanes: {
+    regionSlug: "radinfra",
+    sourceId: "atlas_bikelanes",
+    defaultConfig: "1v92rco.7h39.4pt3i8"
+  },
+  parking: {
+    regionSlug: "parkraum",
+    sourceId: "lars_parking",
+    defaultConfig: "12nl2cs.16lxxh"
+  }
+};
+function tildaInspectorUrl(options) {
+  const base = options.baseUrl ?? tildaGeoBase;
+  const url = new URL(`${base}/regionen/${options.regionSlug}`);
+  const { zoom, lat, lng } = options.map;
+  url.searchParams.set("map", `${zoom}/${lat}/${lng}`);
+  if (options.config) url.searchParams.set("config", options.config);
+  if (options.features) {
+    const f = serializeTildaFeaturesParam(options.features);
+    if (f) url.searchParams.set("f", f);
+  }
+  url.searchParams.set("v", String(options.version ?? 2));
+  return url.toString();
+}
+function tildaInspectorUrlForInfra(infra, options) {
+  const preset = TILDA_INFRA_PRESETS[infra];
+  const features = options.featureId != null && options.coords != null ? {
+    sourceId: preset.sourceId,
+    featureId: options.featureId,
+    coords: options.coords
+  } : void 0;
+  return tildaInspectorUrl({
+    regionSlug: preset.regionSlug,
+    map: options.map,
+    config: options.config ?? preset.defaultConfig,
+    features,
+    version: options.version,
+    baseUrl: options.baseUrl
+  });
+}
+function tildaInfraSourceNumericId(infra) {
+  return tildaSourceNumericId(TILDA_INFRA_PRESETS[infra].sourceId);
+}
+
+export { TILDA_INFRA_PRESETS, TILDA_SOURCE_NUMERIC_IDS, changesetLinks, elementLinks, fillEditorUrlTemplate, getUrl, handleJosmLinkClick, idEditorUrl, josmImportUrl, josmLoadObjectUrl, josmRemoteBase, josmUrl, linksIn, longOsmType, mapillaryRecentPanosUrl, mapillaryUrl, osmChangesetUrl, osmDeepHistoryBase, osmDeepHistoryUrl, osmDevUrl, osmEditIdUrl, osmEditKyleKiwiIdUrl, osmEditRapidUrl, osmObjectHistoryUrl, osmOrgUrl, osmProdApiUrl, osmProdUrl, osmchaBase, osmchaChangesetUrl, osmchaFiltersUrl, serializeTildaFeaturesParam, shortOsmType, tildaGeoBase, tildaInfraSourceNumericId, tildaInspectorUrl, tildaInspectorUrlForInfra, tildaSourceIdFromNumeric, tildaSourceNumericId, toLongOsmType, toShortOsmType, userLinks };

package/dist/josm.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Click handler for a JOSM remote-control link (`http://127.0.0.1:8111/...`).
+ *
+ * JOSM answers the request itself, so the browser should not navigate away: the link is fetched
+ * instead, and the default action is cancelled. JOSM sends CORS headers, so the fetch works from
+ * any page. The promise rejects when JOSM is not running, as the request fails.
+ */
+export declare function handleJosmLinkClick(e: Event): Promise<void>;

package/dist/link-lists.d.ts

@@ -0,0 +1,47 @@
+import { type OsmObjectType } from './osm-type';
+/** One link of a list. `id` is stable: apps use it for their own translated label. */
+export type OsmLink = {
+    /** Stable id, e.g. `osm-history`. */
+    id: string;
+    /** English default label. */
+    label: string;
+    url: string;
+    /** ISO 3166 codes (lower case) where this link is offered, e.g. `['de']`; absent = everywhere. */
+    countries?: readonly string[];
+    /** JOSM remote control: open with `handleJosmLinkClick` instead of a new tab. */
+    josm?: true;
+};
+export type ElementLinksOptions = {
+    type: OsmObjectType;
+    id: number | string;
+    /** Place for the imagery and TILDA links. Without it those links are left out. */
+    loc?: {
+        lat: number;
+        lng: number;
+    };
+    /** Map zoom for the place links. Default 17. */
+    zoom?: number;
+    /** OSM website the app edits on. Default `osmProdUrl`. */
+    server?: string;
+};
+export type ChangesetLinksOptions = {
+    id: number | string;
+    /** OSM website the app edits on. Default `osmProdUrl`. */
+    server?: string;
+};
+export type UserLinksOptions = {
+    name: string;
+    /** OSM website the app edits on. Default `osmProdUrl`. */
+    server?: string;
+};
+/** Links for one OSM element: history, object page, editors, viewers and imagery. */
+export declare function elementLinks({ type, id, loc, zoom, server }: ElementLinksOptions): OsmLink[];
+/** Links for one changeset. */
+export declare function changesetLinks({ id, server }: ChangesetLinksOptions): OsmLink[];
+/** Links for one OSM user, by display name. */
+export declare function userLinks({ name, server }: UserLinksOptions): OsmLink[];
+/**
+ * Links offered at a place: those without `countries`, and those whose `countries` contain one of
+ * the codes. Codes are compared case-insensitively.
+ */
+export declare function linksIn(links: readonly OsmLink[], countryCodes: readonly string[]): OsmLink[];

package/dist/map-download-url.d.ts

@@ -0,0 +1,2 @@
+import type { MapBounds } from '@osm-editor-kit/osm-data';
+export declare function getUrl(bounds: MapBounds, useDevServer: boolean): string;

package/dist/mapillary.d.ts

@@ -0,0 +1,19 @@
+import type { LatLngLiteral } from '@osm-editor-kit/osm-data';
+export type MapillaryUrlOptions = {
+    /** UTC calendar date (`YYYY-MM-DD`) for Mapillary's `dateFrom` filter. */
+    dateFrom?: string;
+    /** UTC calendar date (`YYYY-MM-DD`) for Mapillary's `dateTo` filter. */
+    dateTo?: string;
+    /** When true, adds `panos=true` (360° imagery only). */
+    panosOnly?: boolean;
+    /** Map zoom; defaults to 17. */
+    zoom?: number;
+    /** When set, adds `trafficSign=` (default `all` when omitted from options entirely uses `all`). */
+    trafficSign?: 'all' | false;
+};
+export declare function mapillaryUrl(center: LatLngLiteral, options?: MapillaryUrlOptions): string;
+/** Panorama imagery from the last few years — useful for kerbside parking signs. */
+export declare function mapillaryRecentPanosUrl(center: LatLngLiteral, options?: {
+    years?: number;
+    referenceDate?: Date;
+}): string;

package/dist/osm-object.d.ts

@@ -0,0 +1,11 @@
+import type { OsmObjectType } from './osm-type';
+export type OsmTypeId = {
+    osmType: OsmObjectType | null | undefined;
+    osmId: number | string | null | undefined;
+};
+/** `https://www.openstreetmap.org/{type}/{id}` (or the same path on `server`). */
+export declare function osmOrgUrl({ osmType, osmId }: OsmTypeId, server?: string): string | undefined;
+/** OSM website object history page (`…/{type}/{id}/history`, or on `server`). */
+export declare function osmObjectHistoryUrl({ osmType, osmId }: OsmTypeId, server?: string): string | undefined;
+/** `https://www.openstreetmap.org/changeset/{id}` (or the same path on `server`). */
+export declare function osmChangesetUrl(changesetId: number | string, server?: string): string;

package/dist/osm-type.d.ts

@@ -0,0 +1,6 @@
+export type OsmObjectType = 'way' | 'node' | 'relation';
+export type OsmShortType = 'w' | 'n' | 'r';
+export declare const longOsmType: Record<string, OsmObjectType>;
+export declare const shortOsmType: Record<string, OsmShortType>;
+export declare function toLongOsmType(type: string): OsmObjectType | undefined;
+export declare function toShortOsmType(type: string): OsmShortType | undefined;

package/dist/osmcha.d.ts

@@ -0,0 +1,26 @@
+/** Single OSMCha changeset page. */
+export declare function osmchaChangesetUrl(changesetId: number | string): string;
+export type OsmchaFilterValue = {
+    label: string;
+    value: string;
+};
+/**
+ * OSMCha frontend filter keys (subset). Each value is an array of `{label,value}`
+ * as required by https://github.com/OSMCha/osmcha-frontend deep links.
+ */
+export type OsmchaFiltersInput = {
+    in_bbox?: string | OsmchaFilterValue[];
+    date__gte?: string | OsmchaFilterValue[];
+    date__lte?: string | OsmchaFilterValue[];
+    users?: string | OsmchaFilterValue[];
+    uids?: string | OsmchaFilterValue[];
+    ids?: string | OsmchaFilterValue[];
+    tag_changes?: string | OsmchaFilterValue[];
+    all_tag_changes?: string | OsmchaFilterValue[];
+    comment?: string | OsmchaFilterValue[];
+    metadata?: string | OsmchaFilterValue[];
+    area_lt?: string | OsmchaFilterValue[];
+    [key: string]: string | OsmchaFilterValue[] | undefined;
+};
+/** Build `https://osmcha.org/?filters=<JSON>` deep link. */
+export declare function osmchaFiltersUrl(filters: OsmchaFiltersInput): string;

package/dist/tilda/features-param.d.ts

@@ -0,0 +1,20 @@
+export type TildaFeatureCoord = {
+    kind: 'point';
+    lon: number;
+    lat: number;
+} | {
+    kind: 'bbox';
+    minLon: number;
+    minLat: number;
+    maxLon: number;
+    maxLat: number;
+};
+export type TildaFeatureParam = {
+    /** TILDA source name (e.g. `atlas_bikelanes`) or numeric id. */
+    sourceId: string | number;
+    /** Feature id: `way/123` or numeric Lars id. */
+    featureId: string | number;
+    coords: TildaFeatureCoord;
+};
+/** Build TILDA `f` query value from one or more features. */
+export declare function serializeTildaFeaturesParam(features: TildaFeatureParam | TildaFeatureParam[]): string | undefined;

package/dist/tilda/index.d.ts

@@ -0,0 +1,3 @@
+export { serializeTildaFeaturesParam, type TildaFeatureCoord, type TildaFeatureParam, } from './features-param';
+export { TILDA_INFRA_PRESETS, tildaInfraSourceNumericId, tildaInspectorUrl, tildaInspectorUrlForInfra, type TildaInfra, type TildaInfraPreset, type TildaInspectorForInfraOptions, type TildaInspectorUrlOptions, type TildaMapPosition, } from './inspector';
+export { TILDA_SOURCE_NUMERIC_IDS, tildaSourceIdFromNumeric, tildaSourceNumericId } from './sources';

package/dist/tilda/inspector.d.ts

@@ -0,0 +1,44 @@
+import { type TildaFeatureCoord, type TildaFeatureParam } from './features-param';
+export type TildaInfra = 'bikelanes' | 'parking';
+export type TildaInfraPreset = {
+    regionSlug: string;
+    sourceId: string;
+    /** Layer visibility config; drifts in TILDA — override per call if needed. */
+    defaultConfig: string;
+};
+/**
+ * Infra → public TILDA region presets.
+ * Roads (width/surface/lanes) have no public region — omit those callers.
+ */
+export declare const TILDA_INFRA_PRESETS: Record<TildaInfra, TildaInfraPreset>;
+export type TildaMapPosition = {
+    zoom: number;
+    lat: number;
+    lng: number;
+};
+export type TildaInspectorUrlOptions = {
+    regionSlug: string;
+    map: TildaMapPosition;
+    config?: string;
+    features?: TildaFeatureParam | TildaFeatureParam[];
+    version?: number;
+    baseUrl?: string;
+};
+/** Full TILDA region inspector deeplink (`map` + optional `config` + `f` + `v`). */
+export declare function tildaInspectorUrl(options: TildaInspectorUrlOptions): string;
+export type TildaInspectorForInfraOptions = {
+    map: TildaMapPosition;
+    /** Required for feature-level `f`; omit for viewport-only links. */
+    featureId?: string | number;
+    coords?: TildaFeatureCoord;
+    config?: string;
+    version?: number;
+    baseUrl?: string;
+};
+/**
+ * Build inspector URL for a known infra preset.
+ * Returns viewport-only URL when `featureId`/`coords` are omitted.
+ * Returns `null` only when map position is incomplete (should not happen with typed input).
+ */
+export declare function tildaInspectorUrlForInfra(infra: TildaInfra, options: TildaInspectorForInfraOptions): string;
+export declare function tildaInfraSourceNumericId(infra: TildaInfra): number | undefined;

package/dist/tilda/sources.d.ts

@@ -0,0 +1,8 @@
+/**
+ * TILDA `f` parameter sourceNumericId ↔ source name.
+ * Mirrors tilda-geo `useFeaturesParam/url.ts` (atlas / Lars / Mapillary / TILDA parking).
+ */
+export declare const TILDA_SOURCE_NUMERIC_IDS: Record<number, string>;
+/** Resolve TILDA source name → compact numeric id used in `f=`. */
+export declare function tildaSourceNumericId(sourceId: string): number | undefined;
+export declare function tildaSourceIdFromNumeric(numericId: number): string | undefined;

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "@osm-editor-kit/osm-editor-links",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-alpha.1",
+  "description": "OpenStreetMap link lists for elements, changesets and users (editors, history, viewers, imagery), with JOSM remote-control helpers.",
+  "homepage": "https://github.com/osmberlin/street-space-editor/tree/main/packages/osm-editor-links",
+  "license": "MIT",
+  "author": "Tobias Jordans",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/osmberlin/street-space-editor.git",
+    "directory": "packages/osm-editor-links"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "alpha"
+  },
+  "scripts": {
+    "build": "tsup && rm -f .tsbuildinfo && tsc -p tsconfig.build.json",
+    "type-check": "tsc --noEmit",
+    "test-run": "bun test src/test",
+    "prepublishOnly": "bun run build && bun ../../scripts/package-exports-for-publish.ts",
+    "postpublish": "bun ../../scripts/package-exports-restore.ts",
+    "prepack": "bun ../../scripts/package-exports-for-publish.ts",
+    "postpack": "bun ../../scripts/package-exports-restore.ts"
+  },
+  "dependencies": {
+    "@osm-editor-kit/osm-data": "^0.1.0-alpha.1"
+  },
+  "devDependencies": {
+    "bun-types": "^1.2.20",
+    "typescript": "^7.0.0"
+  },
+  "publishExports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  }
+}