@ghentcdh/annotation-api 0.0.1-alpha.10 → 0.0.1-alpha.14

package/index.js

@@ -1,172 +1,265 @@
-import { Controller as e, Get as t, Inject as n, Injectable as r, Module as i, NotFoundException as a, Param as o } from "@nestjs/common";
-import { z as s } from "zod";
-import { contextBuilder as c, w3cAnnotation as l } from "@ghentcdh/w3c-utils";
-import { Debugger as u, PlainTextAdapter as ee, W3CAnnotationAdapter as d, WordSnapper as te, createAnnotatedText as ne, createHighlightStyle as f } from "@ghentcdh/annotated-text";
-import { ControlBuilder as p, LayoutBuilder as m } from "@ghentcdh/crouton-forms-vue";
-import { existsSync as h, readFileSync as g, readdirSync as _ } from "node:fs";
-import { join as v } from "node:path";
-import { ApiTags as re } from "@nestjs/swagger";
-//#region packages/annotation-core/src/lib/types/source.model.ts
-var ie = ["text"], y = s.object({
-	text: s.string(),
-	textDirection: s.enum(["ltr", "rtl"]).default("ltr"),
-	processingLanguage: s.string().default("en"),
-	label: s.string().optional(),
-	offset: s.number().optional().default(0)
-}), ae = s.object({
-	id: s.string(),
-	uri: s.string(),
-	type: s.enum(ie),
-	content: y
-}), oe = (e) => {
-	let t = e.areas.map((e) => `"${e.join(" ")}"`).join(" "), n = e.areas[0]?.length ?? 1, r = {
-		gridTemplateAreas: t,
-		gridTemplateColumns: e.columns ?? Array(n).fill("minmax(0, 1fr)").join(" ")
+import { Body, Controller, Delete, Get, Inject, Injectable, Module, Param, Patch, Post } from "@nestjs/common";
+import { z } from "zod";
+import { ContextBuilder, contextBuilder, w3cAnnotation } from "@ghentcdh/w3c-utils";
+import { JsonOperationsSchema, ResourceJsonShape, ViewConfigSchema, labelFromId, registerResourceExtensions } from "@ghentcdh/crouton-core";
+import { Debugger, PlainTextAdapter, W3CAnnotationAdapter, WordSnapper, createAnnotatedText, createHighlightStyle } from "@ghentcdh/annotated-text";
+import { CroutonApiModule, ResourceConfigRegistry } from "@ghentcdh/crouton-api";
+import { ApiBody, ApiOperation, ApiParam, ApiResponse, ApiTags } from "@nestjs/swagger";
+//#region src/lib/annotation/annotation.repository.ts
+var AnnotationCrudRepository = class {};
+//#endregion
+//#region ../annotation-core/src/lib/types/key-label.type.ts
+var KeyLabelSchema = z.object();
+//#endregion
+//#region ../annotation-core/src/lib/types/source.model.ts
+var SourceTypesList = ["text"];
+var SourceTextSchema = z.object({
+	text: z.string(),
+	textDirection: z.enum(["ltr", "rtl"]).default("ltr"),
+	processingLanguage: z.string().default("en"),
+	label: z.string().optional(),
+	offset: z.number().optional().default(0)
+});
+var SourceModelSchema = z.object({
+	id: z.string(),
+	uri: z.string(),
+	type: z.enum(SourceTypesList),
+	content: SourceTextSchema
+});
+//#endregion
+//#region ../annotation-core/src/lib/types/grid-layout.types.ts
+/** Computed CSS styles for the grid container */
+var buildGridStyle = (layout) => {
+	const templateAreas = layout.areas.map((row) => `"${row.join(" ")}"`).join(" ");
+	const colCount = layout.areas[0]?.length ?? 1;
+	const style = {
+		gridTemplateAreas: templateAreas,
+		gridTemplateColumns: layout.columns ?? Array(colCount).fill("minmax(0, 1fr)").join(" ")
 	};
-	return e.rows && (r.gridTemplateRows = e.rows), r;
-}, se = (e, t) => e.panes.find((e) => e.sourceId === t)?.area, b = "AnnotationMetadata", x = s.custom(), ce = s.object({
-	id: s.string(),
-	name: s.string(),
-	columns: s.array(x),
-	json_schema: s.any().optional(),
-	json_ld: s.any().optional(),
-	ui_schema: s.any().optional(),
-	metadata_schema: s.any().optional(),
-	color: s.string(),
-	type: s.string().optional(),
-	icon: s.string().optional(),
-	isRoot: s.boolean().default(!0),
-	allowedChildren: s.array(s.string()).default([]),
-	allowedLinks: s.array(s.string()).default([]),
-	context: s.custom(),
-	target: s.enum([
-		"gutter",
-		"underline",
-		"highlight"
-	]).default("highlight")
-}), S = {
-	baseUrl: "http://localhost:3000/",
+	if (layout.rows) style["gridTemplateRows"] = layout.rows;
+	return style;
+};
+/** Returns the grid-area CSS value for a given source id, or undefined if not configured */
+var getPaneArea = (layout, sourceId) => {
+	return layout.panes.find((p) => p.sourceId === sourceId)?.area;
+};
+//#endregion
+//#region ../annotation-core/src/lib/utils/annotation.context-builder.ts
+var defaultConfig = {
+	baseUrl: "http://localhost:3333/",
+	crudController: "annotation/annotation",
 	app: "ghentcdh",
 	prefix: "ghentcdh",
-	isDev: !1,
+	isDev: false,
 	cacheTTLms: 1200 * 1e3
-}, C = (e = {}) => {
-	let t = e.baseUrl ?? S.baseUrl, n = t.endsWith("/") ? t : `${t}/`, r = e.isDev ?? !1, i = r ? 0 : 1200 * 1e3;
+};
+var resolveConfig = (config = {}) => {
+	const baseUrl = config.baseUrl ?? defaultConfig.baseUrl;
+	const normalizedBaseUrl = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+	const isDev = config.isDev ?? false;
+	const cacheTTLms = isDev ? 0 : 1200 * 1e3;
 	return {
-		baseUrl: n,
-		contextUrl: `${n}ns/`,
-		app: e.app ?? S.app,
-		prefix: e.prefix ?? S.prefix,
-		isDev: r,
-		cacheTTLms: i
+		baseUrl: normalizedBaseUrl,
+		contextUrl: `${normalizedBaseUrl}ns/`,
+		app: config.app ?? defaultConfig.app,
+		prefix: config.prefix ?? defaultConfig.prefix,
+		crudController: config.crudController ?? defaultConfig.crudController,
+		isDev,
+		cacheTTLms
 	};
-}, w = (e, t) => {
-	let { prefix: n, baseUrl: r, contextUrl: i } = C(t), a = b;
-	return c(n, r).setType(n, a).addPrefix(e, `${n}:${e}`).setContextUri(`${i}${e}.jsonld`);
-}, le = "annotation.style", ue = s.object({
-	id: s.string(),
-	name: s.string(),
-	target: s.enum([
+};
+var baseContextBuilder = (id, config) => {
+	const { prefix, baseUrl, contextUrl } = resolveConfig(config);
+	const metaData = AnnotationMetadataType;
+	return contextBuilder(prefix, baseUrl).setType(prefix, metaData).addPrefix(id, `${prefix}:${id}`).setContextUri(`${contextUrl}${id}.jsonld`);
+};
+//#endregion
+//#region ../annotation-core/src/lib/types/annotation.contex.ts
+var AnnotationMetadataType = "AnnotationMetadata";
+var createAnnotationContext = (annotationDefConfig, resource) => {
+	const formView = resource.views?.["form"];
+	const builder = baseContextBuilder(resource.id, annotationDefConfig);
+	if (formView) builder.parseJsonSchema(formView.json_schema);
+	return {
+		id: resource.id,
+		styling: {
+			name: resource.name,
+			id: resource.id,
+			target: resource.annotation.target,
+			color: resource.annotation.color
+		},
+		hasContext: !!formView,
+		prefix: buildPrefix(annotationDefConfig, resource),
+		uri: builder.uri,
+		jsonLd: builder.toJsonLdContext(),
+		safeParse: builder.safeParse.bind(builder),
+		toAnnotationBody: builder.toAnnotationBody.bind(builder)
+	};
+};
+var buildPrefix = (annotationDefConfig, resource) => {
+	return `${annotationDefConfig.prefix}:${resource.annotation.type}/`;
+};
+//#endregion
+//#region ../annotation-core/src/lib/types/version.ts
+/**
+* resource.json schema versioning.
+*
+* `schemaVersion` is a monotonic integer stamped on every `resource.json`. It is
+* **decoupled from the crouton package semver** on purpose — bump it only when the
+* resource.json *shape* changes in a way that needs a migration, and ship a matching
+* step in `./migrations`. This keeps the migration chain one-step-per-bump with no
+* version-range math.
+*
+* Files written before versioning existed carry no field and are treated as the
+* baseline. Because `CURRENT_RESOURCE_VERSION` starts equal to the baseline, shipping
+* the versioning machinery is a pure no-op for every existing file until the first
+* real shape change lands (`CURRENT_RESOURCE_VERSION = 2` + a `1 → 2` migration).
+*/
+/** Version assumed for a `resource.json` that has no `schemaVersion` field. */
+var BASELINE_RESOURCE_VERSION = 1;
+/**
+* The version the running crouton understands. Bump by 1 whenever resource.json's
+* shape changes, and add a migration step (`from: N, to: N + 1`) in `./migrations`.
+*/
+var CURRENT_RESOURCE_VERSION = 1;
+//#endregion
+//#region ../annotation-core/src/lib/types/annotation-json-config.types.ts
+var AnnotationTargetEnum = z.enum([
+	"gutter",
+	"underline",
+	"highlight"
+]);
+var AnnotationConfigSchema = z.object({
+	color: z.string().optional(),
+	type: z.string().optional(),
+	icon: z.string().optional(),
+	isRoot: z.boolean().optional().default(true),
+	allowedChildren: z.array(z.string()).optional().default([]),
+	allowedLinks: z.array(z.string()).optional().default([]),
+	target: AnnotationTargetEnum.optional().default("highlight")
+});
+var AnnotationJsonResourceShape = ResourceJsonShape.extend({
+	route: z.string().optional(),
+	tag: z.string().optional(),
+	operations: JsonOperationsSchema.optional().default(JsonOperationsSchema.parse({})),
+	id: z.string(),
+	annotation: AnnotationConfigSchema.optional().default(AnnotationConfigSchema.parse({}))
+}).passthrough();
+var AnnotationJsonResourceSchema = AnnotationJsonResourceShape.transform((obj) => {
+	const title = labelFromId(obj.name);
+	return {
+		schemaVersion: obj.schemaVersion ?? 1,
+		title,
+		...obj
+	};
+});
+//#endregion
+//#region ../annotation-core/src/lib/types/annotation-definition.type.ts
+var annotationColumnDefinition = z.custom();
+var AnnotationResourceSchema = AnnotationJsonResourceShape.pick({
+	id: true,
+	name: true,
+	title: true,
+	operations: true,
+	annotation: true
+}).extend({
+	annotation: AnnotationConfigSchema,
+	context: z.instanceof(ContextBuilder).optional().nullish(),
+	schemas: z.record(z.string(), ViewConfigSchema.partial()).optional().nullish()
+});
+//#endregion
+//#region ../annotation-core/src/lib/annotation.style.ts
+var CONTEXT = "annotation.style";
+var AnnotationStyleSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	target: z.enum([
 		"gutter",
 		"underline",
 		"highlight"
 	]).optional().default("underline"),
-	color: s.string().optional()
-}), T = "AnnotationStyle", E = (e) => {
-	let { prefix: t, baseUrl: n, contextUrl: r } = C(e);
-	return c(t, n).setType(t, T).setContextUri(`${r}${T}.jsonld`).parseZodSchema(ue);
-}, de = (e, t) => {
-	let n = E(e).toAnnotationBodyUnsafe(t);
-	return n.success || (u.debug(le, "AnnotationStyleContextBuilder safe parse failed"), u.warn(n.error)), n;
-}, D = (e) => {
-	let t = p.properties(e.id);
-	if (t.customLabel(e.label), !e.fieldInput) return t;
-	let { type: n, options: r = {} } = e.fieldInput;
-	return n === "autocomplete" ? t.autocomplete({
-		...r.uri && { uri: r.uri },
-		...r.resource && { resource: r.resource },
-		...r.valueKey && { valueKey: r.valueKey },
-		...r.labelKey && { labelKey: r.labelKey },
-		...r.enableCreate !== void 0 && { enableCreate: r.enableCreate },
-		...r.colspan && { colspan: r.colspan }
-	}) : n === "select" ? t.select({
-		...r.values && { values: r.values },
-		...r.clearable !== void 0 && { clearable: r.clearable },
-		...r.storeValue !== void 0 && { storeValue: r.storeValue },
-		...r.emitObject !== void 0 && { emitObject: r.emitObject },
-		...r.colspan && { colspan: r.colspan }
-	}) : t.control(n, { ...r.colspan && { colspan: r.colspan } });
-}, O = (e) => {
-	let t = m.grid();
-	return e.filter((e) => !e.hiddenInForm).forEach((e) => t.addControl(D(e))), t.build();
-}, k = (e) => {
-	let t = m.grid();
-	return e.filter((e) => !e.hiddenInMetadata).forEach((e) => t.addControl(D(e).readonly())), t.build();
-}, A = (e) => {
-	if (e.type === "object" && e.properties) {
-		let t = {};
-		for (let [n, r] of Object.entries(e.properties)) t[n] = A(r);
-		return s.object(t);
-	}
-	return s.string();
-}, j = (e, t, n) => {
-	let r = w(e, n), i = t.columns ?? [];
-	if (!i.length) return r;
-	let a = {};
-	for (let e of i) {
-		let t = A(e.type ?? { type: "string" });
-		a[e.id] = e.required === !1 ? t.optional() : t;
-	}
-	return Object.keys(a).length ? r.parseZodSchema(s.object(a)) : r;
-}, M = (e, t, n = j) => {
-	let r = n(e.id, e, t), i = e.columns ?? [], a = i.length > 0, o = e.ui_schema ?? (a ? O(i) : void 0), s = e.metadata_schema ?? (a ? k(i) : void 0), c = {
-		id: e.id,
-		name: e.name,
-		color: e.color,
-		isRoot: e.isRoot ?? !0,
-		columns: i,
-		context: r,
-		json_ld: r.toJsonLdContext(),
-		json_schema: o ? r.toJsonSchema() : null,
-		allowedChildren: e.allowedChildren ?? [],
-		allowedLinks: e.allowedLinks ?? [],
-		target: e.target ?? "highlight"
-	};
-	return o && (c.ui_schema = o), s && (c.metadata_schema = s), e.type && (c.type = e.type), e.icon && (c.icon = e.icon), c;
-}, fe = (e, t, n) => e.map((e) => M(e, t, n)), pe = (e, t, n) => n.map((r) => {
-	let i = t.get(r.id), a = i.getSpecificResourceTargets(e);
-	if (!a || a.length === 0) return null;
-	let o = i.getSpecificResourceTargets().map((e) => e.source).filter((t) => t !== e).map((e) => n.find((t) => t.id === e)).filter(Boolean);
-	return {
-		purpose: N(i),
-		annotation: r,
-		relations: o
+	color: z.string().optional()
+});
+var AnnotationStyleType = "AnnotationStyle";
+var AnnotationStyleContextBuilder = (annotationConfig) => {
+	const { prefix, baseUrl, contextUrl } = resolveConfig(annotationConfig);
+	return contextBuilder(prefix, baseUrl).setType(prefix, AnnotationStyleType).setContextUri(`${contextUrl}${AnnotationStyleType}.jsonld`).parseZodSchema(AnnotationStyleSchema);
+};
+var createAnnotationStyleBodyUnsafe = (annotationConfig, style) => {
+	const resource = {
+		...style,
+		...style.annotation
 	};
-}).filter(Boolean), N = (e) => P(e)?.id ?? "text", P = (e) => e.getBodiesByPurpose("styling").find((e) => e.type === "AnnotationStyle"), me = (e, t, n) => {
-	let r = t.getSpecificResourceTargets()[0]?.source;
-	if (!r) return null;
-	let i = t.getTextPositionSelector(r)[0];
-	if (!i) return null;
-	let a = P(t)?.id ?? "text";
+	const parsed = AnnotationStyleContextBuilder(annotationConfig).toAnnotationBodyUnsafe(resource);
+	if (!parsed.success) {
+		Debugger.debug(CONTEXT, "AnnotationStyleContextBuilder safe parse failed");
+		Debugger.warn(parsed.error);
+	}
+	return parsed;
+};
+//#endregion
+//#region ../annotation-core/src/lib/utils/annotation-utils.ts
+var mapRelationsToLinks = (sourceUri, builders, annotations) => {
+	return annotations.map((link) => {
+		const builder = builders.get(link.id);
+		const specifyResource = builder.getSpecificResourceTargets(sourceUri);
+		if (!specifyResource || specifyResource.length === 0) return null;
+		const relations = builder.getSpecificResourceTargets().map((s) => s.source).filter((s) => s !== sourceUri).map((uri) => {
+			return annotations.find((a) => a.id === uri);
+		}).filter(Boolean);
+		return {
+			purpose: getAnnotationType(builder),
+			annotation: link,
+			relations
+		};
+	}).filter(Boolean);
+};
+var getAnnotationType = (builder) => {
+	return getAnnotationStyle(builder)?.id ?? "text";
+};
+var getAnnotationStyle = (builder) => {
+	return builder.getBodiesByPurpose("styling").find((b) => b.type === "AnnotationStyle");
+};
+var getAnnotationPosition = (id, builder, allowedChildrenPerType) => {
+	const sourceUri = builder.getSpecificResourceTargets()[0]?.source;
+	if (!sourceUri) return null;
+	const textPositionSelector = builder.getTextPositionSelector(sourceUri)[0];
+	if (!textPositionSelector) return null;
+	const type = getAnnotationStyle(builder)?.id ?? "text";
 	return {
-		id: e,
-		start: i.start,
-		end: i.end,
-		allowedChildren: n[a] ?? [],
-		sourceUri: r ?? "",
-		type: a,
-		minX: i.start,
+		id,
+		start: textPositionSelector.start,
+		end: textPositionSelector.end,
+		allowedChildren: allowedChildrenPerType[type] ?? [],
+		sourceUri: sourceUri ?? "",
+		type,
+		minX: textPositionSelector.start,
 		minY: 0,
-		maxX: i.end,
+		maxX: textPositionSelector.end,
 		maxY: 0
 	};
-}, F = "ROOT", I = () => `mela:new-annotation:${Date.now()}`, L = (e, t) => (e.getSpecificResourceTargets(t.source).length || e.addTarget({
-	type: "SpecificResource",
-	source: t.source
-}), e.updateTextPositionSelector({
-	start: t.start,
-	end: t.end
-}, t.source), e), R = class {
+};
+var rootId = "ROOT";
+var createId = () => {
+	return `mela:new-annotation:${Date.now()}`;
+};
+var updateSelector = (builder, selector) => {
+	if (!builder.getSpecificResourceTargets(selector.source).length) builder.addTarget({
+		type: "SpecificResource",
+		source: selector.source
+	});
+	builder.updateTextPositionSelector({
+		start: selector.start,
+		end: selector.end
+	}, selector.source);
+	builder.updateTextQuoteSelector({
+		prefix: selector.prefix,
+		suffix: selector.suffix,
+		exact: selector.exact
+	}, selector.source);
+	return builder;
+};
+var AnnotationUtilsImpl = class {
 	annotationConfig;
 	builderMap = /* @__PURE__ */ new Map();
 	childParentMap = /* @__PURE__ */ new Map();
@@ -174,369 +267,547 @@ var ie = ["text"], y = s.object({
 	linkedAnnotations = /* @__PURE__ */ new Map();
 	annotations = [];
 	allowedChildrenPerType = {};
-	constructor(e) {
-		this.annotationConfig = e;
+	constructor(annotationConfig) {
+		this.annotationConfig = annotationConfig;
 	}
-	getBuilder(e) {
-		let t = this.builderMap.get(e.id);
-		if (!t) throw Error(`Annotation builder not found: ${e.id}`);
-		return t;
+	getBuilder(annotation) {
+		const builder = this.builderMap.get(annotation.id);
+		if (!builder) throw new Error(`Annotation builder not found: ${annotation.id}`);
+		return builder;
 	}
-	setAnnotations(e, t) {
-		this.allowedChildrenPerType = t, this.annotations = e, this.parentChildMap.clear(), this.childParentMap.clear(), this.builderMap.clear();
-		let n = [], r = /* @__PURE__ */ new Map();
-		return e.forEach((e) => {
-			let t = l(e);
-			this.builderMap.set(e.id, t);
-			let i = me(e.id, t, this.allowedChildrenPerType);
-			r.set(e.id, e), i && n.push(i);
-		}), n.forEach((e) => {
-			let t = n.filter((t) => t.id !== e.id && t.sourceUri === e.sourceUri && t.start <= e.start && t.end >= e.end && t.allowedChildren.some((t) => t.key === e.type)).sort((e, t) => e.end - e.start - (t.end - t.start))[0], i = t?.id ?? F, a = this.parentChildMap.get(i) ?? [];
-			a.push(r.get(e.id)), this.parentChildMap.set(t?.id ?? F, a), this.childParentMap.set(e.id, r.get(i) ?? null);
-		}), e.forEach((t) => {
-			this.linkedAnnotations.set(t.id, pe(t.id, this.builderMap, e));
-		}), this;
+	setAnnotations(annotations, allowedChildrenPerType) {
+		this.allowedChildrenPerType = allowedChildrenPerType;
+		this.annotations = annotations;
+		this.parentChildMap.clear();
+		this.childParentMap.clear();
+		this.builderMap.clear();
+		const annotationsWithPositons = [];
+		const annotationIdMap = /* @__PURE__ */ new Map();
+		annotations.forEach((annotation) => {
+			const builder = w3cAnnotation(annotation);
+			this.builderMap.set(annotation.id, builder);
+			const position = getAnnotationPosition(annotation.id, builder, this.allowedChildrenPerType);
+			annotationIdMap.set(annotation.id, annotation);
+			if (position) annotationsWithPositons.push(position);
+		});
+		annotationsWithPositons.forEach((annotation) => {
+			const parentAnnotation = annotationsWithPositons.filter((a) => a.id !== annotation.id && a.sourceUri === annotation.sourceUri && a.start <= annotation.start && a.end >= annotation.end && a.allowedChildren.some((c) => c.key === annotation.type)).sort((a, b) => a.end - a.start - (b.end - b.start))[0];
+			const parentId = parentAnnotation?.id ?? rootId;
+			const children = this.parentChildMap.get(parentId) ?? [];
+			children.push(annotationIdMap.get(annotation.id));
+			this.parentChildMap.set(parentAnnotation?.id ?? rootId, children);
+			this.childParentMap.set(annotation.id, annotationIdMap.get(parentId) ?? null);
+		});
+		annotations.forEach((annotation) => {
+			this.linkedAnnotations.set(annotation.id, mapRelationsToLinks(annotation.id, this.builderMap, annotations));
+		});
+		return this;
 	}
-	getLinks(e) {
-		return this.linkedAnnotations.get(e.id) ?? [];
+	getLinks(annotation) {
+		return this.linkedAnnotations.get(annotation.id) ?? [];
 	}
-	getTextPositionSelector(e, t) {
-		return this.getBuilder(e).getTextPositionSelector(t)[0];
+	getTextPositionSelector(annotation, sourceUri) {
+		return this.getBuilder(annotation).getTextPositionSelector(sourceUri)[0];
 	}
-	isAnnotationUri = (e) => e.startsWith("mela:annotation/");
-	getParentSelector = (e) => e.getSpecificResourceTargets().find((e) => this.isAnnotationUri(e.source)) ?? null;
-	getParent(e) {
-		let t = this.getBuilder(e), n = this.getParentSelector(t);
-		return n ? this.annotations.find((e) => e.id === n.source) ?? null : null;
+	isAnnotationUri = (uri) => {
+		return uri.startsWith("mela:annotation/");
+	};
+	getParentSelector = (builder) => {
+		return builder.getSpecificResourceTargets().find((t) => this.isAnnotationUri(t.source)) ?? null;
+	};
+	getParent(annotation) {
+		const builder = this.getBuilder(annotation);
+		const parentUri = this.getParentSelector(builder);
+		if (!parentUri) return null;
+		return this.annotations.find((a) => a.id === parentUri.source) ?? null;
 	}
-	createAnnotation(e, t, n, r) {
-		let i = E(this.annotationConfig).toAnnotationBody(t), a = l(e ?? void 0).setMotivation("tagging").addBody(i);
-		return e?.id || a.setId(I()), n && Object.keys(n).length > 0 && (n.type = n.type ?? "AnnotationMetadata", n.purpose = n.purpose ?? N(a), a.updateBodyByType(n.type, n)), r && L(a, r), a.build();
+	createAnnotation(fromAnnotation, type, data, selectors) {
+		const styleBody = AnnotationStyleContextBuilder(this.annotationConfig).toAnnotationBody(type);
+		const builder = w3cAnnotation(fromAnnotation ?? void 0).setMotivation("tagging").addBody(styleBody);
+		if (!fromAnnotation?.id) builder.setId(createId());
+		if (data && Object.keys(data).length > 0) {
+			data.type = data.type ?? "AnnotationMetadata";
+			data.purpose = data.purpose ?? getAnnotationType(builder);
+			builder.updateBodyByType(data.type, data);
+		}
+		for (const selector of selectors) updateSelector(builder, selector);
+		return builder.build();
 	}
-	createLinkAnnotation = (e, t, n, r) => {
-		let i = E(this.annotationConfig).toAnnotationBody(n), a = l().setMotivation("tagging").setId(I()).addBody(i);
-		return r && Object.keys(r).length > 0 && (r.type = r.type ?? "AnnotationMetadata", r.purpose = r.purpose ?? N(a), a.updateBodyByType(r.type, r)), a.addTarget({ source: e.id }).addTarget({ source: t.id }), a.build();
+	createLinkAnnotation = (sourceAnnotation, targetAnnotation, type, data) => {
+		const styleBody = AnnotationStyleContextBuilder(this.annotationConfig).toAnnotationBody(type);
+		const builder = w3cAnnotation().setMotivation("tagging").setId(createId()).addBody(styleBody);
+		if (data && Object.keys(data).length > 0) {
+			data.type = data.type ?? "AnnotationMetadata";
+			data.purpose = data.purpose ?? getAnnotationType(builder);
+			builder.updateBodyByType(data.type, data);
+		}
+		builder.addTarget({ source: sourceAnnotation.id }).addTarget({ source: targetAnnotation.id });
+		return builder.build();
 	};
 	cancel() {
 		this.setAnnotations(this.annotations, this.allowedChildrenPerType);
 	}
-	getSourceUri = (e) => {
-		let t = this.getBuilder(e), n = t.getSourceUri();
-		return n ? {
-			textPositionSelector: t.getTextPositionSelector(n)[0],
-			sourceUri: n
-		} : (console.warn("no source uri"), null);
+	getSourceUri = (annotation) => {
+		const builder = this.getBuilder(annotation);
+		const sourceUri = builder.getSourceUri();
+		if (!sourceUri) {
+			console.warn("no source uri");
+			return null;
+		}
+		return {
+			textPositionSelector: builder.getTextPositionSelector(sourceUri)[0],
+			sourceUri
+		};
+	};
+	getMetadata = (annotation) => {
+		return this.getBuilder(annotation).getBodiesByType("AnnotationMetadata")?.[0] ?? null;
+	};
+	getAnnotationStyle = (annotation) => {
+		return getAnnotationStyle(this.getBuilder(annotation));
 	};
-	getMetadata = (e, t) => this.getBuilder(e).getBodiesByType("AnnotationMetadata")?.[0] ?? null;
-	getAnnotationStyle = (e) => P(this.getBuilder(e));
-	getAnnotationType = (e) => N(this.getBuilder(e));
-	createAnnotationFromSelector(e, t, n) {
-		let r = l(t ?? void 0).setMotivation("tagging").setId(I()), i = E(this.annotationConfig).toAnnotationBody(e);
-		return r.addBody(i), n && L(r, n), r.build();
+	getAnnotationType = (annotation) => {
+		return getAnnotationType(this.getBuilder(annotation));
+	};
+	createAnnotationFromSelector(type, annotation, selector) {
+		const builder = w3cAnnotation(annotation ?? void 0).setMotivation("tagging").setId(createId());
+		const styleBody = AnnotationStyleContextBuilder(this.annotationConfig).toAnnotationBody(type);
+		builder.addBody(styleBody);
+		if (selector) updateSelector(builder, selector);
+		return builder.build();
+	}
+};
+var annotationUtils = (annotationConfig) => {
+	return new AnnotationUtilsImpl(annotationConfig);
+};
+//#endregion
+//#region ../annotation-core/src/lib/utils/annotation-render.style.ts
+var defaultRender = (utils) => (annotation) => {
+	return (utils?.getAnnotationStyle(annotation))?.target ?? "default";
+};
+var styleFn = (listStyles, utils) => (annotation) => {
+	const style = utils?.getAnnotationStyle(annotation);
+	if (!style) return "default";
+	const styleId = style?.id ?? "default";
+	if (!listStyles.includes(styleId)) {
+		Debugger.debug("styleFn", `No style found for ${styleId}`);
+		if (style.color) return { default: createHighlightStyle(style.color) };
+		return "default";
 	}
-}, he = (e) => new R(e), z = (e) => (t) => e?.getAnnotationStyle(t)?.target ?? "default", B = (e, t) => (n) => {
-	let r = t?.getAnnotationStyle(n);
-	if (!r) return "default";
-	let i = r?.id ?? "default";
-	return e.includes(i) ? i : (u.debug("styleFn", `No style found for ${i}`), r.color ? { default: f(r.color) } : "default");
-}, V = (e, t) => e ? e.reduce((e, n) => (e[n.id] = t ? n[t] : n, e), {}) : {}, ge = (e, t, n, r) => {
-	let i = e ?? [], a = V(i), o = i.filter((e) => e.isRoot).map((e) => ({
-		key: e.id,
-		label: e.label
-	})), s = V(i, "style");
-	s.default ||= {
+	return styleId;
+};
+//#endregion
+//#region ../annotation-core/src/lib/utils/annotation-configuration.factory.ts
+var groupById = (defs, valueKey) => {
+	if (!defs) return {};
+	return defs.reduce((acc, def) => {
+		acc[def.id] = valueKey ? def[valueKey] : def;
+		return acc;
+	}, {});
+};
+var createAnnotationConfiguration = (annotationDefinitions, utils, textAdapter, annotationAdapter) => {
+	const definitions = annotationDefinitions ?? [];
+	const definitionsMap = groupById(definitions);
+	const rootTypes = definitions.filter((d) => d.annotation.isRoot).map((d) => ({
+		key: d.id,
+		label: d.label
+	}));
+	const styles = groupById(definitions, "style");
+	if (!styles["default"]) styles["default"] = {
 		label: "Annotation",
-		isRoot: !0,
-		style: { default: f("#dd7777") },
+		isRoot: true,
+		style: { default: createHighlightStyle("#dd7777") },
 		allowedChildren: [],
 		allowedLinks: [],
-		schema: {
-			uiSchema: {
-				type: "VerticalLayout",
-				elements: []
-			},
-			jsonSchema: {
-				type: "object",
-				properties: {}
-			},
-			metaDataSchema: {
-				type: "VerticalLayout",
-				elements: []
-			},
-			validation: () => void 0
+		views: {}
+	};
+	const listStyles = Object.keys(styles);
+	const allowedChildrenPerType = groupById(definitions, "allowedChildren");
+	const defaultAnnotationAdapter = (source) => W3CAnnotationAdapter(source ? { sourceUri: source.uri } : {});
+	const renderParams = () => ({ renderFn: defaultRender(utils) });
+	const styleParams = () => ({ styleFn: styleFn(listStyles, utils) });
+	const _createAnnotatedText = (id, sourceModel) => {
+		const _textAdapter = textAdapter?.() ?? PlainTextAdapter();
+		const annotatedText = createAnnotatedText(id, {
+			annotationAdapter: annotationAdapter?.() ?? defaultAnnotationAdapter(sourceModel),
+			textAdapter: _textAdapter
+		});
+		annotatedText.setSnapper(new WordSnapper()).setRenderParams(renderParams()).setStyleParams(styleParams()).registerStyles(styles);
+		if (sourceModel) {
+			const { content } = sourceModel;
+			annotatedText.setText(content.text).setTextAdapterParams({ textDirection: content.textDirection });
 		}
+		return annotatedText;
 	};
-	let c = Object.keys(s), l = V(i, "allowedChildren"), u = (e) => d(e ? { sourceUri: e.uri } : {}), p = () => ({ renderFn: z(t) }), m = () => ({ styleFn: B(c, t) });
 	return {
-		allowedChildrenPerType: l,
-		definitions: i,
-		getDefinition: (e) => a[e] ?? void 0,
-		rootTypes: o,
-		createAnnotatedText: (e, t) => {
-			let i = ne(e);
-			if (i.setSnapper(new te()).setAnnotationAdapter(r ?? u(t)).setTextAdapter(n ?? ee()).setRenderParams(p()).setStyleParams(m()).registerStyles(s), t) {
-				let { content: e } = t;
-				i.setText(e.text).setTextAdapter({ textDirection: e.textDirection });
-			}
-			return i;
-		}
+		allowedChildrenPerType,
+		definitions,
+		getDefinition: (id) => {
+			return definitionsMap[id] ?? void 0;
+		},
+		rootTypes,
+		createAnnotatedText: _createAnnotatedText
 	};
-}, H = Symbol("ANNOTATION_DEF_CONFIG_TOKEN");
+};
 //#endregion
-//#region \0@oxc-project+runtime@0.137.0/helpers/esm/decorateMetadata.js
-function U(e, t) {
-	if (typeof Reflect == "object" && typeof Reflect.metadata == "function") return Reflect.metadata(e, t);
+//#region src/lib/utils/annotation.context-builder.ts
+var ANNOTATION_DEF_CONFIG_TOKEN = Symbol("ANNOTATION_DEF_CONFIG_TOKEN");
+//#endregion
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.137.0/helpers/esm/decorateParam.js
-function W(e, t) {
-	return function(n, r) {
-		t(n, r, e);
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
 	};
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.137.0/helpers/esm/decorate.js
-function G(e, t, n, r) {
-	var i = arguments.length, a = i < 3 ? t : r === null ? r = Object.getOwnPropertyDescriptor(t, n) : r, o;
-	if (typeof Reflect == "object" && typeof Reflect.decorate == "function") a = Reflect.decorate(e, t, n, r);
-	else for (var s = e.length - 1; s >= 0; s--) (o = e[s]) && (a = (i < 3 ? o(a) : i > 3 ? o(t, n, a) : o(t, n)) || a);
-	return i > 3 && a && Object.defineProperty(t, n, a), a;
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 //#endregion
-//#region packages/annotation-api/src/lib/service/annotation-definition.service.ts
-var K = class {
-	config;
-	definitions = [];
-	groupedDefinitions = {};
-	cachedAt = 0;
-	constructor(e) {
-		this.config = e;
-	}
-	async findAllGrouped() {
-		return await this.setDefinitions(), Promise.resolve(this.groupedDefinitions);
+//#region src/lib/context/annotation-context.service.ts
+var AnnotationContextService = class AnnotationContextService {
+	configRegistry;
+	annotationDefConfig;
+	contextConfigMap = /* @__PURE__ */ new Map();
+	prefixMap = /* @__PURE__ */ new Map();
+	constructor(configRegistry, annotationDefConfig) {
+		this.configRegistry = configRegistry;
+		this.annotationDefConfig = annotationDefConfig;
 	}
-	async setDefinitions(e = !1) {
-		let t = Date.now();
-		if (!e && this.definitions.length && t - this.cachedAt < this.config.cacheTTLms) return;
-		let n = await this.reloadDefinitions() ?? [];
-		this.definitions = n, this.groupedDefinitions = n.reduce((e, t) => (e[t.id] = t, e), {}), this.cachedAt = t;
+	async reloadAll() {
+		this.contextConfigMap.clear();
+		this.configRegistry.findAll().forEach((resource) => {
+			const context = createAnnotationContext(this.annotationDefConfig, resource);
+			this.contextConfigMap.set(resource.id, context);
+			this.prefixMap.set(context.prefix, resource.id);
+		});
 	}
-	async findAll() {
-		return await this.setDefinitions(), Promise.resolve(this.definitions);
+	async findById(annotationId) {
+		const find = this.contextConfigMap.get(annotationId);
+		if (find) return find;
+		const resource = await this.configRegistry.findById(annotationId);
+		if (!resource) return null;
+		const context = createAnnotationContext(this.annotationDefConfig, resource);
+		this.contextConfigMap.set(annotationId, context);
+		return context;
 	}
-	async findById(e) {
-		await this.setDefinitions();
-		let t = this.groupedDefinitions[e];
-		if (t || await this.setDefinitions(!0), t = this.groupedDefinitions[e], !t) throw new a();
-		return Promise.resolve(t);
+	getResourceIdFromUri = (uri) => {
+		for (const prefix of this.prefixMap.keys()) if (uri.startsWith(prefix)) return uri.substring(prefix.length);
+		return null;
+	};
+};
+AnnotationContextService = __decorate([
+	Injectable(),
+	__decorateParam(0, Inject(ResourceConfigRegistry)),
+	__decorateParam(1, Inject(ANNOTATION_DEF_CONFIG_TOKEN)),
+	__decorateMetadata("design:paramtypes", [typeof ResourceConfigRegistry === "undefined" ? Object : ResourceConfigRegistry, Object])
+], AnnotationContextService);
+//#endregion
+//#region src/lib/annotation/annotation.mapper.service.ts
+var AnnotationW3cMapperService = class AnnotationW3cMapperService {
+	contextService;
+	constructor(contextService) {
+		this.contextService = contextService;
 	}
-	async getAllContextBuilders() {
-		return (await this.findAll()).map((e) => e.context);
+	async getW3CAnnotation(type, annotation) {
+		const annotationDef = await this.contextService.findById(type);
+		return this.mapToW3CAnnotation(annotationDef, annotation);
 	}
-	async getContextBuilder(e) {
-		let t = await this.findById(e);
-		if (!t) throw new a();
-		return t.context;
+	async fromW3CAnnotation(type, annotation) {
+		const annotationDef = await this.contextService.findById(type);
+		return this.mapFromW3CAnnotation(annotationDef, annotation);
 	}
 };
-K = G([
-	r(),
-	W(0, n(H)),
-	U("design:paramtypes", [Object])
-], K);
+AnnotationW3cMapperService = __decorate([__decorateParam(0, Inject(AnnotationContextService)), __decorateMetadata("design:paramtypes", [typeof AnnotationContextService === "undefined" ? Object : AnnotationContextService])], AnnotationW3cMapperService);
+//#endregion
+//#region src/lib/prefix.ts
+var SCHEMA_PREFIX = "annotation-editor";
 //#endregion
-//#region packages/annotation-api/src/lib/service/annotation-definition-from-files.service.ts
-var q = class extends K {
-	_initialDefinitions;
-	_loaderFn;
-	constructor(e, t, n) {
-		super(e), this._initialDefinitions = t, this._loaderFn = n;
+//#region src/lib/annotation-namespace.controller.ts
+var AnnotationNamespaceController = class AnnotationNamespaceController {
+	service;
+	annotationContextService;
+	constructor(service, annotationContextService) {
+		this.service = service;
+		this.annotationContextService = annotationContextService;
+	}
+	async listNames() {
+		const basePath = process.env["API_URL"] ?? "";
+		const base = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+		return { annotations: (await this.service.getAll()).map((a) => ({
+			id: a.id,
+			name: a.name,
+			schemas: `${base}/${SCHEMA_PREFIX}/${a.id}/schemas`,
+			jsonld: `${base}/ns/${a.id}.jsonld`
+		})) };
+	}
+	async getJsonLd_(id) {
+		return (await this.annotationContextService.findById(id))?.jsonLd;
 	}
-	reloadDefinitions = () => this.config.isDev && this._loaderFn ? Promise.resolve(this._loaderFn()) : Promise.resolve(this._initialDefinitions ?? []);
 };
-q = G([
-	r(),
-	W(0, n(H)),
-	U("design:paramtypes", [
-		Object,
-		Array,
-		Object
-	])
-], q);
+__decorate([
+	Get(),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", []),
+	__decorateMetadata("design:returntype", Promise)
+], AnnotationNamespaceController.prototype, "listNames", null);
+__decorate([
+	Get(":id.jsonld"),
+	__decorateParam(0, Param("id")),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [String]),
+	__decorateMetadata("design:returntype", Promise)
+], AnnotationNamespaceController.prototype, "getJsonLd_", null);
+AnnotationNamespaceController = __decorate([
+	Controller("ns"),
+	ApiTags("Annotations NS"),
+	__decorateParam(0, Inject(ResourceConfigRegistry)),
+	__decorateParam(1, Inject(ANNOTATION_DEF_CONFIG_TOKEN)),
+	__decorateMetadata("design:paramtypes", [typeof ResourceConfigRegistry === "undefined" ? Object : ResourceConfigRegistry, Object])
+], AnnotationNamespaceController);
 //#endregion
-//#region packages/annotation-api/src/lib/service/annotation-definition.loader.ts
-var J = (e, t, n) => {
-	if (!h(e)) return [];
-	let r = _(e, { withFileTypes: !0 }).filter((e) => e.isDirectory()).map((e) => e.name), i = [];
-	for (let a of r) {
-		let r = v(e, a, "resource.json");
-		if (!h(r)) continue;
-		let o = JSON.parse(g(r, "utf-8"));
-		i.push(M(o, t, n));
-	}
-	return i;
-}, Y = class {
-	service;
-	annotationDefConfig;
-	constructor(e, t) {
-		this.service = e, this.annotationDefConfig = t;
+//#region src/lib/annotation/annotation.controller.ts
+var AnnotationController = class AnnotationController {
+	annotationRepository;
+	wrapper;
+	contextService;
+	constructor(annotationRepository, wrapper, contextService) {
+		this.annotationRepository = annotationRepository;
+		this.wrapper = wrapper;
+		this.contextService = contextService;
 	}
-	getAll() {
-		return this.service.findAll();
+	async create(type, annotationBody) {
+		const parsed = await this.wrapper.fromW3CAnnotation(type, annotationBody);
+		const annotation = await this.annotationRepository.create(parsed);
+		return this.get(annotation.id);
 	}
-	async getJsonLd_(e) {
-		return e === "AnnotationStyle" ? E(this.annotationDefConfig).toJsonLdContext() : (await this.service.findById(e))?.json_ld;
+	async getByType(id) {
+		const { annotation, type } = await this.annotationRepository.findOne(id);
+		return this.wrapper.getW3CAnnotation(type, annotation);
 	}
-	async getSchemas(e) {
-		let t = await this.service.findById(e);
-		return {
-			id: t.id,
-			name: t.name,
-			json_schema: t.json_schema,
-			ui_schema: t.ui_schema,
-			metadata_schema: t.metadata_schema,
-			columns: t.columns,
-			isRoot: t.isRoot,
-			allowedChildren: t.allowedChildren,
-			allowedLinks: t.allowedLinks,
-			type: t.type,
-			icon: t.icon,
-			target: t.target
-		};
+	async get(id) {
+		const _id = this.contextService.getResourceIdFromUri(id) ?? id;
+		const { annotation, type } = await this.annotationRepository.findOne(_id);
+		return this.wrapper.getW3CAnnotation(type, annotation);
 	}
-	async getById(e) {
-		return await this.service.findById(e);
+	async patch(type, id, annotationBody) {
+		const _id = this.contextService.getResourceIdFromUri(id) ?? id;
+		const _annotation = await this.wrapper.fromW3CAnnotation(type, annotationBody);
+		const annotation = await this.annotationRepository.update(_id, _annotation);
+		return this.get(annotation.id);
 	}
-	async getFullJsonLd() {
-		return (await this.service.getAllContextBuilders()).map((e) => e.toJsonLdContext());
+	async delete(id) {
+		const _id = this.contextService.getResourceIdFromUri(id) ?? id;
+		return this.annotationRepository.delete(_id);
 	}
-	async getJsonLd(e) {
-		let t = await this.service.getContextBuilder(e);
-		return {
-			jsonLd: t.toJsonLdContext(),
-			forms: t.toJsonSchema()
-		};
+	async deleteType(id) {
+		const _id = this.contextService.getResourceIdFromUri(id) ?? id;
+		return this.annotationRepository.delete(_id);
 	}
 };
-G([
-	t(),
-	U("design:type", Function),
-	U("design:paramtypes", []),
-	U("design:returntype", void 0)
-], Y.prototype, "getAll", null), G([
-	t(":id.jsonld"),
-	W(0, o("id")),
-	U("design:type", Function),
-	U("design:paramtypes", [String]),
-	U("design:returntype", Promise)
-], Y.prototype, "getJsonLd_", null), G([
-	t(":id/schemas"),
-	W(0, o("id")),
-	U("design:type", Function),
-	U("design:paramtypes", [String]),
-	U("design:returntype", Promise)
-], Y.prototype, "getSchemas", null), G([
-	t(":id"),
-	W(0, o("id")),
-	U("design:type", Function),
-	U("design:paramtypes", [String]),
-	U("design:returntype", Promise)
-], Y.prototype, "getById", null), G([
-	t("anno.jsonld"),
-	U("design:type", Function),
-	U("design:paramtypes", []),
-	U("design:returntype", Promise)
-], Y.prototype, "getFullJsonLd", null), G([
-	t(":type/anno.jsonld"),
-	W(0, o("type")),
-	U("design:type", Function),
-	U("design:paramtypes", [String]),
-	U("design:returntype", Promise)
-], Y.prototype, "getJsonLd", null), Y = G([
-	e("ns"),
-	re("Annotations NS"),
-	W(0, n(K)),
-	W(1, n(H)),
-	U("design:paramtypes", [K === void 0 ? Object : K, Object])
-], Y);
+__decorate([
+	Post(":type"),
+	ApiOperation({ summary: "Create a W3C annotation" }),
+	ApiBody({ description: "W3C annotation body" }),
+	ApiResponse({
+		status: 201,
+		description: "The created W3C annotation"
+	}),
+	__decorateParam(0, Param("type")),
+	__decorateParam(1, Body()),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [String, Object]),
+	__decorateMetadata("design:returntype", Promise)
+], AnnotationController.prototype, "create", null);
+__decorate([
+	Get(":type/:id"),
+	ApiOperation({ summary: "Get one annotation by id" }),
+	ApiParam({
+		name: "id",
+		type: "string"
+	}),
+	ApiParam({
+		name: "type",
+		type: "string"
+	}),
+	ApiResponse({
+		status: 200,
+		description: "The W3C annotation"
+	}),
+	__decorateParam(0, Param("id")),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [String]),
+	__decorateMetadata("design:returntype", Promise)
+], AnnotationController.prototype, "getByType", null);
+__decorate([
+	Get(":id"),
+	ApiOperation({ summary: "Get one annotation by id" }),
+	ApiParam({
+		name: "id",
+		type: "string"
+	}),
+	ApiResponse({
+		status: 200,
+		description: "The W3C annotation"
+	}),
+	__decorateParam(0, Param("id")),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [String]),
+	__decorateMetadata("design:returntype", Promise)
+], AnnotationController.prototype, "get", null);
+__decorate([
+	Patch(":type/:id"),
+	ApiOperation({ summary: "Update an annotation" }),
+	ApiParam({
+		name: "id",
+		type: "string"
+	}),
+	ApiBody({ description: "W3C annotation body" }),
+	ApiResponse({
+		status: 200,
+		description: "The updated W3C annotation"
+	}),
+	__decorateParam(0, Param("type")),
+	__decorateParam(1, Param("id")),
+	__decorateParam(2, Body()),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [
+		String,
+		String,
+		Object
+	]),
+	__decorateMetadata("design:returntype", Promise)
+], AnnotationController.prototype, "patch", null);
+__decorate([
+	Delete(":id"),
+	ApiOperation({ summary: "Delete an annotation" }),
+	ApiParam({
+		name: "id",
+		type: "string"
+	}),
+	ApiResponse({
+		status: 200,
+		description: "Annotation deleted"
+	}),
+	__decorateParam(0, Param("id")),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [String]),
+	__decorateMetadata("design:returntype", Promise)
+], AnnotationController.prototype, "delete", null);
+__decorate([
+	Delete(":type/:id"),
+	ApiOperation({ summary: "Delete an annotation" }),
+	ApiParam({
+		name: "id",
+		type: "string"
+	}),
+	ApiResponse({
+		status: 200,
+		description: "Annotation deleted"
+	}),
+	__decorateParam(0, Param("id")),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [String]),
+	__decorateMetadata("design:returntype", Promise)
+], AnnotationController.prototype, "deleteType", null);
+AnnotationController = __decorate([
+	Controller(`${SCHEMA_PREFIX}/annotation`),
+	ApiTags("Annotations"),
+	__decorateParam(0, Inject(AnnotationCrudRepository)),
+	__decorateParam(1, Inject(AnnotationW3cMapperService)),
+	__decorateParam(2, Inject(AnnotationContextService)),
+	__decorateMetadata("design:paramtypes", [
+		typeof AnnotationCrudRepository === "undefined" ? Object : AnnotationCrudRepository,
+		typeof AnnotationW3cMapperService === "undefined" ? Object : AnnotationW3cMapperService,
+		typeof AnnotationContextService === "undefined" ? Object : AnnotationContextService
+	])
+], AnnotationController);
 //#endregion
-//#region packages/annotation-api/src/lib/resource/annotation-resource.loader.ts
-var X = (e, t) => {
-	let n = v(e, "_resource");
-	if (!h(n)) return [];
-	let r = _(n).filter((e) => e.endsWith(".json")), { prefix: i } = C(t);
-	return r.map((e) => {
-		let t = JSON.parse(g(v(n, e), "utf-8")), r = t.columns.find((e) => e.displayAs === "id"), a = t.columns.find((e) => e.displayAs === "label");
-		return {
-			type: t.type,
-			table: t.table,
-			database: t.database,
-			field: {
-				id: r?.column ?? "id",
-				label: a?.column ?? "name"
-			},
-			prefix: `${i}:${t.type}/`
-		};
-	});
-}, Z = class {
-	byType = /* @__PURE__ */ new Map();
-	constructor(e) {
-		for (let t of e) this.byType.set(t.type, t);
-	}
-	findAll = () => [...this.byType.values()];
-	getResourceForType = (e) => this.byType.get(e) ?? null;
-	getResourceFromUri = (e) => {
-		for (let t of this.byType.values()) if (e.startsWith(t.prefix)) return {
-			...t,
-			id: e.substring(t.prefix.length)
-		};
-		return null;
+//#region src/lib/utils/schemaEnricher.utils.ts
+var createSchemaEnricher = (baseUrl = "") => (schema) => {
+	const uri = `${baseUrl}${SCHEMA_PREFIX}/annotation/${schema.route}`;
+	const uriId = `${uri}/{id}`;
+	schema.operations = {
+		findOne: schema.operations.findOne ?? {
+			uri: uriId,
+			method: "get"
+		},
+		update: schema.operations.update ?? {
+			uri: uriId,
+			method: "patch"
+		},
+		delete: schema.operations.delete ?? {
+			uri: uriId,
+			method: "delete"
+		},
+		create: schema.operations.create ?? {
+			uri,
+			method: "post"
+		},
+		findAll: schema.operations.findAll
 	};
+	return { ...schema };
 };
-Z = G([r(), U("design:paramtypes", [Array])], Z);
 //#endregion
-//#region packages/annotation-api/src/lib/annotation-api.module.ts
-var Q, $ = Q = class {
-	static forService(e) {
-		return {
-			module: Q,
-			global: !0,
-			controllers: [Y],
-			providers: [{
-				provide: K,
-				useClass: e.annotationDefinitionService
-			}],
-			exports: [K]
-		};
-	}
-	static async forResourceDir(e, t) {
-		let n = () => J(e, t, j), r = new q(t, n(), n), i = new Z(X(e, t));
-		return {
-			module: Q,
-			global: !0,
-			controllers: [Y],
+//#region src/lib/annotation-api.module.ts
+var _AnnotationApiModule;
+registerResourceExtensions({ annotation: AnnotationConfigSchema });
+var AnnotationApiModule = _AnnotationApiModule = class AnnotationApiModule {
+	static async forResourceDir(resourcePath, datasourcePath, config, annotation) {
+		const _config = resolveConfig(config);
+		const crouton = await CroutonApiModule.forResourceDir(resourcePath, datasourcePath, {
+			baseUrl: "",
+			prefix: SCHEMA_PREFIX,
+			extensions: { annotation: AnnotationConfigSchema },
+			schemaEnricher: createSchemaEnricher(_config.baseUrl)
+		});
+		if (annotation) return {
+			module: _AnnotationApiModule,
+			global: true,
+			imports: [crouton],
+			controllers: [AnnotationNamespaceController, AnnotationController],
 			providers: [
+				AnnotationContextService,
 				{
-					provide: H,
-					useValue: t
+					provide: ANNOTATION_DEF_CONFIG_TOKEN,
+					useValue: _config
 				},
 				{
-					provide: K,
-					useValue: r
+					provide: AnnotationCrudRepository,
+					useExisting: annotation.repository
 				},
 				{
-					provide: Z,
-					useValue: i
+					provide: AnnotationW3cMapperService,
+					useExisting: annotation.mapper
 				}
 			],
-			exports: [K, Z]
+			exports: [AnnotationContextService]
+		};
+		return {
+			module: _AnnotationApiModule,
+			global: true,
+			imports: [crouton],
+			controllers: [AnnotationNamespaceController],
+			providers: [AnnotationContextService, {
+				provide: ANNOTATION_DEF_CONFIG_TOKEN,
+				useValue: _config
+			}],
+			exports: [AnnotationContextService]
 		};
 	}
 };
-$ = Q = G([i({
+AnnotationApiModule = _AnnotationApiModule = __decorate([Module({
 	controllers: [],
 	providers: [],
 	exports: []
-})], $);
+})], AnnotationApiModule);
 //#endregion
-export { H as ANNOTATION_DEF_CONFIG_TOKEN, $ as AnnotationApiModule, q as AnnotationDefinitionFromFilesService, K as AnnotationDefinitionService, b as AnnotationMetadataType, Z as AnnotationResourceDefinitionService, E as AnnotationStyleContextBuilder, T as AnnotationStyleType, ae as SourceModelSchema, y as SourceTextSchema, x as annotationColumnDefinition, j as annotationContextBuilderFactory, ce as annotationDefinition, he as annotationUtils, w as baseContextBuilder, M as buildAnnotationDefinition, fe as buildAnnotationDefinitions, oe as buildGridStyle, k as buildMetadataSchema, O as buildUiSchema, ge as createAnnotationConfiguration, de as createAnnotationStyleBodyUnsafe, z as defaultRender, se as getPaneArea, A as jsonSchemaPropertyToZod, J as loadAnnotationDefinitionsFromDir, X as loadAnnotationResourcesFromDir, C as resolveConfig, B as styleFn };
+export { AnnotationApiModule, AnnotationConfigSchema, AnnotationContextService, AnnotationCrudRepository, AnnotationJsonResourceSchema, AnnotationJsonResourceShape, AnnotationMetadataType, AnnotationResourceSchema, AnnotationStyleContextBuilder, AnnotationStyleType, AnnotationW3cMapperService, BASELINE_RESOURCE_VERSION, CURRENT_RESOURCE_VERSION, KeyLabelSchema, SourceModelSchema, SourceTextSchema, annotationColumnDefinition, annotationUtils, baseContextBuilder, buildGridStyle, buildPrefix, createAnnotationConfiguration, createAnnotationContext, createAnnotationStyleBodyUnsafe, defaultRender, getPaneArea, resolveConfig, styleFn };