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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Roger Barnes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,20 @@
-# Temporary Holding Version
+# structured-context-map-views
 
-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.
+Declarative map views of [structured-context](https://github.com/mindsocket/structured-context) spaces: a short JSON5 definition projects a space into a tree, nested containers or an XY plot, rendered by React components.
+
+```bash
+npm install structured-context-map-views react react-dom structured-context
+```
+
+```tsx
+import { MapView, ParameterControls } from 'structured-context-map-views';
+import 'structured-context-map-views/styles.css';
+
+<MapView definition={definition} graph={graph} values={values} onNodeSelect={(node) => open(node)} />
+```
+
+`structured-context-map-views/node` finds definitions on disk (`loadMapViewDefinitions`). React 19 and `structured-context` are peer dependencies. Pre-1.0: exports may change between minor versions.
+
+See the [documentation](https://github.com/mindsocket/structured-context-map-views#readme): [concepts](https://github.com/mindsocket/structured-context-map-views/blob/main/docs/concepts.md), [writing definitions](https://github.com/mindsocket/structured-context-map-views/blob/main/docs/definitions.md) and [the API](https://github.com/mindsocket/structured-context-map-views/blob/main/docs/api.md).
+
+Licence: MIT.

package/dist/definition-KuPoA1mO.js

@@ -0,0 +1,582 @@
+import Ajv2020 from "ajv/dist/2020";
+import JSON5 from "json5";
+/** Base of the `$id`s the sources use: the `latest` folder. */
+var SCHEMA_URL = `https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest`;
+//#endregion
+//#region src/core/schemas/param-ref.ts
+/** `$ref` target for a setting whose value comes from a declared parameter. */
+var PARAM_REF = `${SCHEMA_URL}/definition.json#/$defs/paramRef`;
+/** A setting that takes either a fixed value matching `valueSchema` or a `{ $param }` binding. */
+function parameterisable(valueSchema, defaultValue, description) {
+	return {
+		description,
+		default: defaultValue,
+		anyOf: [valueSchema, { $ref: PARAM_REF }]
+	};
+}
+//#endregion
+//#region src/core/schemas/definition.ts
+/**
+* The map view definition format: shared parameters, and the regions a map view is composed of.
+*
+* Written as TypeScript so the definition types derive from it (`FromSchema`); the JSON files
+* for `$schema` references and editors are generated (`bun run generate:schemas`).
+*/
+var definitionSchema = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: `${SCHEMA_URL}/definition.json`,
+	title: "Map view definition",
+	description: "Declares how spaces of one schema are projected into a map view: shared parameters, and the regions the map view is composed of.",
+	type: "object",
+	required: [
+		"$id",
+		"schema",
+		"regions"
+	],
+	additionalProperties: false,
+	properties: {
+		$schema: { type: "string" },
+		$id: {
+			type: "string",
+			pattern: "^sctx-map-view://[^/]+(/[^/]+)?$",
+			description: "Identifier, namespaced by where the definition is found: \"sctx-map-view://core/<name>\" (bundled), \"sctx-map-view://<plugin>/<name>\" (a plugin) or \"sctx-map-view://<name>\" (the config folder)."
+		},
+		title: {
+			type: "string",
+			minLength: 1,
+			description: "Display name. Defaults to the last segment of the `$id`."
+		},
+		description: { type: "string" },
+		schema: {
+			type: "string",
+			minLength: 1,
+			description: "`$id` of the structured-context schema whose spaces this map view applies to."
+		},
+		parameters: {
+			type: "object",
+			description: "Settings the reader can change. Each is a JSON Schema with a default, bound to settings anywhere in the definition with { \"$param\": \"<name>\" }.",
+			additionalProperties: { $ref: "#/$defs/parameter" }
+		},
+		regions: {
+			type: "array",
+			minItems: 1,
+			description: "Parts of the map view, each with its own layout, nodes and edges. Only the first region is rendered for now.",
+			items: { $ref: "#/$defs/region" }
+		}
+	},
+	$defs: {
+		parameter: {
+			type: "object",
+			description: "A JSON Schema for the parameter's values (it can $ref, narrow or extend the bundled setting definitions), plus a title for its control.",
+			required: ["default"],
+			properties: {
+				title: { type: "string" },
+				description: { type: "string" },
+				default: {}
+			}
+		},
+		paramRef: {
+			type: "object",
+			description: "Takes this setting's value from a declared parameter.",
+			required: ["$param"],
+			additionalProperties: false,
+			properties: { $param: {
+				type: "string",
+				minLength: 1
+			} }
+		},
+		region: {
+			type: "object",
+			required: ["id", "layout"],
+			additionalProperties: false,
+			properties: {
+				id: {
+					type: "string",
+					minLength: 1,
+					description: "Unique within the map view; part of every occurrence id in the region."
+				},
+				select: {
+					type: "object",
+					description: "Which nodes of the space the region shows. By default, all of them.",
+					additionalProperties: false,
+					properties: { filter: {
+						type: "string",
+						minLength: 1,
+						description: "A structured-context filter: a view name from the space's config, or an expression such as `WHERE …` or `SELECT … WHERE …`."
+					} }
+				},
+				layout: {
+					description: "How the region is arranged, chosen by `type`.",
+					type: "object",
+					required: ["type"],
+					discriminator: { propertyName: "type" },
+					oneOf: [
+						{ $ref: `${SCHEMA_URL}/layouts/tree.json` },
+						{ $ref: `${SCHEMA_URL}/layouts/landscape.json` },
+						{ $ref: `${SCHEMA_URL}/layouts/xy.json` }
+					]
+				},
+				nodes: {
+					type: "object",
+					additionalProperties: false,
+					default: {},
+					properties: {
+						style: parameterisable({ $ref: `${SCHEMA_URL}/settings.json#/$defs/nodeStyle` }, "card", "How nodes are drawn."),
+						fields: parameterisable({ $ref: `${SCHEMA_URL}/settings.json#/$defs/fieldList` }, [], "Schema fields shown on cards.")
+					}
+				},
+				edges: {
+					type: "object",
+					additionalProperties: false,
+					default: {},
+					properties: { show: parameterisable({ type: "boolean" }, true, "Whether connectors are drawn.") }
+				}
+			}
+		}
+	}
+};
+//#endregion
+//#region src/core/schemas/landscape-layout.ts
+/** Settings of the landscape layout: nested containers following an authored grouping. */
+var landscapeLayoutSchema = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: `${SCHEMA_URL}/layouts/landscape.json`,
+	title: "Landscape layout",
+	description: "Nested containers: each grouping level becomes containers inside the level above, and the last level is drawn as nodes.",
+	type: "object",
+	required: ["type", "group"],
+	additionalProperties: false,
+	properties: {
+		type: { const: "landscape" },
+		orientation: parameterisable({ $ref: `${SCHEMA_URL}/settings.json#/$defs/orientation` }, "horizontal", "horizontal: top-level containers side by side, as columns. vertical: stacked, as rows."),
+		group: {
+			type: "array",
+			minItems: 1,
+			description: "Grouping levels, outermost first. The last level is drawn as nodes; the others as containers. Adjacent node levels are joined by any edge between their types, in either direction.",
+			items: {
+				type: "object",
+				if: {
+					type: "object",
+					required: ["field"]
+				},
+				then: {
+					type: "object",
+					description: "Containers labelled by the values of a field of the next node level's nodes. A node with several values appears under each.",
+					required: ["field"],
+					additionalProperties: false,
+					properties: { field: {
+						type: "string",
+						minLength: 1
+					} }
+				},
+				else: {
+					type: "object",
+					description: "A level of nodes of one type.",
+					required: ["type"],
+					additionalProperties: false,
+					properties: {
+						type: {
+							description: "Node type at this level.",
+							anyOf: [{
+								type: "string",
+								minLength: 1
+							}, { $ref: PARAM_REF }]
+						},
+						edge: {
+							type: "object",
+							description: "Which edges join this level to the node level above (or to the last `via` type). By default, any edge between the two types.",
+							required: ["field"],
+							additionalProperties: false,
+							properties: { field: {
+								type: "string",
+								minLength: 1
+							} }
+						},
+						via: {
+							type: "array",
+							minItems: 1,
+							description: "Types skipped between the node level above and this one, in order. Nodes are joined through a chain of edges across them. Ignored on the first level, which has no level above.",
+							items: {
+								type: "string",
+								minLength: 1
+							}
+						},
+						intermediate: parameterisable({ $ref: `${SCHEMA_URL}/layouts/landscape.json#/$defs/intermediate` }, "hidden", "How the skipped nodes of a `via` chain are shown.")
+					}
+				}
+			}
+		}
+	},
+	$defs: { intermediate: {
+		title: "Skipped levels",
+		description: "hidden: not shown. breadcrumb: listed on each node reached through them.",
+		enum: ["hidden", "breadcrumb"]
+	} }
+};
+//#endregion
+//#region src/core/schemas/index.ts
+/** The bundled schemas describing the map view definition format. */
+var MAP_VIEW_SCHEMAS = [
+	definitionSchema,
+	{
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		$id: `${SCHEMA_URL}/settings.json`,
+		title: "Shared map view settings",
+		description: "Reusable setting definitions. Parameters can $ref these and narrow them, e.g. with allOf and enum.",
+		$defs: {
+			orientation: {
+				title: "Orientation",
+				enum: ["vertical", "horizontal"]
+			},
+			nodeStyle: {
+				title: "Node style",
+				description: "card: a box with the title and selected fields. shape: a compact marker with a tooltip.",
+				enum: ["card", "shape"]
+			},
+			fieldList: {
+				title: "Fields",
+				type: "array",
+				items: {
+					type: "string",
+					minLength: 1
+				},
+				uniqueItems: true
+			}
+		}
+	},
+	{
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		$id: `${SCHEMA_URL}/layouts/tree.json`,
+		title: "Tree layout",
+		description: "A tree over the schema's hierarchy: root-type nodes at the top, children via hierarchy edges.",
+		type: "object",
+		required: ["type"],
+		additionalProperties: false,
+		properties: {
+			type: { const: "tree" },
+			orientation: parameterisable({ $ref: `${SCHEMA_URL}/settings.json#/$defs/orientation` }, "vertical", "Direction the tree grows."),
+			dag: parameterisable({ $ref: `${SCHEMA_URL}/layouts/tree.json#/$defs/dag` }, "repeat", "How a node with several parents is shown.")
+		},
+		$defs: { dag: {
+			title: "Nodes with several parents",
+			description: "repeat: the node appears under each parent, its subtree shown once. cross-edge: the node appears under its first parent, with extra connectors from the others.",
+			enum: ["repeat", "cross-edge"]
+		} }
+	},
+	landscapeLayoutSchema,
+	{
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		$id: `${SCHEMA_URL}/layouts/xy.json`,
+		title: "XY layout",
+		description: "Nodes positioned on two axes by numeric fields. Nodes of the plotted types without a usable value on both axes are listed beside the plot, not dropped.",
+		type: "object",
+		required: [
+			"type",
+			"x",
+			"y"
+		],
+		additionalProperties: false,
+		properties: {
+			type: { const: "xy" },
+			x: { $ref: `${SCHEMA_URL}/layouts/xy.json#/$defs/axis` },
+			y: { $ref: `${SCHEMA_URL}/layouts/xy.json#/$defs/axis` },
+			types: parameterisable({
+				type: "array",
+				items: {
+					type: "string",
+					minLength: 1
+				},
+				uniqueItems: true
+			}, [], "Node types to plot. Empty: every type with a value on either axis."),
+			edgeFields: parameterisable({ $ref: `${SCHEMA_URL}/settings.json#/$defs/fieldList` }, [], "Fields whose edges are drawn between plotted nodes. Empty: all edges.")
+		},
+		$defs: {
+			axis: {
+				title: "Axis",
+				type: "object",
+				required: ["field"],
+				additionalProperties: false,
+				properties: {
+					field: {
+						description: "Numeric field giving the position.",
+						anyOf: [{
+							type: "string",
+							minLength: 1
+						}, { $ref: PARAM_REF }]
+					},
+					domain: {
+						description: "Values at the two ends of the axis: [min, max], or \"data\" for the smallest and largest plotted values. Nodes outside a fixed domain are listed as unplaced.",
+						default: "data",
+						anyOf: [{ const: "data" }, {
+							type: "array",
+							items: { type: "number" },
+							minItems: 2,
+							maxItems: 2
+						}]
+					},
+					direction: parameterisable({ $ref: `${SCHEMA_URL}/layouts/xy.json#/$defs/direction` }, "ascending", "ascending: values grow rightwards (x) or upwards (y). descending: the reverse."),
+					label: {
+						type: "string",
+						description: "Axis title. Defaults to the field name."
+					}
+				}
+			},
+			direction: {
+				title: "Axis direction",
+				enum: ["ascending", "descending"]
+			}
+		}
+	}
+];
+//#endregion
+//#region src/core/definition.ts
+var MapViewDefinitionError = class extends Error {
+	constructor(name, message) {
+		super(`Map view "${name}": ${message}`);
+		this.name = "MapViewDefinitionError";
+	}
+};
+var newAjv = (options = {}) => new Ajv2020({
+	allErrors: true,
+	discriminator: true,
+	...options,
+	schemas: MAP_VIEW_SCHEMAS.map((s) => structuredClone(s))
+});
+/** Validates definitions as authored. */
+var ajv = newAjv();
+var validateDefinition = ajv.getSchema(definitionSchema.$id);
+/** Validates resolved definitions, filling in setting defaults from the schemas. */
+var fillDefaults = newAjv({ useDefaults: true }).getSchema(definitionSchema.$id);
+/**
+* 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.
+*/
+function parseMapViewDefinition(name, text) {
+	const fail = (message) => {
+		throw new MapViewDefinitionError(name, message);
+	};
+	let raw;
+	try {
+		raw = JSON5.parse(text);
+	} catch (err) {
+		return fail(`invalid JSON5: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	if (!validateDefinition(raw)) return fail(formatErrors(validateDefinition.errors, raw));
+	const source = raw;
+	const parameterAjv = newAjv();
+	const declared = source.parameters ?? {};
+	const parameters = Object.entries(declared).map(([paramName, schema]) => parseParameter(paramName, schema, parameterAjv, (message) => fail(`parameter "${paramName}": ${message}`)));
+	for (const bound of paramNames(source.regions)) if (!(bound in declared)) fail(`"$param": "${bound}" is not a declared parameter`);
+	checkBindings(source, parameters, fail);
+	const regionIds = /* @__PURE__ */ new Set();
+	for (const region of source.regions) {
+		if (regionIds.has(region.id)) fail(`duplicate region id "${region.id}"`);
+		regionIds.add(region.id);
+		if (region.layout.type === "landscape" && !("type" in region.layout.group.at(-1))) fail(`region "${region.id}": the last grouping level must be a node type, not a field`);
+		if (region.layout.type === "xy") for (const axis of ["x", "y"]) {
+			const { domain } = region.layout[axis];
+			if (Array.isArray(domain) && !(domain[0] < domain[1])) fail(`region "${region.id}": ${axis} domain must be [min, max] with min < max`);
+		}
+	}
+	return {
+		id: source.$id,
+		title: source.title ?? source.$id.slice(source.$id.lastIndexOf("/") + 1),
+		...source.description !== void 0 && { description: source.description },
+		schema: source.schema,
+		parameters,
+		source
+	};
+}
+/**
+* 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.
+*/
+function resolveParameterValues(definition, values = {}) {
+	return Object.fromEntries(definition.parameters.map((param) => {
+		const value = values[param.name];
+		const chosen = value !== void 0 && isProducible(param.control, value) ? value : param.default;
+		return [param.name, structuredClone(chosen)];
+	}));
+}
+/** Apply parameter values to a definition's regions and fill in setting defaults. */
+function resolveRegions(definition, values = {}) {
+	const resolved = resolveParameterValues(definition, values);
+	const filled = substitute(definition.source, (paramName) => resolved[paramName]);
+	if (!fillDefaults(filled)) throw new MapViewDefinitionError(definition.id, `resolved definition is invalid: ${formatErrors(fillDefaults.errors, filled)}`);
+	return filled.regions;
+}
+/**
+* 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.
+*/
+function selectionFilter(definition, values = {}) {
+	return resolveRegions(definition, values)[0]?.select?.filter;
+}
+/** Map view definitions that apply to a space with the given schema. */
+function mapViewsForSchema(definitions, schemaId) {
+	return schemaId === void 0 ? [] : definitions.filter((d) => d.schema === schemaId);
+}
+/** Resolve `$ref`s relative to the format schemas, so parameters can write `settings.json#/$defs/orientation`. */
+function absoluteRefs(node) {
+	if (Array.isArray(node)) return node.map(absoluteRefs);
+	if (typeof node !== "object" || node === null) return node;
+	return Object.fromEntries(Object.entries(node).map(([key, value]) => [key, key === "$ref" && typeof value === "string" ? new URL(value, `${SCHEMA_URL}/`).href : absoluteRefs(value)]));
+}
+function parseParameter(name, schema, parameterAjv, fail) {
+	const { title, description, default: defaultValue, ...authored } = schema;
+	const valueSchema = absoluteRefs(authored);
+	let validate;
+	try {
+		validate = parameterAjv.compile(valueSchema);
+	} catch (err) {
+		return fail(`invalid schema: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	if (!validate(defaultValue)) return fail(`default ${JSON.stringify(defaultValue)} doesn't match its schema`);
+	const control = controlFor(valueSchema, fail);
+	const invalid = producibleValues(control).filter((value) => !validate(value));
+	if (invalid.length > 0) fail(`its ${control.kind} control can produce ${invalid.map((v) => JSON.stringify(v)).join(", ")}, which its schema rejects; remove constraints the control can't enforce`);
+	return {
+		name,
+		title: typeof title === "string" ? title : titleFromRef(valueSchema) ?? name,
+		...typeof description === "string" && { description },
+		default: defaultValue,
+		control
+	};
+}
+/**
+* Values a control can produce, as checked against schemas. For a multi-select that's none,
+* each option alone, and all of them. PROTOTYPE: other subsets are assumed valid if these are,
+* which holds for the constraints in use (enum items, uniqueItems) but not, say, `contains`.
+*/
+function producibleValues(control) {
+	switch (control.kind) {
+		case "toggle": return [true, false];
+		case "select": return [...control.options];
+		case "multiselect": return [
+			[],
+			...control.options.map((option) => [option]),
+			[...control.options]
+		];
+	}
+}
+/**
+* Every `$param` binding must accept each value the parameter's control can produce.
+* PROTOTYPE: parameters are checked one at a time, with the others at their defaults, which
+* assumes their bindings don't constrain each other.
+*/
+function checkBindings(source, parameters, fail) {
+	const defaults = new Map(parameters.map((p) => [p.name, p.default]));
+	for (const param of parameters) for (const candidate of producibleValues(param.control)) {
+		const substituted = substitute(source, (n) => n === param.name ? candidate : defaults.get(n));
+		if (!validateDefinition(substituted)) fail(`parameter "${param.name}" value ${JSON.stringify(candidate)} isn't valid where it's used: ${formatErrors(validateDefinition.errors, substituted)}`);
+	}
+}
+/**
+* Derive a control from a parameter's value schema: `enum` (directly, via `$ref`, or narrowed
+* with `allOf`) gives a select, an array of such items a multi-select, `boolean` a toggle.
+*/
+function controlFor(schema, fail) {
+	if (typeOf(schema) === "boolean") return { kind: "toggle" };
+	const isArray = typeOf(schema) === "array";
+	const options = isArray ? intersect(itemSchemas(schema).map(enumOf)) : enumOf(schema);
+	if (!options) return fail("no control can be generated: give it enum options (directly, or via $ref/allOf), array items with enum options, or type boolean");
+	if (options.length === 0) return fail("its options narrow to nothing");
+	if (!options.every(isPrimitive)) return fail("options must be strings, numbers, booleans or null");
+	return {
+		kind: isArray ? "multiselect" : "select",
+		options
+	};
+}
+/** Schemas linked from this one through `$ref` and `allOf`. */
+function linked(schema) {
+	const ref = typeof schema.$ref === "string" ? ajv.getSchema(schema.$ref)?.schema : void 0;
+	return [...typeof ref === "object" ? [ref] : [], ...schema.allOf ?? []];
+}
+/** Allowed values, intersecting `enum`/`const` with those reached through `$ref` and `allOf`. */
+function enumOf(schema) {
+	return intersect([
+		Array.isArray(schema.enum) ? schema.enum : void 0,
+		"const" in schema ? [schema.const] : void 0,
+		...linked(schema).map(enumOf)
+	]);
+}
+function typeOf(schema) {
+	if (schema.type !== void 0) return schema.type;
+	return linked(schema).map(typeOf).find((type) => type !== void 0);
+}
+/** Every `items` schema applying to an array, so their constraints can be intersected. */
+function itemSchemas(schema) {
+	return [...typeof schema.items === "object" ? [schema.items] : [], ...linked(schema).flatMap(itemSchemas)];
+}
+function intersect(sets) {
+	const defined = sets.filter((set) => set !== void 0);
+	if (defined.length === 0) return void 0;
+	const key = (v) => JSON.stringify(v);
+	return defined.reduce((acc, set) => acc.filter((v) => set.some((w) => key(w) === key(v))));
+}
+function titleFromRef(schema) {
+	const title = linked(schema)[0]?.title;
+	return typeof title === "string" ? title : void 0;
+}
+function isPrimitive(value) {
+	return value === null || [
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof value);
+}
+function isProducible(control, value) {
+	switch (control.kind) {
+		case "toggle": return typeof value === "boolean";
+		case "select": return control.options.includes(value);
+		case "multiselect": return Array.isArray(value) && value.every((v) => control.options.includes(v));
+	}
+}
+function isParamRef(value) {
+	return typeof value === "object" && value !== null && typeof value.$param === "string";
+}
+/** Copy a JSON value, replacing each `{ $param }` binding with its value. */
+function substitute(value, valueFor) {
+	if (isParamRef(value)) return structuredClone(valueFor(value.$param));
+	if (Array.isArray(value)) return value.map((v) => substitute(v, valueFor));
+	if (typeof value === "object" && value !== null) return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, substitute(v, valueFor)]));
+	return value;
+}
+function paramNames(value) {
+	if (isParamRef(value)) return [value.$param];
+	if (Array.isArray(value)) return value.flatMap(paramNames);
+	if (typeof value === "object" && value !== null) return Object.values(value).flatMap(paramNames);
+	return [];
+}
+/**
+* Readable Ajv errors. A setting accepts a value or a `{ $param }` binding (`anyOf`), so a bad
+* value also fails the binding branch; those errors, and the bare anyOf summary, are dropped
+* unless the value actually is a binding. An `if` failure only repeats its branch's errors.
+*/
+function formatErrors(errors, instance) {
+	return (errors ?? []).filter((e) => e.keyword !== "anyOf" && e.keyword !== "if" && !(e.schemaPath.includes("/$defs/paramRef") && !isParamRef(at(instance, e.instancePath)))).map((e) => `${e.instancePath || "/"} ${message(e)}${detail(e)}`).join("; ");
+}
+/** The value at a JSON pointer. */
+function at(value, pointer) {
+	return pointer.split("/").slice(1).map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~")).reduce((node, key) => typeof node === "object" && node !== null ? node[key] : void 0, value);
+}
+function message(error) {
+	if (error.keyword === "discriminator" && error.params.error === "mapping") return `has unknown ${error.params.tag} ${JSON.stringify(error.params.tagValue)}`;
+	return error.message;
+}
+function detail(error) {
+	if (error.keyword === "additionalProperties") return ` ("${error.params.additionalProperty}")`;
+	if (error.keyword === "enum") return ` (${error.params.allowedValues.map((v) => JSON.stringify(v)).join(", ")})`;
+	return "";
+}
+//#endregion
+export { resolveRegions as a, resolveParameterValues as i, mapViewsForSchema as n, selectionFilter as o, parseMapViewDefinition as r, MAP_VIEW_SCHEMAS as s, MapViewDefinitionError as t };
+
+//# sourceMappingURL=definition-KuPoA1mO.js.map