About MaplatCore

MaplatCore is the core library of the Maplat Historical Map / Illustrated Map Viewer. It transforms each map's coordinates with a nonlinear but homeomorphic projection, so maps can collaborate with GPS and accurate maps without distorting the original map image. The end-user viewer built on top of it is Maplat; the data authoring tool is MaplatEditor.

MaplatCore is open-source under the Apache License 2.0 (from version 0.13.2).

Read this document in Japanese / 日本語で読む

Key Features

• Historical map / illustrated map viewer API with nonlinear but homeomorphic coordinate transformation
• GPS / accurate map collaboration without distorting the original map image
• Pluggable base maps (OpenLayers-based; optional Mapbox GL JS / MapLibre GL JS for vector tiles)
• Event-driven POI / line / layer management
• Open-source (Apache 2.0 from version 0.13.2) — part of the Maplat ecosystem

Quick Start

Current release: 1.0.0. This block is the only place in this repository that carries a release version (ADR-0012); everything outside it is written against the 1.0 release. npm: @maplat/core

Install

# pnpm (recommended)
pnpm add @maplat/core

# npm
npm install @maplat/core

Minimal usage

import { MaplatApp } from '@maplat/core';
import 'ol/ol.css'; // REQUIRED: OpenLayers CSS

const option = {
  startFrom: 'gsi',
};

MaplatApp.createObject(option).then((app) => {
  console.log('Maplat initialized', app);
});

CDN (jsDelivr)

For usage directly in the browser without a bundler, you must load OpenLayers before loading MaplatCore.

<!-- OpenLayers -->
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/ol@10/ol.css">
<script src="https://cdn.jsdelivr.net/npm/ol@10/dist/ol.js"></script>

<!-- MaplatCore -->
<script src="https://cdn.jsdelivr.net/npm/@maplat/[email protected]/dist/maplat_core.umd.js"></script>

<div id="map_div"></div>
<script>
  var option = {
    startFrom: 'gsi',
    div: 'map_div',
  };
  MaplatApp.createObject(option).then(function (app) {
    console.log('Maplat initialized', app);
  });
</script>

Note: Make sure to use the latest compatible versions.

POI specification (setting.pois)

The pois field of a map/app setting accepts several historical forms. All existing forms continue to work unchanged (backward compatible). A new layer ref (wrapper) form is added to let the app override per-layer presentation (hide / title / icon / selectedIcon) without editing the layer's FeatureCollection.

| Form | Shape | Behaviour | |---|---|---| | URL string | "pois/x.geojson" | fetched and normalised (legacy) | | Inline FC | { type: "FeatureCollection", ... } | normalised in place (legacy) | | FC array | [FC, FC, ...] | each FC becomes a layer keyed by id (legacy) | | POI object array | [{lng, lat, name}, ...] | single main layer (legacy) | | Old layer dict | { "<key>": <cluster>, ... } | each value normalised (legacy) | | Layer ref (wrapper) — array element | { layer: <URL\|FC>, hide?, title?, icon?, selectedIcon? } | layer is resolved/fetched, the FC is normalised, then the overrides are merged onto the resulting cluster | | Layer ref — whole pois | { layer: <URL\|FC>, hide?, title?, icon?, selectedIcon? } with at least one override key | same merge, keyed by the FC id. Without an override key the object is treated as the old layer dict form (key "layer") for backward compatibility |

Override semantics:

• Only the four override keys are honoured. Unknown keys are dropped with a console.warn (no throw, forward-compatible).
• hide: true (boolean true only) sets cluster.hide = true. hide:false / non-boolean values are ignored (the data-side value is kept).
• title (non-empty string, or a non-empty localized object) maps to cluster.name.
• icon / selectedIcon (non-empty string only) map to cluster.icon / cluster.selectedIcon.
• Override wins over FeatureCollection.properties of the same name.
• Internal cluster keys (pois / id / namespaceID / __nextId) cannot be overwritten from a wrapper (they are not override keys).
• The input object is not mutated.

See src/normalize_pois.ts (isPoiLayerRef, PoiLayerRef) for the programmatic surface.

Attribution and licensing (attr / dataAttr)

Map metadata carries attribution and licensing as two independent pairs: one for the map image itself, and one for the data (control points, POIs, and other derived data). Keeping them apart matters because a scanned map sheet and the georeferencing data built on top of it usually come from different rights holders.

| Field | Type | Meaning | |---|---|---| | attr | string or { <lang>: string } | Map image attribution — who the map image is credited to | | dataAttr | string or { <lang>: string } | Data attribution — who the data is credited to | | license | string | Map image license | | dataLicense | string | Data license | | licenseNote | string or { <lang>: string } | Free-form supplement to license | | dataLicenseNote | string or { <lang>: string } | Free-form supplement to dataLicense |

