@insync-stageplayer/measurements 0.4.8 → 0.4.13

package/lib/hooks/useTimedMeasurementData.js

@@ -1,124 +1,124 @@
-import { useEffect, useState, useMemo } from "react";
-import { filter, groupBy, map, scan, switchMap, toArray } from "rxjs/operators";
-import { useMeasurements } from "./useMeasurements";
-import { from } from "rxjs";
-import { useSelector } from "react-redux";
-import { useMeasurementsModule } from "./useMeasurementsModule";
-/**
- * Returns measurement data for a time. The current time is provided by options.timer which is
- * an instance of a Timer defined in @insync-stageplayer/time.
- * @param options
- * @returns
- */
-export const useTimedMeasurementData = (options) => {
-    const { client, selector } = useMeasurementsModule();
-    const { rows, measurements: measurementIds, limit, timer, unit } = options;
-    /**
-     * Create a map with files, we need these to get the start time of a file. So that we can create a timer with an offset.
-     */
-    const files = useSelector((s) => selector(s).files);
-    const filesById = useMemo(() => {
-        return files.reduce((acc, c) => (Object.assign(Object.assign({}, acc), { [c.path]: c })), {});
-    }, [files]);
-    /**
-     * The scale of the model for which the measurement data was recorded.
-     */
-    const measurementScale = useSelector((s) => selector(s).measurementScale);
-    const { measurements, loading, didInvalidate } = useMeasurements();
-    const [state, setState] = useState({
-        loading: false,
-    });
-    useEffect(() => {
-        if (loading || didInvalidate)
-            return;
-        const observable$ = from(measurements).pipe(filter((m) => measurementIds.indexOf(m.id) !== -1), 
-        // Request are on a per file basis.
-        groupBy((m) => m.file), switchMap((grouped) => grouped.pipe(toArray(), switchMap((measurements) => {
-            //
-            // The measurements in the app have an ID like (ROOT:/32322/WAVE) that
-            // is incompatible with the IDs of the API (just WAVE). So we keep track of a map
-            // that contains the mapping from the IDs used by the API to the ones used in the
-            // app so we can map them back later.
-            //
-            const nameIdMap = measurements.reduce((acc, c) => {
-                return Object.assign(Object.assign({}, acc), { [c.name]: c.id });
-            }, {});
-            // Retrieve the file in which theses measurements are stored.
-            const fileObj = filesById[grouped.key];
-            const start = fileObj.timing.start;
-            // We'll map the timer to have an offset and for the time to be scaled using the measurement scale.
-            const time$ = timer.state.pipe(map((timerState) => {
-                const offset = timerState.time - start;
-                const time = offset * Math.sqrt(measurementScale);
-                return time;
-            }));
-            return client
-                .createMeasurementDataObservable({
-                rows,
-                limit,
-                measurements: measurements.map((m) => m.name),
-                time$,
-                unit,
-                file: grouped.key,
-            })
-                .pipe(
-            // This is where we map back the IDs
-            map((v) => {
-                var _a;
-                return (Object.assign(Object.assign({}, v), { 
-                    // We add a file property so we can retrieve for which file this loading is.
-                    file: grouped.key, data: Object.assign(Object.assign({}, v.data), { measurementData: ((_a = v.data) === null || _a === void 0 ? void 0 : _a.measurementData)
-                            ? Object.keys(v.data.measurementData).reduce((acc, c) => {
-                                var _a, _b;
-                                if ((_a = v.data) === null || _a === void 0 ? void 0 : _a.measurementData[c]) {
-                                    return Object.assign(Object.assign({}, acc), { [nameIdMap[c]]: (_b = v.data) === null || _b === void 0 ? void 0 : _b.measurementData[c] });
-                                }
-                                return acc;
-                            }, {})
-                            : undefined }) }));
-            }));
-        }))), 
-        // We accumulate the data from all the files here.
-        scan((acc, c) => {
-            var _a, _b;
-            const loadingFiles = c.loading
-                ? [...acc.loadingFiles, c.file]
-                : acc.loadingFiles.filter((f) => f !== c.file);
-            return {
-                loadingFiles,
-                data: Object.assign(Object.assign(Object.assign({}, acc.data), c.data), { 
-                    // We'll only return the new range if all files have finished loading.
-                    range: loadingFiles.length > 0 || !c.data.range
-                        ? acc.data.range
-                        : c.data.range, measurementData: Object.assign(Object.assign({}, (_a = acc.data) === null || _a === void 0 ? void 0 : _a.measurementData), (_b = c.data) === null || _b === void 0 ? void 0 : _b.measurementData) }),
-                error: c.error,
-            };
-        }, {
-            loadingFiles: [],
-            data: {},
-        }), 
-        // We should not retrieve measurement data if still loading. So we clear the data here if some file is still loading.
-        map((state) => {
-            const loading = state.loadingFiles.length > 0;
-            return Object.assign(Object.assign({}, state), { loading, data: state.data });
-        }));
-        const subscription = observable$.subscribe(setState);
-        return () => {
-            subscription.unsubscribe();
-        };
-    }, [
-        measurements,
-        client,
-        measurementIds,
-        rows,
-        limit,
-        filesById,
-        timer,
-        measurementScale,
-        unit,
-        loading,
-        didInvalidate,
-    ]);
-    return state;
-};
+import { useEffect, useState, useMemo } from "react";
+import { filter, groupBy, map, scan, switchMap, toArray } from "rxjs/operators";
+import { useMeasurements } from "./useMeasurements";
+import { from } from "rxjs";
+import { useSelector } from "react-redux";
+import { useMeasurementsModule } from "./useMeasurementsModule";
+/**
+ * Returns measurement data for a time. The current time is provided by options.timer which is
+ * an instance of a Timer defined in @insync-stageplayer/time.
+ * @param options
+ * @returns
+ */
+export const useTimedMeasurementData = (options) => {
+    const { client, selector } = useMeasurementsModule();
+    const { rows, measurements: measurementIds, limit, timer, unit } = options;
+    /**
+     * Create a map with files, we need these to get the start time of a file. So that we can create a timer with an offset.
+     */
+    const files = useSelector((s) => selector(s).files);
+    const filesById = useMemo(() => {
+        return files.reduce((acc, c) => (Object.assign(Object.assign({}, acc), { [c.path]: c })), {});
+    }, [files]);
+    /**
+     * The scale of the model for which the measurement data was recorded.
+     */
+    const measurementScale = useSelector((s) => selector(s).measurementScale);
+    const { measurements, loading, didInvalidate } = useMeasurements();
+    const [state, setState] = useState({
+        loading: false,
+    });
+    useEffect(() => {
+        if (loading || didInvalidate)
+            return;
+        const observable$ = from(measurements).pipe(filter((m) => measurementIds.indexOf(m.id) !== -1), 
+        // Request are on a per file basis.
+        groupBy((m) => m.file), switchMap((grouped) => grouped.pipe(toArray(), switchMap((measurements) => {
+            //
+            // The measurements in the app have an ID like (ROOT:/32322/WAVE) that
+            // is incompatible with the IDs of the API (just WAVE). So we keep track of a map
+            // that contains the mapping from the IDs used by the API to the ones used in the
+            // app so we can map them back later.
+            //
+            const nameIdMap = measurements.reduce((acc, c) => {
+                return Object.assign(Object.assign({}, acc), { [c.name]: c.id });
+            }, {});
+            // Retrieve the file in which theses measurements are stored.
+            const fileObj = filesById[grouped.key];
+            const start = fileObj.timing.start;
+            // We'll map the timer to have an offset and for the time to be scaled using the measurement scale.
+            const time$ = timer.state.pipe(map((timerState) => {
+                const offset = timerState.time - start;
+                const time = offset * Math.sqrt(measurementScale);
+                return time;
+            }));
+            return client
+                .createMeasurementDataObservable({
+                rows,
+                limit,
+                measurements: measurements.map((m) => m.name),
+                time$,
+                unit,
+                file: grouped.key,
+            })
+                .pipe(
+            // This is where we map back the IDs
+            map((v) => {
+                var _a;
+                return (Object.assign(Object.assign({}, v), { 
+                    // We add a file property so we can retrieve for which file this loading is.
+                    file: grouped.key, data: Object.assign(Object.assign({}, v.data), { measurementData: ((_a = v.data) === null || _a === void 0 ? void 0 : _a.measurementData)
+                            ? Object.keys(v.data.measurementData).reduce((acc, c) => {
+                                var _a, _b;
+                                if ((_a = v.data) === null || _a === void 0 ? void 0 : _a.measurementData[c]) {
+                                    return Object.assign(Object.assign({}, acc), { [nameIdMap[c]]: (_b = v.data) === null || _b === void 0 ? void 0 : _b.measurementData[c] });
+                                }
+                                return acc;
+                            }, {})
+                            : undefined }) }));
+            }));
+        }))), 
+        // We accumulate the data from all the files here.
+        scan((acc, c) => {
+            var _a, _b;
+            const loadingFiles = c.loading
+                ? [...acc.loadingFiles, c.file]
+                : acc.loadingFiles.filter((f) => f !== c.file);
+            return {
+                loadingFiles,
+                data: Object.assign(Object.assign(Object.assign({}, acc.data), c.data), { 
+                    // We'll only return the new range if all files have finished loading.
+                    range: loadingFiles.length > 0 || !c.data.range
+                        ? acc.data.range
+                        : c.data.range, measurementData: Object.assign(Object.assign({}, (_a = acc.data) === null || _a === void 0 ? void 0 : _a.measurementData), (_b = c.data) === null || _b === void 0 ? void 0 : _b.measurementData) }),
+                error: c.error,
+            };
+        }, {
+            loadingFiles: [],
+            data: {},
+        }), 
+        // We should not retrieve measurement data if still loading. So we clear the data here if some file is still loading.
+        map((state) => {
+            const loading = state.loadingFiles.length > 0;
+            return Object.assign(Object.assign({}, state), { loading, data: state.data });
+        }));
+        const subscription = observable$.subscribe(setState);
+        return () => {
+            subscription.unsubscribe();
+        };
+    }, [
+        measurements,
+        client,
+        measurementIds,
+        rows,
+        limit,
+        filesById,
+        timer,
+        measurementScale,
+        unit,
+        loading,
+        didInvalidate,
+    ]);
+    return state;
+};
 //# sourceMappingURL=useTimedMeasurementData.js.map

