@ghentcdh/annotation-api 0.0.1-alpha.1 → 0.0.1-alpha.13

package/index.js

@@ -1,369 +1,813 @@
-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 } from "@ghentcdh/w3c-utils";
-import "@ghentcdh/annotated-text";
-import { existsSync as l, readFileSync as u, readdirSync as d } from "node:fs";
-import { join as f } from "node:path";
-import { ApiTags as p } from "@nestjs/swagger";
-//#region packages/annotation-core/src/lib/types/annotation.contex.ts
-var m = "AnnotationMetadata", h = s.object({}), g = s.object({
-	id: s.string(),
-	name: s.string(),
-	columns: s.array(h),
-	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()).optional(),
-	allowedLinks: s.array(s.string()).optional(),
-	context: s.custom(),
-	target: s.enum([
-		"gutter",
-		"underline",
-		"highlight"
-	]).optional()
-}), _ = {
-	baseUrl: "http://localhost:3000/",
+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(" ")
+	};
+	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
-}, v = (e = {}) => {
-	let t = e.baseUrl ?? _.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: normalizedBaseUrl,
+		contextUrl: `${normalizedBaseUrl}ns/`,
+		app: config.app ?? defaultConfig.app,
+		prefix: config.prefix ?? defaultConfig.prefix,
+		crudController: config.crudController ?? defaultConfig.crudController,
+		isDev,
+		cacheTTLms
+	};
+};
+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 {
-		baseUrl: n,
-		contextUrl: `${n}ns/`,
-		app: e.app ?? _.app,
-		prefix: e.prefix ?? _.prefix,
-		isDev: r,
-		cacheTTLms: i
+		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)
 	};
