triiiceratops 0.8.2 → 0.9.0

package/dist/types/config.js

@@ -0,0 +1 @@
+export {};

package/dist/{src/lib/types → types}/plugin.d.ts

@@ -1,6 +1,6 @@
-import { Component } from 'svelte';
-import { default as OpenSeadragon } from 'openseadragon';
-import { ViewerState } from '../state/viewer.svelte';
+import type { Component } from 'svelte';
+import type OpenSeadragon from 'openseadragon';
+import type { ViewerState } from '../state/viewer.svelte';
 /**
  * Context object passed to plugins during registration.
  * This is the stable public API that plugins depend on.

package/dist/types/plugin.js

@@ -0,0 +1,36 @@
+/**
+ * Optional base class providing common plugin functionality.
+ */
+var BasePlugin = /** @class */ (function () {
+    function BasePlugin() {
+        this.context = null;
+    }
+    BasePlugin.prototype.onRegister = function (context) {
+        this.context = context;
+    };
+    BasePlugin.prototype.onDestroy = function () {
+        this.context = null;
+    };
+    Object.defineProperty(BasePlugin.prototype, "viewerState", {
+        /** Convenience getter for ViewerState */
+        get: function () {
+            if (!this.context) {
+                throw new Error("Plugin ".concat(this.id, " accessed viewerState before registration"));
+            }
+            return this.context.viewerState;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BasePlugin.prototype, "osdViewer", {
+        /** Convenience getter for OSD viewer */
+        get: function () {
+            var _a, _b;
+            return (_b = (_a = this.context) === null || _a === void 0 ? void 0 : _a.getOSDViewer()) !== null && _b !== void 0 ? _b : null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return BasePlugin;
+}());
+export { BasePlugin };

package/dist/utils/annotationAdapter.js

@@ -0,0 +1,354 @@
+/**
+ * Helper to extract ID from annotation object
+ * Handles Manifesto objects and raw JSON
+ */
+function getAnnotationId(anno) {
+    return anno.id || anno['@id'] || (typeof anno.getId === 'function' ? anno.getId() : '');
+}
+/**
+ * Parse xywh media fragment from target string
+ * Format: "canvas-id#xywh=x,y,w,h"
+ */
+function parseXywh(targetStr) {
+    if (!targetStr)
+        return null;
+    var match = targetStr.match(/xywh=(\d+),(\d+),(\d+),(\d+)/);
+    if (match) {
+        return {
+            x: parseInt(match[1], 10),
+            y: parseInt(match[2], 10),
+            w: parseInt(match[3], 10),
+            h: parseInt(match[4], 10),
+        };
+    }
+    return null;
+}
+/**
+ * Extract target geometry from various annotation formats
+ */
+function extractGeometry(annotation) {
+    // Try to find SVG selector first
+    var svgSelector = findSvgSelector(annotation);
+    if (svgSelector) {
+        return convertSvgToPolygon(svgSelector);
+    }
+    // Extract xywh from target
+    var xywh = extractXywhFromTarget(annotation);
+    if (xywh) {
+        return {
+            type: 'RECTANGLE',
+            x: xywh.x,
+            y: xywh.y,
+            w: xywh.w,
+            h: xywh.h,
+        };
+    }
+    return null;
+}
+/**
+ * Find SVG selector in annotation target
+ */
+function findSvgSelector(annotation) {
+    var _a, _b;
+    // Try Manifesto method
+    if (typeof annotation.getTarget === 'function') {
+        // For Manifesto, check raw JSON for SVG
+        var rawOn = ((_a = annotation.__jsonld) === null || _a === void 0 ? void 0 : _a.on) || ((_b = annotation.__jsonld) === null || _b === void 0 ? void 0 : _b.target);
+        if (rawOn) {
+            return extractSvgFromTarget(rawOn);
+        }
+    }
+    // Check common locations in raw JSON
+    var target = annotation.target || annotation.on;
+    if (target) {
+        return extractSvgFromTarget(target);
+    }
+    return null;
+}
+/**
+ * Extract SVG from target object/array
+ */
+function extractSvgFromTarget(target) {
+    if (!target)
+        return null;
+    // Handle array of targets
+    if (Array.isArray(target)) {
+        for (var _i = 0, target_1 = target; _i < target_1.length; _i++) {
+            var t = target_1[_i];
+            var svg = extractSvgValue(t);
+            if (svg)
+                return svg;
+        }
+    }
+    else {
+        return extractSvgValue(target);
+    }
+    return null;
+}
+/**
+ * Extract SVG value from single target object
+ */
+function extractSvgValue(target) {
+    var _a;
+    if (!target)
+        return null;
+    // Check for SvgSelector
+    var selector = target.selector || target;
+    if ((selector === null || selector === void 0 ? void 0 : selector.type) === 'SvgSelector' && selector.value) {
+        return selector.value;
+    }
+    // Check item (sometimes nested)
+    if (((_a = selector === null || selector === void 0 ? void 0 : selector.item) === null || _a === void 0 ? void 0 : _a.type) === 'SvgSelector' && selector.item.value) {
+        return selector.item.value;
+    }
+    return null;
+}
+/**
+ * Convert SVG string to POLYGON geometry
+ * Parses points from SVG path or polygon element
+ */
+function convertSvgToPolygon(svgString) {
+    try {
+        var parser = new DOMParser();
+        var doc = parser.parseFromString(svgString, 'image/svg+xml');
+        if (doc.documentElement.nodeName === 'parsererror') {
+            console.warn('Failed to parse SVG selector:', svgString);
+            return null;
+        }
+        var points = [];
+        // Extract points from polygon elements
+        var polygons = doc.querySelectorAll('polygon');
+        for (var _i = 0, polygons_1 = polygons; _i < polygons_1.length; _i++) {
+            var poly = polygons_1[_i];
+            var pointsAttr = poly.getAttribute('points');
+            if (pointsAttr) {
+                var polyPoints = parsePolygonPoints(pointsAttr);
+                points.push.apply(points, polyPoints);
+            }
+        }
+        // Extract points from path elements (simple conversion, doesn't handle curves)
+        var paths = doc.querySelectorAll('path');
+        for (var _a = 0, paths_1 = paths; _a < paths_1.length; _a++) {
+            var path = paths_1[_a];
+            var d = path.getAttribute('d');
+            if (d) {
+                var pathPoints = parsePathData(d);
+                points.push.apply(points, pathPoints);
+            }
+        }
+        // Extract points from circle/ellipse (approximate as polygon)
+        var circles = doc.querySelectorAll('circle');
+        for (var _b = 0, circles_1 = circles; _b < circles_1.length; _b++) {
+            var circle = circles_1[_b];
+            var cx = parseFloat(circle.getAttribute('cx') || '0');
+            var cy = parseFloat(circle.getAttribute('cy') || '0');
+            var r = parseFloat(circle.getAttribute('r') || '0');
+            var circlePoints = generateCirclePoints(cx, cy, r);
+            points.push.apply(points, circlePoints);
+        }
+        if (points.length === 0) {
+            return null;
+        }
+        return {
+            type: 'POLYGON',
+            points: points,
+        };
+    }
+    catch (e) {
+        console.warn('Failed to convert SVG to polygon:', e);
+        return null;
+    }
+}
+/**
+ * Parse polygon points attribute
+ * Format: "x1,y1 x2,y2 x3,y3"
+ */
+function parsePolygonPoints(pointsStr) {
+    var points = [];
+    var pairs = pointsStr.trim().split(/\s+/);
+    for (var _i = 0, pairs_1 = pairs; _i < pairs_1.length; _i++) {
+        var pair = pairs_1[_i];
+        var _a = pair.split(',').map(function (v) { return parseFloat(v); }), x = _a[0], y = _a[1];
+        if (!isNaN(x) && !isNaN(y)) {
+            points.push([x, y]);
+        }
+    }
+    return points;
+}
+/**
+ * Parse SVG path data (simplified)
+ * Extracts M (moveto) and L (lineto) commands
+ */
+function parsePathData(d) {
+    var points = [];
+    // Simple regex: match M and L commands followed by coordinates
+    var commandRegex = /[ML]\s*([\d.]+)[,\s]+([\d.]+)/g;
+    var match;
+    while ((match = commandRegex.exec(d)) !== null) {
+        var x = parseFloat(match[1]);
+        var y = parseFloat(match[2]);
+        if (!isNaN(x) && !isNaN(y)) {
+            points.push([x, y]);
+        }
+    }
+    return points;
+}
+/**
+ * Generate polygon points approximating a circle
+ */
+function generateCirclePoints(cx, cy, r, numPoints) {
+    if (numPoints === void 0) { numPoints = 8; }
+    var points = [];
+    for (var i = 0; i < numPoints; i++) {
+        var angle = (i / numPoints) * Math.PI * 2;
+        var x = cx + r * Math.cos(angle);
+        var y = cy + r * Math.sin(angle);
+        points.push([x, y]);
+    }
+    return points;
+}
+/**
+ * Extract xywh from annotation target (multiple formats)
+ */
+function extractXywhFromTarget(annotation) {
+    var _a;
+    // Try Manifesto getTarget method
+    if (typeof annotation.getTarget === 'function') {
+        var target_2 = annotation.getTarget();
+        if (typeof target_2 === 'string' && target_2.includes('xywh=')) {
+            return parseXywh(target_2);
+        }
+        // Check raw JSON as fallback
+        var rawOn = (_a = annotation.__jsonld) === null || _a === void 0 ? void 0 : _a.on;
+        if (rawOn) {
+            var xywh = extractXywhFromRawTarget(rawOn);
+            if (xywh)
+                return xywh;
+        }
+    }
+    // Check raw annotation formats (v2 and v3)
+    var target = annotation.target || annotation.on;
+    if (target) {
+        return extractXywhFromRawTarget(target);
+    }
+    return null;
+}
+/**
+ * Extract xywh from raw target object/array
+ */
+function extractXywhFromRawTarget(target) {
+    if (!target)
+        return null;
+    // Handle arrays
+    if (Array.isArray(target)) {
+        for (var _i = 0, target_3 = target; _i < target_3.length; _i++) {
+            var t = target_3[_i];
+            var xywh = extractXywhFromRawTarget(t);
+            if (xywh)
+                return xywh;
+        }
+    }
+    // Handle string targets with xywh
+    if (typeof target === 'string' && target.includes('xywh=')) {
+        return parseXywh(target);
+    }
+    // Handle object with selector
+    if (target.selector) {
+        var sel = target.selector;
+        var item = sel.item || sel;
+        if (item.value && typeof item.value === 'string' && item.value.includes('xywh=')) {
+            return parseXywh(item.value);
+        }
+    }
+    return null;
+}
+/**
+ * Extract annotation body content (text, label, etc)
+ */
+function extractBody(annotation) {
+    var value = '';
+    var isHtml = false;
+    // Try Manifesto getBody method
+    if (typeof annotation.getBody === 'function') {
+        var body = annotation.getBody();
+        if (body && Array.isArray(body)) {
+            var values = [];
+            for (var _i = 0, body_1 = body; _i < body_1.length; _i++) {
+                var b = body_1[_i];
+                var val = b.getValue ? b.getValue() : '';
+                if (val) {
+                    values.push(val);
+                    var format = b.getFormat ? b.getFormat() : '';
+                    if (format === 'text/html' || format === 'application/html') {
+                        isHtml = true;
+                    }
+                }
+            }
+            value = values.join(' ');
+        }
+    }
+    else {
+        // Handle raw JSON body/resource
+        var getText = function (r) {
+            if (!r)
+                return '';
+            return r.chars || r.value || r['cnt:chars'] || '';
+        };
+        var checkHtml = function (r) {
+            if (!r)
+                return false;
+            return r.format === 'text/html' || r.type === 'TextualBody';
+        };
+        if (annotation.resource) {
+            var resources = Array.isArray(annotation.resource) ? annotation.resource : [annotation.resource];
+            value = resources.map(getText).filter(Boolean).join(' ');
+            isHtml = resources.some(checkHtml);
+        }
+        else if (annotation.body) {
+            var bodyArr = Array.isArray(annotation.body) ? annotation.body : [annotation.body];
+            value = bodyArr.map(getText).filter(Boolean).join(' ');
+            isHtml = bodyArr.some(checkHtml);
+        }
+    }
+    // Try to extract label if no body content found
+    if (!value) {
+        if (typeof annotation.getLabel === 'function') {
+            value = annotation.getLabel() || '';
+        }
+        else if (annotation.label) {
+            value = Array.isArray(annotation.label) ? annotation.label.join(' ') : annotation.label;
+        }
+    }
+    return { value: value || 'Annotation', isHtml: isHtml };
+}
+/**
+ * Parse Manifesto/IIIF annotation to internal format
+ */
+export function parseAnnotation(annotation, index, isSearchHit) {
+    if (isSearchHit === void 0) { isSearchHit = false; }
+    var id = getAnnotationId(annotation) || "anno-".concat(index);
+    var geometry = extractGeometry(annotation);
+    // Skip annotations without geometry
+    if (!geometry) {
+        return null;
+    }
+    var body = extractBody(annotation);
+    return {
+        id: id,
+        geometry: geometry,
+        body: body,
+        isSearchHit: isSearchHit,
+    };
+}
+/**
+ * Batch parse annotations
+ */
+export function parseAnnotations(annotations, searchHitIds) {
+    if (searchHitIds === void 0) { searchHitIds = new Set(); }
+    return annotations
+        .map(function (anno, idx) {
+        var isSearchHit = searchHitIds.has(getAnnotationId(anno));
+        return parseAnnotation(anno, idx, isSearchHit);
+    })
+        .filter(function (anno) { return anno !== null; });
+}

package/dist/utils/annotationAdapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/annotationAdapter.test.js

@@ -0,0 +1,91 @@
+import { describe, it, expect } from "vitest";
+import { parseAnnotation } from "./annotationAdapter";
+describe("annotationAdapter", function () {
+    describe("parseAnnotation", function () {
+        it("should correctly parse a simple xywh string target", function () {
+            var annotation = {
+                "@id": "http://example.org/anno1",
+                on: "http://example.org/image1#xywh=10,20,100,200",
+                label: "Test Annotation",
+            };
+            var result = parseAnnotation(annotation, 0);
+            expect(result).not.toBeNull();
+            if (!result)
+                return;
+            expect(result.geometry.type).toBe("RECTANGLE");
+            var geometry = result.geometry;
+            if ("x" in geometry) {
+                expect(geometry).toEqual({
+                    type: "RECTANGLE",
+                    x: 10,
+                    y: 20,
+                    w: 100,
+                    h: 200,
+                });
+            }
+            else {
+                throw new Error("Geometry should be RECTANGLE type with x, y, w, h");
+            }
+        });
+        it("should extract SVG selector geometry", function () {
+            var annotation = {
+                "@id": "http://example.org/anno2",
+                on: {
+                    selector: {
+                        type: "SvgSelector",
+                        value: '<svg><polygon points="10,10 50,10 50,50 10,50" /></svg>',
+                    },
+                },
+            };
+            var result = parseAnnotation(annotation, 1);
+            expect(result).not.toBeNull();
+            if (!result)
+                return;
+            expect(result.geometry.type).toBe("POLYGON");
+            var geometry = result.geometry;
+            if ("points" in geometry) {
+                expect(geometry.points).toHaveLength(4);
+                expect(geometry.points).toEqual([
+                    [10, 10],
+                    [50, 10],
+                    [50, 50],
+                    [10, 50],
+                ]);
+            }
+            else {
+                throw new Error("Geometry should be POLYGON type with points");
+            }
+        });
+        it("should handle Manifesto-style getTarget and getId methods", function () {
+            var mockManifestoAnno = {
+                getId: function () { return "http://example.org/manifesto-anno"; },
+                getTarget: function () { return "http://example.org/canvas1#xywh=5,5,50,50"; },
+                getBody: function () { return [
+                    { getValue: function () { return "Manifesto Body"; }, getFormat: function () { return "text/plain"; } },
+                ]; },
+            };
+            // @ts-ignore - mocking complex object
+            var result = parseAnnotation(mockManifestoAnno, 2);
+            expect(result === null || result === void 0 ? void 0 : result.id).toBe("http://example.org/manifesto-anno");
+            var geometry = result === null || result === void 0 ? void 0 : result.geometry;
+            if (geometry && "x" in geometry) {
+                expect(geometry).toMatchObject({
+                    type: "RECTANGLE",
+                    x: 5,
+                    y: 5,
+                    w: 50,
+                    h: 50,
+                });
+            }
+            expect(result === null || result === void 0 ? void 0 : result.body.value).toBe("Manifesto Body");
+        });
+        it("should return null for invalid annotations with no geometry", function () {
+            var invalidAnno = {
+                "@id": "bad-anno",
+                on: "http://example.org/canvas1", // No media fragment or selector
+            };
+            var result = parseAnnotation(invalidAnno, 3);
+            expect(result).toBeNull();
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triiiceratops",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -18,16 +18,16 @@
   "module": "./dist/index.js",
   "svelte": "./dist/index.js",
   "style": "./dist/triiiceratops.css",
-  "types": "./dist/src/lib/index.d.ts",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/src/lib/index.d.ts",
+      "types": "./dist/index.d.ts",
       "style": "./dist/triiiceratops.css",
       "svelte": "./dist/index.js",
       "import": "./dist/index.js"
     },
     "./plugins/image-manipulation": {
-      "types": "./dist/src/lib/plugins/image-manipulation/index.d.ts",
+      "types": "./dist/plugins/image-manipulation/index.d.ts",
       "svelte": "./dist/plugins/image-manipulation.js",
       "import": "./dist/plugins/image-manipulation.js"
     },
@@ -52,6 +52,7 @@
     "@inlang/paraglide-js": "^2.5.0",
     "@inlang/paraglide-vite": "^1.4.0",
     "@playwright/test": "^1.57.0",
+    "@sveltejs/package": "^2.5.7",
     "@sveltejs/vite-plugin-svelte": "^6.2.1",
     "@tsconfig/svelte": "^5.0.6",
     "@types/node": "^24.10.1",
@@ -78,7 +79,7 @@
   "scripts": {
     "dev": "vite",
     "build": "vite build",
-    "build:lib": "vite build --config vite.config.lib.ts",
+    "build:lib": "svelte-package && vite build --config vite.config.lib.ts",
     "build:element": "vite build --config vite.config.element.ts",
     "build:demo": "vite build --config vite.config.demo.ts",
     "build:consumer": "vite build --config vite.config.demo-consumer.ts",