package/lib/hooks/useWindowedMeasurementData.d.ts

@@ -1,26 +1,26 @@
-import { AsyncState } from "../AsyncSubject";
-import { CreateWindowedMeasurementDataObservableArgs } from "../client";
-import { MeasurementsTypes } from "../types";
-import { NumberRange } from "@insync-stageplayer/common";
-import { Timer } from "@insync-stageplayer/time";
-/**
- * The options for the useWindowedMeasurementData
- */
-export declare type UseWindowedMeasurementDataOptions = Omit<CreateWindowedMeasurementDataObservableArgs, "file" | "time$"> & {
-    /**
-     * Observable Timer (from @insync-stageplayer/time) that emits times.
-     */
-    timer: Timer;
-};
-declare type StateValue = {
-    measurementData: MeasurementsTypes.DataMap;
-    range: NumberRange;
-};
-/**
- * A hook that returns windowed data.
- * @param options
- * @returns
- */
-export declare const useWindowedMeasurementData: (options: UseWindowedMeasurementDataOptions) => AsyncState<StateValue>;
-export {};
+import { AsyncState } from "../AsyncSubject";
+import { CreateWindowedMeasurementDataObservableArgs } from "../client";
+import { MeasurementsTypes } from "../types";
+import { NumberRange } from "@insync-stageplayer/common";
+import { Timer } from "@insync-stageplayer/time";
+/**
+ * The options for the useWindowedMeasurementData
+ */
+export declare type UseWindowedMeasurementDataOptions = Omit<CreateWindowedMeasurementDataObservableArgs, "file" | "time$"> & {
+    /**
+     * Observable Timer (from @insync-stageplayer/time) that emits times.
+     */
+    timer: Timer;
+};
+declare type StateValue = {
+    measurementData: MeasurementsTypes.DataMap;
+    range: NumberRange;
+};
+/**
+ * A hook that returns windowed data.
+ * @param options
+ * @returns
+ */
+export declare const useWindowedMeasurementData: (options: UseWindowedMeasurementDataOptions) => AsyncState<StateValue>;
+export {};
 //# sourceMappingURL=useWindowedMeasurementData.d.ts.map