-}, y = (e, t) => {
-	let { prefix: n, baseUrl: r, contextUrl: i } = v(t), a = m;
-	return c(n, r).setType(n, a).addPrefix(e, `${n}:${e}`).setContextUri(`${i}${e}.jsonld`);
-}, b = s.object({
-	id: s.string(),
-	name: s.string(),
-	target: s.enum([
+};
+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()
-}), x = "AnnotationStyle", S = (e) => {
-	let { prefix: t, baseUrl: n, contextUrl: r } = v(e);
-	return c(t, n).setType(t, x).setContextUri(`${r}${x}.jsonld`).parseZodSchema(b);
-}, C = (e) => {
-	let t = {};
-	if (e.fieldInput) {
-		let { type: n, options: r } = e.fieldInput;
-		t.format = n, n === "autocomplete" && (t.dataField = "data", r.uri && (t.uri = r.uri), r.resource && (t.resource = r.resource), r.valueKey && (t.valueKey = r.valueKey), r.labelKey && (t.labelKey = r.labelKey), r.enableCreate !== void 0 && (t.enableCreate = r.enableCreate));
+	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
+	};
+	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 {
-		type: "Control",
-		scope: `#/properties/${e.id}`,
-		options: t
+		id,
+		start: textPositionSelector.start,
+		end: textPositionSelector.end,
+		allowedChildren: allowedChildrenPerType[type] ?? [],
+		sourceUri: sourceUri ?? "",
+		type,
+		minX: textPositionSelector.start,
+		minY: 0,
+		maxX: textPositionSelector.end,
+		maxY: 0
 	};
-}, w = (e) => ({
-	type: "TextCell",
-	scope: `#/properties/${e.id}`,
-	options: {
-		format: "keyValue",
-		key: e.fieldInput?.options?.labelKey ?? e.displayKey ?? "label"
+};
+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();
+	parentChildMap = /* @__PURE__ */ new Map();
+	linkedAnnotations = /* @__PURE__ */ new Map();
+	annotations = [];
+	allowedChildrenPerType = {};
+	constructor(annotationConfig) {
+		this.annotationConfig = annotationConfig;
+	}
+	getBuilder(annotation) {
+		const builder = this.builderMap.get(annotation.id);
+		if (!builder) throw new Error(`Annotation builder not found: ${annotation.id}`);
+		return builder;
+	}
+	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;
 	}
-}), T = (e) => ({
-	type: "GridLayout",
-	elements: e.filter((e) => !e.hiddenInForm).map(C),
-	options: {}
-}), E = (e) => ({
-	type: "GridLayout",
-	elements: e.filter((e) => !e.hiddenInMetadata).map(w),
-	options: {}
-}), D = (e) => {
-	if (e.type === "object" && e.properties) {
-		let t = {};
-		for (let [n, r] of Object.entries(e.properties)) t[n] = D(r);
-		return s.object(t);
+	getLinks(annotation) {
+		return this.linkedAnnotations.get(annotation.id) ?? [];
 	}
-	return s.string();
-}, O = (e, t, n) => {
-	let r = y(e, n), i = t.columns ?? [];
-	if (!i.length) return r;
-	let a = {};
-	for (let e of i) e.type && (a[e.id] = D(e.type));
-	return Object.keys(a).length ? r.parseZodSchema(s.object(a)) : r;
-}, k = (e, t, n = O) => {
-	let r = n(e.id, e, t), i = e.columns ?? [], a = i.length > 0, o = e.ui_schema ?? (a ? T(i) : void 0), s = e.metadata_schema ?? (a ? E(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
+	getTextPositionSelector(annotation, sourceUri) {
+		return this.getBuilder(annotation).getTextPositionSelector(sourceUri)[0];
+	}
+	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(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 = (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 = (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));
+	};
+	getAnnotationType = (annotation) => {
+		return getAnnotationType(this.getBuilder(annotation));
 	};
-	return o && (c.ui_schema = o), s && (c.metadata_schema = s), e.type && (c.type = e.type), e.icon && (c.icon = e.icon), e.target && (c.target = e.target), e.allowedChildren && (c.allowedChildren = e.allowedChildren), e.allowedLinks && (c.allowedLinks = e.allowedLinks), c;
-}, A = Symbol("ANNOTATION_DEF_CONFIG_TOKEN");
+	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";
+	}
+	return styleId;
+};
 //#endregion
-//#region \0@oxc-project+runtime@0.133.0/helpers/esm/decorateMetadata.js
-function j(e, t) {
-	if (typeof Reflect == "object" && typeof Reflect.metadata == "function") return Reflect.metadata(e, t);
+//#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: true,
+		style: { default: createHighlightStyle("#dd7777") },
+		allowedChildren: [],
+		allowedLinks: [],
+		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;
+	};
+	return {
+		allowedChildrenPerType,
+		definitions,
+		getDefinition: (id) => {
+			return definitionsMap[id] ?? void 0;
+		},
+		rootTypes,
+		createAnnotatedText: _createAnnotatedText
+	};
+};
+//#endregion
+//#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.133.0/helpers/esm/decorateParam.js
-function M(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.133.0/helpers/esm/decorate.js
-function N(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 P = 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);
 	}
 };
-P = N([
-	r(),
-	M(0, n(A)),
-	j("design:paramtypes", [Object])
-], P);
+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 F = class extends P {
-	_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 ?? []);
 };
