triiiceratops 0.9.1 → 0.9.3

package/dist/index-bundle.d.ts

@@ -0,0 +1,2 @@
+import '../app.css';
+export * from './index';

package/dist/index-bundle.js

@@ -0,0 +1,2 @@
+import '../app.css';
+export * from './index';

package/dist/plugins/image-manipulation/ImageManipulationPlugin.svelte.js

@@ -1,103 +1,70 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 import Sliders from 'phosphor-svelte/lib/Sliders';
 import { BasePlugin } from '../../types/plugin';
 import { applyFilters, clearFilters, hasActiveFilters } from './filters';
 import { DEFAULT_FILTERS } from './types';
 import ImageManipulationPanel from './ImageManipulationPanel.svelte';
 import { m } from '../../state/i18n.svelte';
-var ImageManipulationPlugin = /** @class */ (function (_super) {
-    __extends(ImageManipulationPlugin, _super);
-    function ImageManipulationPlugin() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.id = 'image-manipulation';
-        _this.name = 'Image Manipulation';
-        _this.version = '1.0.0';
-        // Reactive state using Svelte 5 runes
-        _this._panelOpen = $state(false);
-        _this._filters = $state(__assign({}, DEFAULT_FILTERS));
-        _this.osd = null;
-        return _this;
-    }
-    ImageManipulationPlugin.prototype.onRegister = function (context) {
-        var _this = this;
-        _super.prototype.onRegister.call(this, context);
+export class ImageManipulationPlugin extends BasePlugin {
+    id = 'image-manipulation';
+    name = 'Image Manipulation';
+    version = '1.0.0';
+    // Reactive state using Svelte 5 runes
+    _panelOpen = $state(false);
+    _filters = $state({ ...DEFAULT_FILTERS });
+    osd = null;
+    onRegister(context) {
+        super.onRegister(context);
         // Register menu button
         context.registerMenuButton({
-            id: "".concat(this.id, ":toggle"),
+            id: `${this.id}:toggle`,
             icon: Sliders,
             get tooltip() {
                 return m.image_adjustments();
             },
-            onClick: function () { return _this.togglePanel(); },
-            isActive: function () { return _this._panelOpen; },
+            onClick: () => this.togglePanel(),
+            isActive: () => this._panelOpen,
             activeClass: 'btn-secondary',
             order: 50,
         });
         // Register panel
         context.registerPanel({
-            id: "".concat(this.id, ":panel"),
+            id: `${this.id}:panel`,
             component: ImageManipulationPanel,
             position: 'left',
-            isVisible: function () { return _this._panelOpen; },
+            isVisible: () => this._panelOpen,
             props: {
                 filters: this._filters,
-                onFilterChange: function (f) { return _this.setFilters(f); },
-                onReset: function () { return _this.resetFilters(); },
-                onClose: function () { return _this.togglePanel(); },
+                onFilterChange: (f) => this.setFilters(f),
+                onReset: () => this.resetFilters(),
+                onClose: () => this.togglePanel(),
             },
         });
-    };
-    ImageManipulationPlugin.prototype.onViewerReady = function (viewer) {
-        var _this = this;
+    }
+    onViewerReady(viewer) {
         this.osd = viewer;
         // Apply existing filters if any
         if (hasActiveFilters(this._filters)) {
             applyFilters(viewer, this._filters);
         }
         // Re-apply filters when new images unlock (canvas change)
-        this.osd.addHandler('open', function () {
-            if (_this.osd && hasActiveFilters(_this._filters)) {
-                applyFilters(_this.osd, _this._filters);
+        this.osd.addHandler('open', () => {
+            if (this.osd && hasActiveFilters(this._filters)) {
+                applyFilters(this.osd, this._filters);
             }
         });
-    };
-    ImageManipulationPlugin.prototype.onDestroy = function () {
+    }
+    onDestroy() {
         if (this.osd) {
             clearFilters(this.osd);
         }
         this.osd = null;
-        _super.prototype.onDestroy.call(this);
-    };
+        super.onDestroy();
+    }
     // Public API
-    ImageManipulationPlugin.prototype.togglePanel = function () {
+    togglePanel() {
         this._panelOpen = !this._panelOpen;
-    };
-    ImageManipulationPlugin.prototype.setFilters = function (filters) {
+    }
+    setFilters(filters) {
         // Mutate properties to maintain reference for bound props
         this._filters.brightness = filters.brightness;
         this._filters.contrast = filters.contrast;
@@ -107,16 +74,14 @@ var ImageManipulationPlugin = /** @class */ (function (_super) {
         if (this.osd) {
             applyFilters(this.osd, filters);
         }
-    };
-    ImageManipulationPlugin.prototype.resetFilters = function () {
+    }
+    resetFilters() {
         Object.assign(this._filters, DEFAULT_FILTERS);
         if (this.osd) {
             clearFilters(this.osd);
         }
-    };
-    ImageManipulationPlugin.prototype.getFilters = function () {
-        return __assign({}, this._filters);
-    };
-    return ImageManipulationPlugin;
-}(BasePlugin));
-export { ImageManipulationPlugin };
+    }
+    getFilters() {
+        return { ...this._filters };
+    }
+}

package/dist/plugins/image-manipulation/filters.js

@@ -3,20 +3,19 @@
  * CSS filters are GPU-accelerated and work without modifying OSD internals.
  */
 export function applyFilters(viewer, filters) {
-    var _a;
     // OSD uses either canvas or webgl drawer
-    var canvas = (_a = viewer.drawer) === null || _a === void 0 ? void 0 : _a.canvas;
+    const canvas = viewer.drawer?.canvas;
     if (!canvas)
         return;
-    var parts = [];
+    const parts = [];
     if (filters.brightness !== 100) {
-        parts.push("brightness(".concat(filters.brightness / 100, ")"));
+        parts.push(`brightness(${filters.brightness / 100})`);
     }
     if (filters.contrast !== 100) {
-        parts.push("contrast(".concat(filters.contrast / 100, ")"));
+        parts.push(`contrast(${filters.contrast / 100})`);
     }
     if (filters.saturation !== 100) {
-        parts.push("saturate(".concat(filters.saturation / 100, ")"));
+        parts.push(`saturate(${filters.saturation / 100})`);
     }
     if (filters.invert) {
         parts.push('invert(1)');
@@ -30,8 +29,7 @@ export function applyFilters(viewer, filters) {
  * Remove all filters from the canvas.
  */
 export function clearFilters(viewer) {
-    var _a;
-    var canvas = (_a = viewer.drawer) === null || _a === void 0 ? void 0 : _a.canvas;
+    const canvas = viewer.drawer?.canvas;
     if (canvas) {
         canvas.style.filter = 'none';
     }

package/dist/plugins/image-manipulation/types.js

@@ -1,4 +1,4 @@
-export var DEFAULT_FILTERS = {
+export const DEFAULT_FILTERS = {
     brightness: 100,
     contrast: 100,
     saturation: 100,

package/dist/state/i18n.svelte.d.ts

@@ -1,4 +1,5 @@
+import * as messages from "../paraglide/messages.js";
 export declare const language: {
-    readonly current: any;
+    readonly current: "en" | "de";
 };
-export declare const m: any;
+export declare const m: typeof messages;

package/dist/state/i18n.svelte.js

@@ -1,16 +1,16 @@
 import * as messages from "../paraglide/messages.js";
 import { languageTag, onSetLanguageTag } from "../paraglide/runtime.js";
-var tag = $state(languageTag());
-onSetLanguageTag(function (newTag) {
+let tag = $state(languageTag());
+onSetLanguageTag((newTag) => {
     tag = newTag;
 });
-export var language = {
+export const language = {
     get current() {
         return tag;
     }
 };
-export var m = new Proxy(messages, {
-    get: function (target, prop, receiver) {
+export const m = new Proxy(messages, {
+    get(target, prop, receiver) {
         // Register dependency by accessing the signal
         tag;
         return Reflect.get(target, prop, receiver);

package/dist/state/manifests.svelte.js

@@ -1,173 +1,103 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
+import * as manifesto from "manifesto.js";
+export class ManifestsState {
+    manifests = $state({});
+    constructor() { }
+    async fetchManifest(manifestId) {
+        if (this.manifests[manifestId]) {
+            return; // Already fetched or fetching
+        }
+        this.manifests[manifestId] = { isFetching: true };
+        try {
+            const response = await fetch(manifestId);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
             }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+            const json = await response.json();
+            const manifestoObject = manifesto.parseManifest(json);
+            this.manifests[manifestId] = {
+                json,
+                manifesto: manifestoObject,
+                isFetching: false,
+            };
+        }
+        catch (error) {
+            this.manifests[manifestId] = { error: error.message, isFetching: false };
+        }
     }
-};
-import * as manifesto from "manifesto.js";
-var ManifestsState = /** @class */ (function () {
-    function ManifestsState() {
-        this.manifests = $state({});
+    getManifest(manifestId) {
+        const entry = this.manifests[manifestId];
+        return entry?.manifesto;
     }
-    ManifestsState.prototype.fetchManifest = function (manifestId) {
-        return __awaiter(this, void 0, void 0, function () {
-            var response, json, manifestoObject, error_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (this.manifests[manifestId]) {
-                            return [2 /*return*/]; // Already fetched or fetching
-                        }
-                        this.manifests[manifestId] = { isFetching: true };
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 4, , 5]);
-                        return [4 /*yield*/, fetch(manifestId)];
-                    case 2:
-                        response = _a.sent();
-                        if (!response.ok) {
-                            throw new Error("HTTP error! status: ".concat(response.status));
-                        }
-                        return [4 /*yield*/, response.json()];
-                    case 3:
-                        json = _a.sent();
-                        manifestoObject = manifesto.parseManifest(json);
-                        this.manifests[manifestId] = {
-                            json: json,
-                            manifesto: manifestoObject,
-                            isFetching: false,
-                        };
-                        return [3 /*break*/, 5];
-                    case 4:
-                        error_1 = _a.sent();
-                        this.manifests[manifestId] = { error: error_1.message, isFetching: false };
-                        return [3 /*break*/, 5];
-                    case 5: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    ManifestsState.prototype.getManifest = function (manifestId) {
-        var entry = this.manifests[manifestId];
-        return entry === null || entry === void 0 ? void 0 : entry.manifesto;
-    };
-    ManifestsState.prototype.fetchAnnotationList = function (url) {
-        return __awaiter(this, void 0, void 0, function () {
-            var response, data, e_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (this.manifests[url])
-                            return [2 /*return*/]; // Already fetched or fetching
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 6, , 7]);
-                        return [4 /*yield*/, fetch(url)];
-                    case 2:
-                        response = _a.sent();
-                        if (!response.ok) return [3 /*break*/, 4];
-                        return [4 /*yield*/, response.json()];
-                    case 3:
-                        data = _a.sent();
-                        this.manifests[url] = { json: data };
-                        return [3 /*break*/, 5];
-                    case 4:
-                        console.error("Failed to fetch annotation list: ".concat(url));
-                        _a.label = 5;
-                    case 5: return [3 /*break*/, 7];
-                    case 6:
-                        e_1 = _a.sent();
-                        console.error("Error fetching annotation list: ".concat(url), e_1);
-                        return [3 /*break*/, 7];
-                    case 7: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    ManifestsState.prototype.getCanvases = function (manifestId) {
-        var m = this.getManifest(manifestId);
+    async fetchAnnotationList(url) {
+        if (this.manifests[url])
+            return; // Already fetched or fetching
+        try {
+            const response = await fetch(url);
+            if (response.ok) {
+                const data = await response.json();
+                this.manifests[url] = { json: data };
+            }
+            else {
+                console.error(`Failed to fetch annotation list: ${url}`);
+            }
+        }
+        catch (e) {
+            console.error(`Error fetching annotation list: ${url}`, e);
+        }
+    }
+    getCanvases(manifestId) {
+        const m = this.getManifest(manifestId);
         if (!m) {
             return [];
         }
-        var sequences = m.getSequences();
+        const sequences = m.getSequences();
         if (!sequences || !sequences.length)
             return [];
-        var canvases = sequences[0].getCanvases();
+        const canvases = sequences[0].getCanvases();
         return canvases;
-    };
-    ManifestsState.prototype.getAnnotations = function (manifestId, canvasId) {
-        var m = this.getManifest(manifestId);
+    }
+    getAnnotations(manifestId, canvasId) {
+        const m = this.getManifest(manifestId);
         if (!m)
             return [];
-        var canvas = m.getSequences()[0].getCanvasById(canvasId);
+        const canvas = m.getSequences()[0].getCanvasById(canvasId);
         if (!canvas)
             return [];
-        var annos = this.manualGetAnnotations(manifestId, canvasId);
+        const annos = this.manualGetAnnotations(manifestId, canvasId);
         return annos;
-    };
+    }
     // We can refactor this to use Manifesto's resource handling later if needed.
-    ManifestsState.prototype.manualGetAnnotations = function (manifestId, canvasId) {
-        var _this = this;
-        var manifestoObject = this.getManifest(manifestId);
+    manualGetAnnotations(manifestId, canvasId) {
+        const manifestoObject = this.getManifest(manifestId);
         if (!manifestoObject)
             return [];
-        var canvas = manifestoObject.getSequences()[0].getCanvasById(canvasId);
+        const canvas = manifestoObject.getSequences()[0].getCanvasById(canvasId);
         if (!canvas)
             return [];
         // Manifesto wraps the JSON. We can access the underlying JSON via canvas.__jsonld
         // Or better, use canvas.getContent() if it works, but for external lists manual fetch is robust.
-        var canvasJson = canvas.__jsonld;
-        var annotations = [];
+        const canvasJson = canvas.__jsonld;
+        let annotations = [];
         // Helper to parse list using Manifesto
-        var parseList = function (listJson) {
+        const parseList = (listJson) => {
             // manifesto.create is not available in 4.3.0 or not exported nicely?
             // Just return raw resources.
             return listJson.resources || listJson.items || [];
         };
         // IIIF v2 otherContent
         if (canvasJson.otherContent) {
-            canvasJson.otherContent.forEach(function (content) {
-                var id = content["@id"] || content.id;
+            canvasJson.otherContent.forEach((content) => {
+                const id = content["@id"] || content.id;
                 if (id && !content.resources) {
-                    var externalList = _this.manifests[id];
+                    const externalList = this.manifests[id];
                     if (externalList) {
                         if (externalList.json) {
-                            var parsed = parseList(externalList.json);
-                            annotations.push.apply(annotations, parsed);
+                            const parsed = parseList(externalList.json);
+                            annotations.push(...parsed);
                         }
                     }
                     else {
-                        _this.fetchAnnotationList(id);
+                        this.fetchAnnotationList(id);
                     }
                 }
                 else if (content.resources) {
@@ -177,34 +107,32 @@ var ManifestsState = /** @class */ (function () {
                     // Let's rely on the robust parsing I added to Overlay for raw/mixed.
                     // But the user wants library usage.
                     // const r = manifesto.create(content); // might work?
-                    annotations.push.apply(annotations, content.resources);
+                    annotations.push(...content.resources);
                 }
             });
         }
         // IIIF v3 annotations
         if (canvasJson.annotations) {
-            canvasJson.annotations.forEach(function (content) {
-                var id = content.id || content["@id"];
+            canvasJson.annotations.forEach((content) => {
+                const id = content.id || content["@id"];
                 if (id && !content.items) {
-                    var externalList = _this.manifests[id];
+                    const externalList = this.manifests[id];
                     if (externalList) {
                         if (externalList.json) {
-                            var parsed = parseList(externalList.json);
-                            annotations.push.apply(annotations, parsed);
+                            const parsed = parseList(externalList.json);
+                            annotations.push(...parsed);
                         }
                     }
                     else {
-                        _this.fetchAnnotationList(id);
+                        this.fetchAnnotationList(id);
                     }
                 }
                 else if (content.items) {
-                    annotations.push.apply(annotations, content.items);
+                    annotations.push(...content.items);
                 }
             });
         }
         return annotations;
-    };
-    return ManifestsState;
-}());
-export { ManifestsState };
-export var manifestsState = new ManifestsState();
+    }
+}
+export const manifestsState = new ManifestsState();