package/lib/hooks/useWindowedMeasurementData.js

@@ -1,120 +1,120 @@
-import { useEffect, useState, useMemo } from "react";
-import { useMeasurements } from "./useMeasurements";
-import { from } from "rxjs";
-import { map, filter, groupBy, switchMap, toArray, scan } from "rxjs/operators";
-import { useSelector } from "react-redux";
-import { useMeasurementsModule } from "./useMeasurementsModule";
-/**
- * A hook that returns windowed data.
- * @param options
- * @returns
- */
-export const useWindowedMeasurementData = (options) => {
-    const { rows, measurements: measurementIds, visibleWindow, unit, timer, } = options;
-    const { client, selector } = useMeasurementsModule();
-    // The timer will give back timestamps in "realtime" in microseconds, so for example: 1500635719101123 (Fri Jul 21 2017 13:15:19 GMT+0200 (Central European Summer Time) {}).
-    // We will need to use the measurement scale and the start of the measurementfiles to calculate the offset time for a given measurement.
-    const measurementScale = useSelector((s) => selector(s).measurementScale);
-    const { measurements } = useMeasurements();
-    const [state, setState] = useState({
-        loading: false,
-    });
-    /**
-     * Create a map with files, we need these to get the start time of a file. So that we can create a timer with an offset.
-     */
-    const files = useSelector((s) => selector(s).files);
-    const filesById = useMemo(() => {
-        return files.reduce((acc, c) => (Object.assign(Object.assign({}, acc), { [c.path]: c })), {});
-    }, [files]);
-    useEffect(() => {
-        const observable$ = from(measurements).pipe(filter((m) => measurementIds.indexOf(m.id) !== -1), 
-        // Request are on a per file basis.
-        groupBy((m) => m.file), switchMap((grouped) => grouped.pipe(toArray(), switchMap((measurements) => {
-            //
-            // The measurements in the app have an ID like (ROOT:/32322/WAVE) that
-            // is incompatible with the IDs of the API (just WAVE). So we keep track of a map
-            // that contains the mapping from the IDs used by the API to the ones used in the
-            // app so we can map them back later.
-            //
-            const nameIdMap = measurements.reduce((acc, c) => {
-                return Object.assign(Object.assign({}, acc), { [c.name]: c.id });
-            }, {});
-            // Retrieve the file in which theses measurements are stored.
-            const fileObj = filesById[grouped.key];
-            const start = fileObj.timing.start;
-            // We'll map the timer to have an offset and for the time to be scaled using the measurement scale.
-            const time$ = timer.state.pipe(map((timerState) => {
-                const offsetTime = timerState.time - start;
-                const scaledOffsetTime = offsetTime * Math.sqrt(measurementScale);
-                return scaledOffsetTime;
-            }));
-            return client
-                .createWindowedMeasurementDataObservable({
-                rows,
-                visibleWindow,
-                measurements: measurements.map((m) => m.name),
-                // times are on a per-file basis, so this will use the offset of the file
-                time$,
-                file: grouped.key,
-                unit,
-            })
-                .pipe(
-            // This is where we map back the IDs
-            map((v) => {
-                var _a;
-                return (Object.assign(Object.assign({}, v), { 
-                    // We add a file property so we can retrieve for which file this loading is.
-                    file: grouped.key, data: Object.assign(Object.assign({}, v.data), { measurementData: ((_a = v.data) === null || _a === void 0 ? void 0 : _a.measurementData)
-                            ? Object.keys(v.data.measurementData).reduce((acc, c) => {
-                                var _a, _b;
-                                if ((_a = v.data) === null || _a === void 0 ? void 0 : _a.measurementData[c]) {
-                                    return Object.assign(Object.assign({}, acc), { [nameIdMap[c]]: (_b = v.data) === null || _b === void 0 ? void 0 : _b.measurementData[c] });
-                                }
-                                return acc;
-                            }, {})
-                            : undefined }) }));
-            }));
-        }))), 
-        // We accumulate the data from all the files here.
-        scan((acc, c) => {
-            var _a, _b;
-            const loadingFiles = c.loading
-                ? [...acc.loadingFiles, c.file]
-                : acc.loadingFiles.filter((f) => f !== c.file);
-            return {
-                loadingFiles,
-                data: Object.assign(Object.assign(Object.assign({}, acc.data), c.data), { 
-                    // We'll only return the new range if all files have finished loading.
-                    range: loadingFiles.length > 0 || !c.data.range
-                        ? acc.data.range
-                        : c.data.range, measurementData: Object.assign(Object.assign({}, (_a = acc.data) === null || _a === void 0 ? void 0 : _a.measurementData), (_b = c.data) === null || _b === void 0 ? void 0 : _b.measurementData) }),
-                error: c.error,
-            };
-        }, {
-            loadingFiles: [],
-            data: {},
-        }), 
-        // We should not retrieve measurement data if still loading. So we clear the data here if some file is still loading.
-        map((state) => {
-            const loading = state.loadingFiles.length > 0;
-            return Object.assign(Object.assign({}, state), { loading, data: state.data });
-        }));
-        const subscription = observable$.subscribe(setState);
-        return () => {
-            subscription.unsubscribe();
-        };
-    }, [
-        client,
-        measurementIds,
-        measurements,
-        options,
-        rows,
-        visibleWindow,
-        measurementScale,
-        unit,
-        timer.state,
-        filesById,
-    ]);
-    return state;
-};
+import { useEffect, useState, useMemo } from "react";
+import { useMeasurements } from "./useMeasurements";
+import { from } from "rxjs";
+import { map, filter, groupBy, switchMap, toArray, scan } from "rxjs/operators";
+import { useSelector } from "react-redux";
+import { useMeasurementsModule } from "./useMeasurementsModule";
+/**
+ * A hook that returns windowed data.
+ * @param options
+ * @returns
+ */
+export const useWindowedMeasurementData = (options) => {
+    const { rows, measurements: measurementIds, visibleWindow, unit, timer, } = options;
+    const { client, selector } = useMeasurementsModule();
+    // The timer will give back timestamps in "realtime" in microseconds, so for example: 1500635719101123 (Fri Jul 21 2017 13:15:19 GMT+0200 (Central European Summer Time) {}).
+    // We will need to use the measurement scale and the start of the measurementfiles to calculate the offset time for a given measurement.
+    const measurementScale = useSelector((s) => selector(s).measurementScale);
+    const { measurements } = useMeasurements();
+    const [state, setState] = useState({
+        loading: false,
+    });
+    /**
+     * Create a map with files, we need these to get the start time of a file. So that we can create a timer with an offset.
+     */
+    const files = useSelector((s) => selector(s).files);
+    const filesById = useMemo(() => {
+        return files.reduce((acc, c) => (Object.assign(Object.assign({}, acc), { [c.path]: c })), {});
+    }, [files]);
+    useEffect(() => {
+        const observable$ = from(measurements).pipe(filter((m) => measurementIds.indexOf(m.id) !== -1), 
+        // Request are on a per file basis.
+        groupBy((m) => m.file), switchMap((grouped) => grouped.pipe(toArray(), switchMap((measurements) => {
+            //
+            // The measurements in the app have an ID like (ROOT:/32322/WAVE) that
+            // is incompatible with the IDs of the API (just WAVE). So we keep track of a map
+            // that contains the mapping from the IDs used by the API to the ones used in the
+            // app so we can map them back later.
+            //
+            const nameIdMap = measurements.reduce((acc, c) => {
+                return Object.assign(Object.assign({}, acc), { [c.name]: c.id });
+            }, {});
+            // Retrieve the file in which theses measurements are stored.
+            const fileObj = filesById[grouped.key];
+            const start = fileObj.timing.start;
+            // We'll map the timer to have an offset and for the time to be scaled using the measurement scale.
+            const time$ = timer.state.pipe(map((timerState) => {
+                const offsetTime = timerState.time - start;
+                const scaledOffsetTime = offsetTime * Math.sqrt(measurementScale);
+                return scaledOffsetTime;
+            }));
+            return client
+                .createWindowedMeasurementDataObservable({
+                rows,
+                visibleWindow,
+                measurements: measurements.map((m) => m.name),
+                // times are on a per-file basis, so this will use the offset of the file
+                time$,
+                file: grouped.key,
+                unit,
+            })
+                .pipe(
+            // This is where we map back the IDs
+            map((v) => {
+                var _a;
+                return (Object.assign(Object.assign({}, v), { 
+                    // We add a file property so we can retrieve for which file this loading is.
+                    file: grouped.key, data: Object.assign(Object.assign({}, v.data), { measurementData: ((_a = v.data) === null || _a === void 0 ? void 0 : _a.measurementData)
+                            ? Object.keys(v.data.measurementData).reduce((acc, c) => {
+                                var _a, _b;
+                                if ((_a = v.data) === null || _a === void 0 ? void 0 : _a.measurementData[c]) {
+                                    return Object.assign(Object.assign({}, acc), { [nameIdMap[c]]: (_b = v.data) === null || _b === void 0 ? void 0 : _b.measurementData[c] });
+                                }
+                                return acc;
+                            }, {})
+                            : undefined }) }));
+            }));
+        }))), 
+        // We accumulate the data from all the files here.
+        scan((acc, c) => {
+            var _a, _b;
+            const loadingFiles = c.loading
+                ? [...acc.loadingFiles, c.file]
+                : acc.loadingFiles.filter((f) => f !== c.file);
+            return {
+                loadingFiles,
+                data: Object.assign(Object.assign(Object.assign({}, acc.data), c.data), { 
+                    // We'll only return the new range if all files have finished loading.
+                    range: loadingFiles.length > 0 || !c.data.range
+                        ? acc.data.range
+                        : c.data.range, measurementData: Object.assign(Object.assign({}, (_a = acc.data) === null || _a === void 0 ? void 0 : _a.measurementData), (_b = c.data) === null || _b === void 0 ? void 0 : _b.measurementData) }),
+                error: c.error,
+            };
+        }, {
+            loadingFiles: [],
+            data: {},
+        }), 
+        // We should not retrieve measurement data if still loading. So we clear the data here if some file is still loading.
+        map((state) => {
+            const loading = state.loadingFiles.length > 0;
+            return Object.assign(Object.assign({}, state), { loading, data: state.data });
+        }));
+        const subscription = observable$.subscribe(setState);
+        return () => {
+            subscription.unsubscribe();
+        };
+    }, [
+        client,
+        measurementIds,
+        measurements,
+        options,
+        rows,
+        visibleWindow,
+        measurementScale,
+        unit,
+        timer.state,
+        filesById,
+    ]);
+    return state;
+};
 //# sourceMappingURL=useWindowedMeasurementData.js.map

