structured-context-map-views 0.0.0-stage → 0.1.0

package/dist/styles.css

@@ -0,0 +1,497 @@
+/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */
+@layer properties;
+@layer theme {
+  :root, :host {
+    --mv-spacing: 0.25rem;
+    --mv-text-xs: 0.75rem;
+    --mv-text-xs--line-height: calc(1 / 0.75);
+    --mv-text-sm: 0.875rem;
+    --mv-text-sm--line-height: calc(1.25 / 0.875);
+    --mv-font-weight-semibold: 600;
+    --mv-tracking-wide: 0.025em;
+    --mv-leading-tight: 1.25;
+    --mv-leading-snug: 1.375;
+    --mv-radius-md: 0.375rem;
+    --mv-radius-lg: 0.5rem;
+    --mv-color-surface: #f8f8f7;
+    --mv-color-card: #ffffff;
+    --mv-color-ink: #1f2328;
+    --mv-color-muted: #59636e;
+    --mv-color-edge: #d1d9e0;
+    --mv-color-accent: #0969da;
+  }
+}
+.mv\:pointer-events-none {
+  pointer-events: none;
+}
+.mv\:absolute {
+  position: absolute;
+}
+.mv\:relative {
+  position: relative;
+}
+.mv\:inset-0 {
+  inset: 0px;
+}
+.mv\:inset-8 {
+  inset: calc(var(--mv-spacing) * 8);
+}
+.mv\:float-left {
+  float: left;
+}
+.mv\:m-0 {
+  margin: 0px;
+}
+.mv\:mt-1 {
+  margin-top: var(--mv-spacing);
+}
+.mv\:mr-1\.5 {
+  margin-right: calc(var(--mv-spacing) * 1.5);
+}
+.mv\:box-border {
+  box-sizing: border-box;
+}
+.mv\:block {
+  display: block;
+}
+.mv\:flex {
+  display: flex;
+}
+.mv\:grid {
+  display: grid;
+}
+.mv\:size-6 {
+  width: calc(var(--mv-spacing) * 6);
+  height: calc(var(--mv-spacing) * 6);
+}
+.mv\:h-full {
+  height: 100%;
+}
+.mv\:min-h-0 {
+  min-height: 0px;
+}
+.mv\:min-h-\[28rem\] {
+  min-height: 28rem;
+}
+.mv\:w-44 {
+  width: calc(var(--mv-spacing) * 44);
+}
+.mv\:w-full {
+  width: 100%;
+}
+.mv\:w-max {
+  width: max-content;
+}
+.mv\:max-w-44 {
+  max-width: calc(var(--mv-spacing) * 44);
+}
+.mv\:max-w-\[36rem\] {
+  max-width: 36rem;
+}
+.mv\:min-w-\[36rem\] {
+  min-width: 36rem;
+}
+.mv\:min-w-full {
+  min-width: 100%;
+}
+.mv\:flex-1 {
+  flex: 1;
+}
+.mv\:shrink-0 {
+  flex-shrink: 0;
+}
+.mv\:-translate-x-1\/2 {
+  --tw-translate-x: calc(calc(1 / 2 * 100%) * -1);
+  translate: var(--tw-translate-x) var(--tw-translate-y);
+}
+.mv\:-translate-x-3 {
+  --tw-translate-x: calc(var(--mv-spacing) * -3);
+  translate: var(--tw-translate-x) var(--tw-translate-y);
+}
+.mv\:translate-y-1\/2 {
+  --tw-translate-y: calc(1 / 2 * 100%);
+  translate: var(--tw-translate-x) var(--tw-translate-y);
+}
+.mv\:translate-y-3 {
+  --tw-translate-y: calc(var(--mv-spacing) * 3);
+  translate: var(--tw-translate-x) var(--tw-translate-y);
+}
+.mv\:rotate-180 {
+  rotate: 180deg;
+}
+.mv\:cursor-pointer {
+  cursor: pointer;
+}
+.mv\:list-none {
+  list-style-type: none;
+}
+.mv\:grid-cols-\[auto_1fr\] {
+  grid-template-columns: auto 1fr;
+}
+.mv\:grid-rows-\[1fr_auto\] {
+  grid-template-rows: 1fr auto;
+}
+.mv\:flex-col {
+  flex-direction: column;
+}
+.mv\:flex-col-reverse {
+  flex-direction: column-reverse;
+}
+.mv\:flex-row {
+  flex-direction: row;
+}
+.mv\:flex-wrap {
+  flex-wrap: wrap;
+}
+.mv\:items-center {
+  align-items: center;
+}
+.mv\:items-start {
+  align-items: flex-start;
+}
+.mv\:items-stretch {
+  align-items: stretch;
+}
+.mv\:justify-between {
+  justify-content: space-between;
+}
+.mv\:justify-center {
+  justify-content: center;
+}
+.mv\:gap-0\.5 {
+  gap: calc(var(--mv-spacing) * 0.5);
+}
+.mv\:gap-1 {
+  gap: var(--mv-spacing);
+}
+.mv\:gap-1\.5 {
+  gap: calc(var(--mv-spacing) * 1.5);
+}
+.mv\:gap-2 {
+  gap: calc(var(--mv-spacing) * 2);
+}
+.mv\:gap-3 {
+  gap: calc(var(--mv-spacing) * 3);
+}
+.mv\:gap-4 {
+  gap: calc(var(--mv-spacing) * 4);
+}
+.mv\:gap-x-4 {
+  column-gap: calc(var(--mv-spacing) * 4);
+}
+.mv\:gap-y-2 {
+  row-gap: calc(var(--mv-spacing) * 2);
+}
+.mv\:truncate {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.mv\:overflow-auto {
+  overflow: auto;
+}
+.mv\:overflow-visible {
+  overflow: visible;
+}
+.mv\:rounded {
+  border-radius: 0.25rem;
+}
+.mv\:rounded-full {
+  border-radius: calc(infinity * 1px);
+}
+.mv\:rounded-lg {
+  border-radius: var(--mv-radius-lg);
+}
+.mv\:rounded-md {
+  border-radius: var(--mv-radius-md);
+}
+.mv\:border {
+  border-style: var(--tw-border-style);
+  border-width: 1px;
+}
+.mv\:border-0 {
+  border-style: var(--tw-border-style);
+  border-width: 0px;
+}
+.mv\:border-2 {
+  border-style: var(--tw-border-style);
+  border-width: 2px;
+}
+.mv\:border-b {
+  border-bottom-style: var(--tw-border-style);
+  border-bottom-width: 1px;
+}
+.mv\:border-l {
+  border-left-style: var(--tw-border-style);
+  border-left-width: 1px;
+}
+.mv\:border-dashed {
+  --tw-border-style: dashed;
+  border-style: dashed;
+}
+.mv\:border-edge {
+  border-color: var(--mv-color-edge);
+}
+.mv\:border-muted\/60 {
+  border-color: var(--mv-color-muted);
+  @supports (color: color-mix(in lab, red, red)) {
+    border-color: color-mix(in oklab, var(--mv-color-muted) 60%, transparent);
+  }
+}
+.mv\:bg-card {
+  background-color: var(--mv-color-card);
+}
+.mv\:bg-surface {
+  background-color: var(--mv-color-surface);
+}
+.mv\:bg-surface\/80 {
+  background-color: var(--mv-color-surface);
+  @supports (color: color-mix(in lab, red, red)) {
+    background-color: color-mix(in oklab, var(--mv-color-surface) 80%, transparent);
+  }
+}
+.mv\:fill-none {
+  fill: none;
+}
+.mv\:stroke-accent\/60 {
+  stroke: var(--mv-color-accent);
+  @supports (color: color-mix(in lab, red, red)) {
+    stroke: color-mix(in oklab, var(--mv-color-accent) 60%, transparent);
+  }
+}
+.mv\:stroke-muted\/50 {
+  stroke: var(--mv-color-muted);
+  @supports (color: color-mix(in lab, red, red)) {
+    stroke: color-mix(in oklab, var(--mv-color-muted) 50%, transparent);
+  }
+}
+.mv\:p-0 {
+  padding: 0px;
+}
+.mv\:p-2 {
+  padding: calc(var(--mv-spacing) * 2);
+}
+.mv\:p-4 {
+  padding: calc(var(--mv-spacing) * 4);
+}
+.mv\:px-0\.5 {
+  padding-inline: calc(var(--mv-spacing) * 0.5);
+}
+.mv\:px-1 {
+  padding-inline: var(--mv-spacing);
+}
+.mv\:px-2\.5 {
+  padding-inline: calc(var(--mv-spacing) * 2.5);
+}
+.mv\:px-8 {
+  padding-inline: calc(var(--mv-spacing) * 8);
+}
+.mv\:py-1\.5 {
+  padding-block: calc(var(--mv-spacing) * 1.5);
+}
+.mv\:py-8 {
+  padding-block: calc(var(--mv-spacing) * 8);
+}
+.mv\:pt-10 {
+  padding-top: calc(var(--mv-spacing) * 10);
+}
+.mv\:pl-14 {
+  padding-left: calc(var(--mv-spacing) * 14);
+}
+.mv\:text-left {
+  text-align: left;
+}
+.mv\:text-sm {
+  font-size: var(--mv-text-sm);
+  line-height: var(--tw-leading, var(--mv-text-sm--line-height));
+}
+.mv\:text-xs {
+  font-size: var(--mv-text-xs);
+  line-height: var(--tw-leading, var(--mv-text-xs--line-height));
+}
+.mv\:text-\[0\.65rem\] {
+  font-size: 0.65rem;
+}
+.mv\:leading-snug {
+  --tw-leading: var(--mv-leading-snug);
+  line-height: var(--mv-leading-snug);
+}
+.mv\:leading-tight {
+  --tw-leading: var(--mv-leading-tight);
+  line-height: var(--mv-leading-tight);
+}
+.mv\:font-semibold {
+  --tw-font-weight: var(--mv-font-weight-semibold);
+  font-weight: var(--mv-font-weight-semibold);
+}
+.mv\:tracking-wide {
+  --tw-tracking: var(--mv-tracking-wide);
+  letter-spacing: var(--mv-tracking-wide);
+}
+.mv\:whitespace-nowrap {
+  white-space: nowrap;
+}
+.mv\:text-ink {
+  color: var(--mv-color-ink);
+}
+.mv\:text-muted {
+  color: var(--mv-color-muted);
+}
+.mv\:uppercase {
+  text-transform: uppercase;
+}
+.mv\:opacity-75 {
+  opacity: 75%;
+}
+.mv\:shadow-sm {
+  --tw-shadow: 0 1px 3px 0 var(--tw-shadow-color, rgb(0 0 0 / 0.1)), 0 1px 2px -1px var(--tw-shadow-color, rgb(0 0 0 / 0.1));
+  box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
+}
+.mv\:\[writing-mode\:vertical-rl\] {
+  writing-mode: vertical-rl;
+}
+@media (hover: hover) {
+  .mv\:hover\:border-accent:hover {
+    border-color: var(--mv-color-accent);
+  }
+  .mv\:hover\:text-accent:hover {
+    color: var(--mv-color-accent);
+  }
+}
+.mv\:focus-visible\:outline-2:focus-visible {
+  outline-style: var(--tw-outline-style);
+  outline-width: 2px;
+}
+.mv\:focus-visible\:outline-accent:focus-visible {
+  outline-color: var(--mv-color-accent);
+}
+@property --tw-translate-x {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-translate-y {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-translate-z {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0;
+}
+@property --tw-border-style {
+  syntax: "*";
+  inherits: false;
+  initial-value: solid;
+}
+@property --tw-leading {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-font-weight {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-tracking {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-inset-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-inset-shadow-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-inset-shadow-alpha {
+  syntax: "<percentage>";
+  inherits: false;
+  initial-value: 100%;
+}
+@property --tw-ring-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ring-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-inset-ring-color {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-inset-ring-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-ring-inset {
+  syntax: "*";
+  inherits: false;
+}
+@property --tw-ring-offset-width {
+  syntax: "<length>";
+  inherits: false;
+  initial-value: 0px;
+}
+@property --tw-ring-offset-color {
+  syntax: "*";
+  inherits: false;
+  initial-value: #fff;
+}
+@property --tw-ring-offset-shadow {
+  syntax: "*";
+  inherits: false;
+  initial-value: 0 0 #0000;
+}
+@property --tw-outline-style {
+  syntax: "*";
+  inherits: false;
+  initial-value: solid;
+}
+@layer properties {
+  @supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))) {
+    *, ::before, ::after, ::backdrop {
+      --tw-translate-x: 0;
+      --tw-translate-y: 0;
+      --tw-translate-z: 0;
+      --tw-border-style: solid;
+      --tw-leading: initial;
+      --tw-font-weight: initial;
+      --tw-tracking: initial;
+      --tw-shadow: 0 0 #0000;
+      --tw-shadow-color: initial;
+      --tw-shadow-alpha: 100%;
+      --tw-inset-shadow: 0 0 #0000;
+      --tw-inset-shadow-color: initial;
+      --tw-inset-shadow-alpha: 100%;
+      --tw-ring-color: initial;
+      --tw-ring-shadow: 0 0 #0000;
+      --tw-inset-ring-color: initial;
+      --tw-inset-ring-shadow: 0 0 #0000;
+      --tw-ring-inset: initial;
+      --tw-ring-offset-width: 0px;
+      --tw-ring-offset-color: #fff;
+      --tw-ring-offset-shadow: 0 0 #0000;
+      --tw-outline-style: solid;
+    }
+  }
+}

package/dist/types/core/definition.d.ts

@@ -0,0 +1,112 @@
+import type { FromSchema } from 'json-schema-to-ts';
+import { definitionSchema, type landscapeLayoutSchema, MAP_VIEW_SCHEMAS, type settingsSchema, type treeLayoutSchema, type xyLayoutSchema } from './schemas';
+export { MAP_VIEW_SCHEMAS };
+type References = {
+    references: [
+        typeof settingsSchema,
+        typeof treeLayoutSchema,
+        typeof landscapeLayoutSchema,
+        typeof xyLayoutSchema,
+        typeof definitionSchema
+    ];
+    parseIfThenElseKeywords: true;
+};
+type ParamRef = {
+    $param: string;
+};
+/** Drop `{ $param }` bindings from every setting's type: what remains after resolution. */
+type Resolved<T> = T extends ParamRef ? never : T extends readonly (infer U)[] ? Resolved<U>[] : T extends object ? {
+    [K in keyof T]: Resolved<T[K]>;
+} : T;
+/** A definition as authored: settings may be `{ $param }` bindings, defaulted properties may be absent. */
+export type AuthoredDefinition = FromSchema<typeof definitionSchema, References & {
+    keepDefaultedPropertiesOptional: true;
+}>;
+type FilledDefinition = FromSchema<typeof definitionSchema, References>;
+/** A region with parameters applied and defaults filled in: what layouts receive. */
+export type Region = Resolved<FilledDefinition['regions'][number]>;
+export type LayoutConfig = Region['layout'];
+export type TreeLayoutConfig = Extract<LayoutConfig, {
+    type: 'tree';
+}>;
+export type LandscapeLayoutConfig = Extract<LayoutConfig, {
+    type: 'landscape';
+}>;
+export type XYLayoutConfig = Extract<LayoutConfig, {
+    type: 'xy';
+}>;
+export type AxisConfig = XYLayoutConfig['x'];
+export type GroupLevel = LandscapeLayoutConfig['group'][number];
+export type IntermediateDisplay = Extract<GroupLevel, {
+    type: string;
+}>['intermediate'];
+export type NodesConfig = Region['nodes'];
+export type EdgesConfig = Region['edges'];
+export type Orientation = TreeLayoutConfig['orientation'];
+export type DagMode = TreeLayoutConfig['dag'];
+export type NodeStyle = NodesConfig['style'];
+/**
+ * A validated map view definition. Plain data, so hosts can pass it across a server/browser
+ * boundary. Settings in `source` may still be `{ $param }` bindings; {@link resolveRegions}
+ * replaces them with parameter values.
+ */
+export type MapViewDefinition = {
+    /** The definition's `$id`. */
+    id: string;
+    title: string;
+    description?: string;
+    /** `$id` of the schema whose spaces this map view applies to. */
+    schema: string;
+    parameters: Parameter[];
+    /** The definition as authored. */
+    source: AuthoredDefinition;
+};
+/** A setting the reader can change, with the control generated from its schema. */
+export type Parameter = {
+    name: string;
+    title: string;
+    description?: string;
+    default: unknown;
+    control: ParameterControl;
+};
+/** Options are JSON primitives, so they can be labelled and compared directly. */
+export type ParameterControl = {
+    kind: 'select';
+    options: readonly Primitive[];
+} | {
+    kind: 'multiselect';
+    options: readonly Primitive[];
+} | {
+    kind: 'toggle';
+};
+type Primitive = string | number | boolean | null;
+export type ParameterValues = Readonly<Record<string, unknown>>;
+export declare class MapViewDefinitionError extends Error {
+    constructor(name: string, message: string);
+}
+/**
+ * Parse a JSON5 map view definition and check it against the bundled schemas. `name` labels
+ * error messages (hosts pass where the definition came from).
+ *
+ * Beyond schema validation: every parameter needs a control derivable from its schema, and
+ * every value that control can produce must satisfy the parameter's schema; every `$param`
+ * must name a declared parameter; and each parameter's values must be valid wherever it's
+ * bound, checked by substituting them and re-validating.
+ */
+export declare function parseMapViewDefinition(name: string, text: string): MapViewDefinition;
+/**
+ * The value each parameter takes: the given value if its control could produce it, otherwise
+ * (missing, or stale saved state) the default. Hosts' controls and rendering both use this.
+ */
+export declare function resolveParameterValues(definition: MapViewDefinition, values?: ParameterValues): ParameterValues;
+/** Apply parameter values to a definition's regions and fill in setting defaults. */
+export declare function resolveRegions(definition: MapViewDefinition, values?: ParameterValues): Region[];
+/**
+ * The filter selecting the nodes a map view shows, if any. Hosts apply it when loading the space.
+ * PROTOTYPE: filters are evaluated by the host, not per region in the browser, because
+ * structured-context's filter evaluator can't yet be bundled for a browser (its only entry point,
+ * `structured-context/api`, imports Node built-ins). That's fine while only the first region renders.
+ */
+export declare function selectionFilter(definition: MapViewDefinition, values?: ParameterValues): string | undefined;
+/** Map view definitions that apply to a space with the given schema. */
+export declare function mapViewsForSchema(definitions: readonly MapViewDefinition[], schemaId: string | undefined): MapViewDefinition[];

package/dist/types/core/graph.d.ts

@@ -0,0 +1,16 @@
+import type { Hierarchy, SpaceGraph, SpaceNode } from 'structured-context/api';
+type NodeId = SpaceNode['id'];
+/** A directed parent → child edge of a space graph, carrying the metadata of the reference it came from. */
+export type Edge = SpaceGraph['parentEdges'] extends ReadonlyMap<string, readonly (infer E)[]> ? E : never;
+/**
+ * Edges to a node's parents, in the order the node declares them. A graph narrowed by a filter keeps
+ * edges to parents outside it; those are left out.
+ */
+export declare function parentEdges(graph: SpaceGraph, id: NodeId): readonly Edge[];
+/** Edges to a node's children, in graph order of the children. */
+export declare function childEdges(graph: SpaceGraph, id: NodeId): readonly Edge[];
+/** Every edge whose parent and child are both in the graph. */
+export declare function edgesWithin(graph: SpaceGraph): Edge[];
+/** Whether an edge belongs to the given hierarchy (as opposed to a relationship or another hierarchy). */
+export declare function isHierarchyEdge(edge: Edge, hierarchy: Hierarchy | undefined): boolean;
+export {};

package/dist/types/core/index.d.ts

@@ -0,0 +1,6 @@
+export { type AuthoredDefinition, type AxisConfig, type DagMode, type EdgesConfig, type GroupLevel, type IntermediateDisplay, type LandscapeLayoutConfig, type LayoutConfig, MAP_VIEW_SCHEMAS, type MapViewDefinition, MapViewDefinitionError, mapViewsForSchema, type NodeStyle, type NodesConfig, type Orientation, type Parameter, type ParameterControl, type ParameterValues, parseMapViewDefinition, type Region, resolveParameterValues, resolveRegions, selectionFilter, type TreeLayoutConfig, type XYLayoutConfig, } from './definition';
+export { type Edge, isHierarchyEdge } from './graph';
+export { buildLandscape, type Landscape, type LandscapeOccurrence, type ViaStep } from './landscape';
+export { occurrenceKey, type PathSegment } from './occurrence';
+export { buildTree, type Tree, type TreeLink, type TreeOccurrence, treeLinks } from './tree';
+export { buildXYPlot, type Unplaced, type XYLink, type XYPlot, type XYPoint } from './xy';

package/dist/types/core/landscape.d.ts

@@ -0,0 +1,44 @@
+import type { SpaceGraph, SpaceNode } from 'structured-context/api';
+import type { LandscapeLayoutConfig } from './definition';
+/** One rendered container or node in a landscape. */
+export type LandscapeOccurrence = {
+    /** Path-based key, unique within the map view (see {@link occurrenceKey}). */
+    key: string;
+    /** Index of the grouping level this occurrence belongs to. */
+    level: number;
+    /** A node, or a field value shared by the nodes inside (`null`: the field is empty). */
+    item: {
+        kind: 'node';
+        node: SpaceNode;
+    } | {
+        kind: 'value';
+        field: string;
+        value: string | null;
+    };
+    /** Nodes on the `via` chain that joined this node to the node level above, one entry per skipped type. */
+    via: ViaStep[];
+    /** Key of the node's first occurrence when this is a repeat. Repeats are rendered in full. */
+    repeatOf?: string;
+    children: LandscapeOccurrence[];
+};
+export type ViaStep = {
+    type: string;
+    nodes: SpaceNode[];
+};
+export type Landscape = {
+    groups: LandscapeOccurrence[];
+    /**
+     * Nodes of a grouped level that no container above reaches (e.g. an Activity with no
+     * Outcome when grouping by Outcomes), each with its own contents.
+     */
+    ungrouped: LandscapeOccurrence[];
+};
+/**
+ * Lay a space out as nested containers following the layout's grouping levels.
+ *
+ * Adjacent node levels are joined by any edge between their types, in either direction, or only
+ * edges from `edge.field`. A `via` chain joins them through the skipped types. A field level
+ * splits the next node level by that field's values. A node reached from several containers
+ * appears in each, in full: the levels are finite, so repeating contents can't recurse.
+ */
+export declare function buildLandscape(graph: SpaceGraph, regionId: string, layout: LandscapeLayoutConfig): Landscape;

package/dist/types/core/occurrence.d.ts

@@ -0,0 +1,11 @@
+/**
+ * One step of an occurrence path: a node title, a `[field, value]` group, or `null` for the
+ * ungrouped area. Encoded distinctly, so a field group can't collide with a node of the same name.
+ */
+export type PathSegment = string | readonly [field: string, value: string | null] | null;
+/**
+ * Path-based key for one occurrence of a node: region, then the steps from the outermost
+ * container down to the node. Unique within a map view even when a node appears several times.
+ * Hosts can render several map views at once, so layouts scope keys to the map view instance.
+ */
+export declare function occurrenceKey(regionId: string, path: readonly PathSegment[]): string;