@pluot/core 0.1.0

package/dist-tsc/3d-view-controls.d.ts

@@ -0,0 +1,17 @@
+export default function createCamera(element: any, options: any): {
+    view: any;
+    element: any;
+    delay: any;
+    rotateSpeed: any;
+    zoomSpeed: any;
+    translateSpeed: any;
+    flipX: boolean;
+    flipY: boolean;
+    modes: any;
+    tick: () => boolean;
+    lookAt: (center: any, eye: any, up: any) => void;
+    rotate: (pitch: any, yaw: any, roll: any) => void;
+    pan: (dx: any, dy: any, dz: any) => void;
+    translate: (dx: any, dy: any, dz: any) => void;
+};
+//# sourceMappingURL=3d-view-controls.d.ts.map

package/dist-tsc/3d-view-controls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"3d-view-controls.d.ts","sourceRoot":"","sources":["../src/3d-view-controls.js"],"names":[],"mappings":"AA8CA;;;;;;;;;;;;;;;EAgOC"}

package/dist-tsc/3d-view-controls.js

@@ -0,0 +1,247 @@
+// License copied from https://github.com/mikolalysenko/3d-view-controls/blob/master/LICENSE
+//
+// The MIT License (MIT)
+//
+// Copyright (c) 2013 Mikola Lysenko
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+// Reference: https://github.com/mikolalysenko/3d-view-controls/blob/0e59c2ae4a891ce3c7bb83aa4291f89d99366037/camera.js
+// TODO: contribute modifications back upstream once things are working.
+import createView from '3d-view';
+import mouseChange from 'mouse-change';
+import mouseWheel from 'mouse-wheel';
+import mouseOffset from 'mouse-event-offset';
+import hasPassive from 'has-passive-events';
+// Updated right-now implementation to avoid `global` usage.
+// Reference: https://github.com/hughsk/right-now/blob/master/browser.js
+const now = performance && performance.now
+    ? function now() {
+        return performance.now();
+    }
+    : Date.now ||
+        function now() {
+            return +new Date();
+        };
+export default function createCamera(element, options) {
+    element = element || document.body;
+    options = options || {};
+    var limits = [0.01, Infinity];
+    if ('distanceLimits' in options) {
+        limits[0] = options.distanceLimits[0];
+        limits[1] = options.distanceLimits[1];
+    }
+    if ('zoomMin' in options) {
+        limits[0] = options.zoomMin;
+    }
+    if ('zoomMax' in options) {
+        limits[1] = options.zoomMax;
+    }
+    var view = createView({
+        center: options.center || [0, 0, 0],
+        up: options.up || [0, 1, 0],
+        eye: options.eye || [0, 0, 10],
+        mode: options.mode || 'orbit',
+        distanceLimits: limits
+    });
+    var pmatrix = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    var distance = 0.0;
+    var width = element.clientWidth;
+    var height = element.clientHeight;
+    var camera = {
+        view: view,
+        element: element,
+        delay: options.delay || 16,
+        rotateSpeed: options.rotateSpeed || 1,
+        zoomSpeed: options.zoomSpeed || 1,
+        translateSpeed: options.translateSpeed || 1,
+        flipX: !!options.flipX,
+        flipY: !!options.flipY,
+        modes: view.modes,
+        tick: function () {
+            var t = now();
+            var delay = this.delay;
+            view.idle(t - delay);
+            view.flush(t - (100 + delay * 2));
+            var ctime = t - 2 * delay;
+            view.recalcMatrix(ctime);
+            var allEqual = true;
+            var matrix = view.computedMatrix;
+            for (var i = 0; i < 16; ++i) {
+                allEqual = allEqual && (pmatrix[i] === matrix[i]);
+                pmatrix[i] = matrix[i];
+            }
+            var sizeChanged = element.clientWidth === width &&
+                element.clientHeight === height;
+            width = element.clientWidth;
+            height = element.clientHeight;
+            if (allEqual) {
+                return !sizeChanged;
+            }
+            distance = Math.exp(view.computedRadius[0]);
+            return true;
+        },
+        lookAt: function (center, eye, up) {
+            view.lookAt(view.lastT(), center, eye, up);
+        },
+        rotate: function (pitch, yaw, roll) {
+            view.rotate(view.lastT(), pitch, yaw, roll);
+        },
+        pan: function (dx, dy, dz) {
+            view.pan(view.lastT(), dx, dy, dz);
+        },
+        translate: function (dx, dy, dz) {
+            view.translate(view.lastT(), dx, dy, dz);
+        }
+    };
+    Object.defineProperties(camera, {
+        matrix: {
+            get: function () {
+                return view.computedMatrix;
+            },
+            set: function (mat) {
+                view.setMatrix(view.lastT(), mat);
+                return view.computedMatrix;
+            },
+            enumerable: true
+        },
+        mode: {
+            get: function () {
+                return view.getMode();
+            },
+            set: function (mode) {
+                view.setMode(mode);
+                return view.getMode();
+            },
+            enumerable: true
+        },
+        center: {
+            get: function () {
+                return view.computedCenter;
+            },
+            set: function (ncenter) {
+                view.lookAt(view.lastT(), ncenter);
+                return view.computedCenter;
+            },
+            enumerable: true
+        },
+        eye: {
+            get: function () {
+                return view.computedEye;
+            },
+            set: function (neye) {
+                view.lookAt(view.lastT(), null, neye);
+                return view.computedEye;
+            },
+            enumerable: true
+        },
+        up: {
+            get: function () {
+                return view.computedUp;
+            },
+            set: function (nup) {
+                view.lookAt(view.lastT(), null, null, nup);
+                return view.computedUp;
+            },
+            enumerable: true
+        },
+        distance: {
+            get: function () {
+                return distance;
+            },
+            set: function (d) {
+                view.setDistance(view.lastT(), d);
+                return d;
+            },
+            enumerable: true
+        },
+        distanceLimits: {
+            get: function () {
+                return view.getDistanceLimits(limits);
+            },
+            set: function (v) {
+                view.setDistanceLimits(v);
+                return v;
+            },
+            enumerable: true
+        }
+    });
+    element.addEventListener('contextmenu', function (ev) {
+        //ev.preventDefault()
+        //return false
+    });
+    var lastX = 0, lastY = 0, lastMods = { shift: false, control: false, alt: false, meta: false };
+    mouseChange(element, handleInteraction);
+    //enable simple touch interactions
+    element.addEventListener('touchstart', function (ev) {
+        var xy = mouseOffset(ev.changedTouches[0], element);
+        handleInteraction(0, xy[0], xy[1], lastMods);
+        handleInteraction(1, xy[0], xy[1], lastMods);
+        ev.preventDefault();
+    }, hasPassive ? { passive: false } : false);
+    element.addEventListener('touchmove', function (ev) {
+        var xy = mouseOffset(ev.changedTouches[0], element);
+        handleInteraction(1, xy[0], xy[1], lastMods);
+        ev.preventDefault();
+    }, hasPassive ? { passive: false } : false);
+    element.addEventListener('touchend', function (ev) {
+        var xy = mouseOffset(ev.changedTouches[0], element);
+        handleInteraction(0, lastX, lastY, lastMods);
+        ev.preventDefault();
+    }, hasPassive ? { passive: false } : false);
+    function handleInteraction(buttons, x, y, mods) {
+        var scale = 1.0 / element.clientHeight;
+        var dx = scale * (x - lastX);
+        var dy = scale * (y - lastY);
+        var flipX = camera.flipX ? 1 : -1;
+        var flipY = camera.flipY ? 1 : -1;
+        var drot = Math.PI * camera.rotateSpeed;
+        var t = now();
+        if (buttons & 1) {
+            if (mods.shift) {
+                view.rotate(t, 0, 0, -dx * drot);
+            }
+            else {
+                view.rotate(t, flipX * drot * dx, -flipY * drot * dy, 0);
+            }
+        }
+        else if (buttons & 2) {
+            view.pan(t, -camera.translateSpeed * dx * distance, camera.translateSpeed * dy * distance, 0);
+        }
+        else if (buttons & 4) {
+            var kzoom = camera.zoomSpeed * dy / window.innerHeight * (t - view.lastT()) * 50.0;
+            view.pan(t, 0, 0, distance * (Math.exp(kzoom) - 1));
+        }
+        lastX = x;
+        lastY = y;
+        lastMods = mods;
+    }
+    mouseWheel(element, function (dx, dy, dz) {
+        var flipX = camera.flipX ? 1 : -1;
+        var flipY = camera.flipY ? 1 : -1;
+        var t = now();
+        if (Math.abs(dx) > Math.abs(dy)) {
+            view.rotate(t, 0, 0, -dx * flipX * Math.PI * camera.rotateSpeed / window.innerWidth);
+        }
+        else {
+            var kzoom = camera.zoomSpeed * flipY * dy / window.innerHeight * (t - view.lastT()) / 100.0;
+            view.pan(t, 0, 0, distance * (Math.exp(kzoom) - 1));
+        }
+    }, true);
+    return camera;
+}