attr / dataAttr accept a localized object so that a credit line can differ per viewer language; license / dataLicense are plain strings. They are not enumerations — the library stores and renders whatever string it is given. In practice two conventional values are used:

• "ODbL" — ODbL (Open Database License)
• "Custom" — Custom license, with the actual terms written into licenseNote / dataLicenseNote

The bundled base maps in src/source_ex.ts show both conventions: OpenStreetMap is declared as attr: "©︎ OpenStreetMap contributors" with license: "Custom" and dataLicense: "ODbL", while the GSI base map uses "Custom" for both and spells the terms out in licenseNote.

Choosing these values in a UI is the authoring tool's concern (MaplatEditor); MaplatCore only defines what the fields mean and renders the resulting credit.

Lifecycle

• See docs/ui-core-lifecycle.md for lifecycle phases and uiHooks (this document lives in the Maplat viewer repository; the lifecycle is shared with @maplat/ui).

API reference

• API signatures (release-dependent): see docs/api/
• Conceptual guide (release-independent): see the Wiki API-Reference

Development

Setup

Clone the repository and install dependencies.

git clone https://github.com/code4history/MaplatCore.git
cd MaplatCore
pnpm install

Development Server

Start the development server with hot reload.

pnpm dev

Build

pnpm build        # Build npm package (dist/)
pnpm build:demo   # Build demo application (dist-demo/)

Test

pnpm test         # Run unit tests (Vitest)
pnpm typecheck    # Run type checks (TypeScript)
pnpm lint         # Run linter and formatter (ESLint/Prettier)
pnpm run test:e2e # Run E2E tests (Playwright)

Prerequisites

Node.js follows the GitHub Actions test.yml matrix; pnpm follows the engines field in package.json (ADR-0012: release-dependent).

• Node.js: v22 or v24 (tested via GitHub Actions)
• pnpm: >=9.0.0 (required; package.json enforces pnpm)

Peer Dependencies

MaplatCore depends on the following libraries as peer dependencies. You must install them manually.

• OpenLayers (ol) — ^9.0.0 || ^10.0.0 (required; peer dependency of MaplatCore and Maplat @maplat/ui)

pnpm add ol

If you use Vector Tiles, you may also need Mapbox GL JS or MapLibre GL JS:

• mapbox-gl: ^2.0.0 || ^3.0.0 (optional)
• maplibre-gl: ^5.0.0 || ^6.0.0 (optional)

Ecosystem

MaplatCore is part of the Maplat ecosystem by Code for History. See the full ecosystem map (8 repositories + product/corporate sites):

📖 Ecosystem Map — (the diagram is currently kept in a private planning repository; the Sister repositories table below is the public substitute)

Sister repositories

| Repository | License | npm | Role | |---|---|---|---| | Maplat | Apache 2.0 | @maplat/ui | Main viewer | | MaplatCore | Apache 2.0 | @maplat/core | Core library | | MaplatTin | Apache 2.0 | @maplat/tin | TIN conversion | | MaplatTransform | Apache 2.0 | @maplat/transform | Coordinate transform | | MaplatEditor | Apache 2.0 | — | Data authoring tool (desktop) | | Chuci | MIT | @c4h/chuci | Multimedia swiper & viewer Web Components | | Quyuan | MIT | @c4h/quyuan | GeoJSON template engine + multimedia viewer Web Components | | Weiwudi | MIT | @c4h/weiwudi | Service Worker for tile cache |

MaplatEditor is the data authoring tool used to create the maps and POIs that the viewers above render. The Maplat ecosystem is end-to-end: author with MaplatEditor, serve with any of the viewer libraries.

Links

| Audience | Link | Purpose | |---|---|---| | Project info / features / cases | https://www.maplat.jp/en/ | Product site | | Sponsor / business inquiry | https://www.nayuta-inc.co.jp/en/ | Corporate site (Nayuta, Inc.) |

ADR-0013: Apache-licensed repositories (this one) link to both sites. MIT-licensed sister repos (Weiwudi / Quyuan / Chuci) carry no Nayuta link.

License

Apache License 2.0 — see LICENSE.

Copyright 2019-2026 Kohei Otsuka, Code for History / Nayuta, Inc.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

Patent notice: The Maplat coordinate-transform technology is patented in Japan (Patent No. 6684776).

Past versions: Versions before 0.13.2 were distributed under the Maplat Limited License 1.1. The license restoration to Apache 2.0 takes effect from version 1.0.0-rc1 onward. Earlier versions available on npmjs.com remain under their original limited-license terms.