package/lib/index.d.ts

@@ -1,13 +1,14 @@
-export * from "./types";
-export * from "./client";
-export * from "./hooks/useTimedMeasurementData";
-export * from "./hooks/useWindowedMeasurementData";
-export * from "./components/MeasurementsModuleProvider";
-export * from "./components/MeasurementsTable";
-export * from "./components/MeasurementsChooser";
-export * from "./components/ModalMeasurementChooser";
-export * from "./redux/reducer";
-export * from "./hooks/useMeasurements";
-export * from "./hooks/useMeasurement";
-export * from "./hooks/useMeasurementsModule";
+export * from "./types";
+export * from "./client";
+export * from "./hooks/useTimedMeasurementData";
+export * from "./hooks/useWindowedMeasurementData";
+export * from "./components/MeasurementsModuleProvider";
+export * from "./components/MeasurementsTable";
+export * from "./components/MeasurementsChooser";
+export * from "./components/ModalMeasurementChooser";
+export * from "./redux/reducer";
+export * from "./hooks/useMeasurements";
+export * from "./hooks/useMeasurement";
+export * from "./hooks/useMeasurementsModule";
+export * from "./hooks/useOverlayMeasurementData";
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,yCAAyC,CAAC;AACxD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,sCAAsC,CAAC;AACrD,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,yCAAyC,CAAC;AACxD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,sCAAsC,CAAC;AACrD,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mCAAmC,CAAC"}