package/dist-tsc/core.d.ts

@@ -0,0 +1,10 @@
+import * as wasm from "pluot";
+import { type LruStore } from "./lru-store.js";
+import type { AsyncReadable } from "zarrita";
+export declare const render_wasm: typeof wasm.render_wasm, pick_wasm: typeof wasm.pick_wasm;
+export declare function initialize(): Promise<any>;
+export declare function getIsWasmReady(): boolean;
+export declare function setStore(store: AsyncReadable, plotId: string): string;
+export declare function setStoreByName(storeName: string, store: AsyncReadable): void;
+export declare function getStore(storeName: string): LruStore<AsyncReadable<unknown>>;
+//# sourceMappingURL=core.d.ts.map

package/dist-tsc/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,OAAO,CAAC;AAC9B,OAAO,EAAO,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,eAAO,MAAQ,WAAW,2BAAE,SAAS,uBAAS,CAAC;AA2D/C,wBAAsB,UAAU,iBAQ/B;AAED,wBAAgB,cAAc,IAAI,OAAO,CAExC;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAGrE;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,QAErE;AAED,wBAAgB,QAAQ,CAAC,SAAS,EAAE,MAAM,oCAEzC"}

package/dist-tsc/core.js

@@ -0,0 +1,71 @@
+import * as wasm from "pluot";
+import { lru } from "./lru-store.js";
+export const { render_wasm, pick_wasm } = wasm;
+// Global stores singleton.
+const stores = {};
+let isInitializedPromise = undefined;
+let isWasmReady = false;
+async function _initialize() {
+    // IMPORTANT: This function should only be executed ONCE.
+    await wasm.default();
+    // This is a hack that allows avoiding putting these functions on `window` or `globalThis`.
+    // It is a workaround for https://github.com/wasm-bindgen/wasm-bindgen/issues/3041
+    // See corresponding code in `bindings.rs`.
+    wasm.set_zarr_imports({
+        zarr_get: async (store_name, key) => {
+            console.log(`zarr_get: store_name=${store_name}, key=${key}`);
+            return stores[store_name].get(`/${key}`);
+        },
+        zarr_get_status: (store_name, key) => {
+            return stores[store_name].getPeek(`/${key}`);
+        },
+        zarr_has: async (store_name, key) => {
+            // console.log(`zarr_has: store_name=${store_name}, key=${key}`);
+            return stores[store_name].get(`/${key}`) !== undefined;
+        },
+        zarr_has_status: (store_name, key) => {
+            return stores[store_name].getPeek(`/${key}`);
+        },
+        zarr_get_range_from_offset: async (store_name, key, offset, length) => {
+            // console.log(`zarr_get_range_from_offset: store_name=${store_name}, key=${key}, offset=${offset}, length=${length}`);
+            return stores[store_name].getRange(`/${key}`, { offset, length });
+        },
+        zarr_get_range_from_offset_status: (store_name, key, offset, length) => {
+            // console.log(`zarr_get_range_from_offset: store_name=${store_name}, key=${key}, offset=${offset}, length=${length}`);
+            return stores[store_name].getRangePeek(`/${key}`, { offset, length });
+        },
+        zarr_get_range_from_end: async (store_name, key, suffix_length) => {
+            // console.log(`zarr_get_range_from_end: store_name=${store_name}, key=${key}, suffix_length=${suffix_length}`);
+            return stores[store_name].getRange(`/${key}`, { suffixLength: suffix_length });
+        },
+        zarr_get_range_from_end_status: (store_name, key, suffix_length) => {
+            // console.log(`zarr_get_range_from_end: store_name=${store_name}, key=${key}, suffix_length=${suffix_length}`);
+            return stores[store_name].getRangePeek(`/${key}`, { suffixLength: suffix_length });
+        },
+    });
+    // Opt-in to better error messages.
+    wasm.set_panic_hook();
+}
+export async function initialize() {
+    // This function is safe to execute multiple times.
+    if (!isInitializedPromise) {
+        isInitializedPromise = _initialize().then(() => { isWasmReady = true; });
+    }
+    else {
+        isInitializedPromise.then(() => { isWasmReady = true; });
+    }
+    return isInitializedPromise;
+}
+export function getIsWasmReady() {
+    return isWasmReady;
+}
+export function setStore(store, plotId) {
+    stores[plotId + "_store"] = lru(store);
+    return plotId + "_store";
+}
+export function setStoreByName(storeName, store) {
+    stores[storeName] = lru(store);
+}
+export function getStore(storeName) {
+    return stores[storeName];
+}