-F = N([
-	r(),
-	M(0, n(A)),
-	j("design:paramtypes", [
-		Object,
-		Array,
-		Object
-	])
-], F);
+__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 I = (e, t, n) => {
-	if (!l(e)) return [];
-	let r = d(e, { withFileTypes: !0 }).filter((e) => e.isDirectory()).map((e) => e.name), i = [];
-	for (let a of r) {
-		let r = f(e, a, "resource.json");
-		if (!l(r)) continue;
-		let o = JSON.parse(u(r, "utf-8"));
-		i.push(k(o, t, n));
+//#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;
 	}
-	return i;
-}, L = class {
-	service;
-	annotationDefConfig;
-	constructor(e, t) {
-		this.service = e, this.annotationDefConfig = t;
+	async create(type, annotationBody) {
+		const parsed = await this.wrapper.fromW3CAnnotation(type, annotationBody);
+		const annotation = await this.annotationRepository.create(parsed);
+		return this.get(annotation.id);
 	}
-	getAll() {
-		return this.service.findAll();
+	async getByType(id) {
+		const { annotation, type } = await this.annotationRepository.findOne(id);
+		return this.wrapper.getW3CAnnotation(type, annotation);
 	}
-	async getJsonLd_(e) {
-		return e === "AnnotationStyle" ? S(this.annotationDefConfig).toJsonLdContext() : (await this.service.findById(e))?.json_ld;
+	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 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 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 getById(e) {
-		return await this.service.findById(e);
+	async delete(id) {
+		const _id = this.contextService.getResourceIdFromUri(id) ?? id;
+		return this.annotationRepository.delete(_id);
 	}
-	async getFullJsonLd() {
-		return (await this.service.getAllContextBuilders()).map((e) => e.toJsonLdContext());
-	}
-	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);
 	}
 };
-N([
-	t(),
-	j("design:type", Function),
-	j("design:paramtypes", []),
-	j("design:returntype", void 0)
-], L.prototype, "getAll", null), N([
-	t(":id.jsonld"),
-	M(0, o("id")),
-	j("design:type", Function),
-	j("design:paramtypes", [String]),
-	j("design:returntype", Promise)
-], L.prototype, "getJsonLd_", null), N([
-	t(":id/schemas"),
-	M(0, o("id")),
-	j("design:type", Function),
-	j("design:paramtypes", [String]),
-	j("design:returntype", Promise)
-], L.prototype, "getSchemas", null), N([
-	t(":id"),
-	M(0, o("id")),
-	j("design:type", Function),
-	j("design:paramtypes", [String]),
-	j("design:returntype", Promise)
-], L.prototype, "getById", null), N([
-	t("anno.jsonld"),
-	j("design:type", Function),
-	j("design:paramtypes", []),
-	j("design:returntype", Promise)
-], L.prototype, "getFullJsonLd", null), N([
-	t(":type/anno.jsonld"),
-	M(0, o("type")),
-	j("design:type", Function),
-	j("design:paramtypes", [String]),
-	j("design:returntype", Promise)
-], L.prototype, "getJsonLd", null), L = N([
-	e("ns"),
-	p("Annotations NS"),
-	M(0, n(P)),
-	M(1, n(A)),
-	j("design:paramtypes", [P === void 0 ? Object : P, Object])
-], L);
+__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 R = (e, t) => {
-	let n = f(e, "_resource");
-	if (!l(n)) return [];
-	let r = d(n).filter((e) => e.endsWith(".json")), { prefix: i } = v(t);
-	return r.map((e) => {
-		let t = JSON.parse(u(f(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 = N([r(), j("design:paramtypes", [Array])], z);
 //#endregion
-//#region packages/annotation-api/src/lib/annotation-api.module.ts
-var B, V = B = class {
-	static forService(e) {
-		return {
-			module: B,
-			global: !0,
-			controllers: [L],
-			providers: [{
-				provide: P,
-				useClass: e.annotationDefinitionService
-			}],
-			exports: [P]
-		};
-	}
-	static async forResourceDir(e, t) {
-		let n = () => I(e, t, O), r = new F(t, n(), n), i = new z(R(e, t));
-		return {
-			module: B,
-			global: !0,
-			controllers: [L],
+//#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: A,
-					useValue: t
+					provide: ANNOTATION_DEF_CONFIG_TOKEN,
+					useValue: _config
 				},
 				{
-					provide: P,
-					useValue: r
+					provide: AnnotationCrudRepository,
+					useExisting: annotation.repository
 				},
 				{
-					provide: z,
-					useValue: i
+					provide: AnnotationW3cMapperService,
+					useExisting: annotation.mapper
 				}
 			],
-			exports: [P, z]
+			exports: [AnnotationContextService]
+		};
+		return {
+			module: _AnnotationApiModule,
+			global: true,
+			imports: [crouton],
+			controllers: [AnnotationNamespaceController],
+			providers: [AnnotationContextService, {
+				provide: ANNOTATION_DEF_CONFIG_TOKEN,
+				useValue: _config
+			}],
+			exports: [AnnotationContextService]
 		};
 	}
 };
-V = B = N([i({
+AnnotationApiModule = _AnnotationApiModule = __decorate([Module({
 	controllers: [],
 	providers: [],
 	exports: []
-})], V);
+})], AnnotationApiModule);
 //#endregion
-export { A as ANNOTATION_DEF_CONFIG_TOKEN, V as AnnotationApiModule, F as AnnotationDefinitionFromFilesService, P as AnnotationDefinitionService, z as AnnotationResourceDefinitionService, h as annotationColumnDefinition, g as annotationDefinition, I as loadAnnotationDefinitionsFromDir, R as loadAnnotationResourcesFromDir };
+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 };