package/lib/index.js

@@ -1,13 +1,14 @@
-export * from "./types";
-export * from "./client";
-export * from "./hooks/useTimedMeasurementData";
-export * from "./hooks/useWindowedMeasurementData";
-export * from "./components/MeasurementsModuleProvider";
-export * from "./components/MeasurementsTable";
-export * from "./components/MeasurementsChooser";
-export * from "./components/ModalMeasurementChooser";
-export * from "./redux/reducer";
-export * from "./hooks/useMeasurements";
-export * from "./hooks/useMeasurement";
-export * from "./hooks/useMeasurementsModule";
+export * from "./types";
+export * from "./client";
+export * from "./hooks/useTimedMeasurementData";
+export * from "./hooks/useWindowedMeasurementData";
+export * from "./components/MeasurementsModuleProvider";
+export * from "./components/MeasurementsTable";
+export * from "./components/MeasurementsChooser";
+export * from "./components/ModalMeasurementChooser";
+export * from "./redux/reducer";
+export * from "./hooks/useMeasurements";
+export * from "./hooks/useMeasurement";
+export * from "./hooks/useMeasurementsModule";
+export * from "./hooks/useOverlayMeasurementData";
 //# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,yCAAyC,CAAC;AACxD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,sCAAsC,CAAC;AACrD,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,yCAAyC,CAAC;AACxD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,sCAAsC,CAAC;AACrD,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mCAAmC,CAAC"}