package/dist-tsc/dom-2d-camera.d.ts

@@ -0,0 +1,26 @@
+export default dom2dCamera;
+declare function dom2dCamera(element: any, { distance, target, rotation, isNdc, isFixed, isPan, isPanInverted, panSpeed, isRotate, rotateSpeed, defaultMouseDownMoveAction, mouseDownMoveModKey, isZoom, zoomSpeed, viewCenter, scaleBounds, translationBounds, onKeyDown, onKeyUp, onMouseDown, onMouseUp, onMouseMove, onWheel, aspectRatioMode, aspectRatioAlignmentMode, }?: {
+    distance?: number | undefined;
+    target?: number[] | undefined;
+    rotation?: number | undefined;
+    isNdc?: boolean | undefined;
+    isFixed?: boolean | undefined;
+    isPan?: boolean | undefined;
+    isPanInverted?: boolean[] | undefined;
+    panSpeed?: number | undefined;
+    isRotate?: boolean | undefined;
+    rotateSpeed?: number | undefined;
+    defaultMouseDownMoveAction?: string | undefined;
+    mouseDownMoveModKey?: string | undefined;
+    isZoom?: boolean | undefined;
+    zoomSpeed?: number | undefined;
+    onKeyDown?: (() => void) | undefined;
+    onKeyUp?: (() => void) | undefined;
+    onMouseDown?: (() => void) | undefined;
+    onMouseUp?: (() => void) | undefined;
+    onMouseMove?: (() => void) | undefined;
+    onWheel?: (() => void) | undefined;
+    aspectRatioMode?: string | undefined;
+    aspectRatioAlignmentMode?: string | undefined;
+}): any;
+//# sourceMappingURL=dom-2d-camera.d.ts.map

package/dist-tsc/dom-2d-camera.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom-2d-camera.d.ts","sourceRoot":"","sources":["../src/dom-2d-camera.js"],"names":[],"mappings":";AAoCA;;;;;;;;;;;;;;;;;;;;;;;QAkZC"}