@uwrl/qc-utils 0.0.15 → 0.0.18

package/dist/services/api.d.ts

@@ -0,0 +1,147 @@
+import { Unit, Thing, Sensor, ResultQualifier, ProcessingLevel, ObservedProperty, Datastream, Tag, PostHydroShareArchive, HydroShareArchive, User, Workspace, ApiKey } from '@/types';
+import { DataSource } from '@/models';
+import { OrchestrationSystem } from '@/models/dataSource';
+export declare const BASE_URL: string;
+export declare const AUTH_BASE: string;
+export declare const ACCOUNT_BASE: string;
+export declare const SESSION_BASE: string;
+export declare const PROVIDER_BASE: string;
+export declare const THINGS_BASE: string;
+export declare const TAG_BASE: string;
+type DatastreamFilterKey = 'unit_id' | 'sensor_id' | 'observed_property_id' | 'processing_level_id' | 'result_qualifier_id';
+export declare const getObservationsEndpoint: (id: string, pageSize: number, startTime: string, endTime?: string, page?: number) => string;
+export declare const api: {
+    fetchSession: () => Promise<any>;
+    login: (email: string, password: string) => Promise<any>;
+    logout: () => Promise<any>;
+    fetchUser: () => Promise<any>;
+    signup: (user: User) => Promise<any>;
+    updateUser: (user: User, oldUser: User) => Promise<any>;
+    deleteUser: () => Promise<any>;
+    sendVerificationEmail: (email: string) => Promise<any>;
+    verifyEmailWithCode: (key: string) => Promise<any>;
+    requestPasswordReset: (email: string) => Promise<any>;
+    resetPassword: (key: string, password: string) => Promise<any>;
+    fetchWorkspaces: () => Promise<any>;
+    fetchAssociatedWorkspaces: () => Promise<any>;
+    fetchWorkspace: (id: string) => Promise<any>;
+    createWorkspace: (postWorkspace: Workspace) => Promise<any>;
+    updateWorkspace: (newWorkspace: Workspace, oldWorkspace?: Workspace | null) => Promise<any>;
+    deleteWorkspace: (id: string) => Promise<any>;
+    transferWorkspace: (id: string, newOwner: string) => Promise<any>;
+    acceptWorkspaceTransfer: (id: string) => Promise<any>;
+    rejectWorkspaceTransfer: (id: string) => Promise<any>;
+    getCollaboratorRoles: (id: string) => Promise<any>;
+    getAPIKeyRoles: (id: string) => Promise<any>;
+    getRole: (roleId: string) => Promise<any>;
+    getCollaborators: (id: string) => Promise<any>;
+    addCollaborator: (id: string, email: string, roleId: string) => Promise<any>;
+    updateCollaboratorRole: (id: string, email: string, roleId: string) => Promise<any>;
+    removeCollaborator: (id: string, email: string) => Promise<any>;
+    fetchApiKeys: (workspaceId: string) => Promise<any>;
+    fetchApiKey: (workspaceId: string, apiKeyId: string) => Promise<any>;
+    createApiKey: (apiKey: ApiKey) => Promise<any>;
+    updateApiKey: (newKey: ApiKey, oldKey?: ApiKey) => Promise<any>;
+    regenerateApiKey: (id: string, apiKeyId: string) => Promise<any>;
+    deleteApiKey: (id: string, apiKeyId: string) => Promise<any>;
+    fetchConnectedProviders: () => Promise<any>;
+    providerRedirect: (provider: string, callbackUrl: string, process: string) => void;
+    providerSignup: (user: User) => Promise<any>;
+    deleteProvider: (provider: string, account: string) => Promise<any>;
+    createUnit: (unit: Unit) => Promise<any>;
+    fetchUnits: () => Promise<any>;
+    fetchWorkspaceUnits: (id: string) => Promise<any>;
+    updateUnit: (newUnit: Unit, oldUnit?: Unit | null) => Promise<any>;
+    deleteUnit: (id: string) => Promise<any>;
+    getUnit: (id: string) => Promise<any>;
+    removeThingOwner: (id: string, email: string) => Promise<any>;
+    addSecondaryOwner: (id: string, email: string) => Promise<any>;
+    transferPrimaryOwnership: (id: string, email: string) => Promise<any>;
+    createThing: (thing: Thing) => Promise<any>;
+    fetchThings: () => Promise<any>;
+    fetchThingsForWorkspace: (id: string) => Promise<any>;
+    fetchOwnedThings: () => Promise<any>;
+    fetchThing: (id: string) => Promise<any>;
+    updateThing: (thing: Thing) => Promise<any>;
+    updateThingPrivacy: (id: string, isPrivate: boolean) => Promise<any>;
+    deleteThing: (id: string) => Promise<any>;
+    fetchMetadataForThingOwner: (thingId: string) => Promise<any>;
+    fetchMetadataForThing: (thingId: string) => Promise<any>;
+    uploadSitePhotos: (thingId: string, data: FormData) => Promise<any>;
+    fetchSitePhotos: (thingId: string) => Promise<any>;
+    deleteSitePhoto: (thingId: string, name: string) => Promise<any>;
+    createSiteTag: (thingId: string, tag: Tag) => Promise<any>;
+    editSiteTag: (thingId: string, tag: Tag) => Promise<any>;
+    fetchSiteTags: (thingId: string) => Promise<any>;
+    fetchUsersSiteTags: () => Promise<any>;
+    deleteSiteTag: (thingId: string, tag: Tag) => Promise<any>;
+    fetchWorkspaceTags: (workspaceId: string) => Promise<any>;
+    createHydroShareArchive: (archive: PostHydroShareArchive) => Promise<any>;
+    updateHydroShareArchive: (newArchive: HydroShareArchive, oldArchive?: HydroShareArchive) => Promise<any>;
+    fetchHydroShareArchive: (thingId: string) => Promise<any>;
+    deleteHydroShareArchive: (thingId: string) => Promise<any>;
+    archiveToHydroShare: (thingId: string) => Promise<any>;
+    createDatastream: (datastream: Datastream) => Promise<any>;
+    fetchDatastreams: (filters?: Partial<Record<DatastreamFilterKey, string>>) => Promise<any>;
+    fetchDatastreamsForThing: (thingId: string) => Promise<any>;
+    fetchExpandedDatastreamsForThing: (thingId: string) => Promise<any>;
+    fetchDatastreamsForDataSource: (id: string) => Promise<any>;
+    fetchDatastream: (id: string) => Promise<any>;
+    fetchDatastreamExpanded: (id: string) => Promise<any>;
+    fetchUsersDatastreams: () => Promise<any>;
+    updateDatastream: (newDS: Datastream, oldDS?: Datastream | null) => Promise<any>;
+    deleteDatastream: (id: string) => Promise<any>;
+    downloadDatastreamCSV: (id: string) => Promise<any>;
+    createObservedProperty: (op: ObservedProperty) => Promise<any>;
+    fetchObservedProperty: (id: string) => Promise<any>;
+    fetchObservedProperties: () => Promise<any>;
+    fetchWorkspaceObservedProperties: (id: string) => Promise<any>;
+    updateObservedProperty: (newOP: ObservedProperty, oldOP?: ObservedProperty | null) => Promise<any>;
+    deleteObservedProperty: (id: string) => Promise<any>;
+    createProcessingLevel: (pl: ProcessingLevel) => Promise<any>;
+    fetchProcessingLevels: () => Promise<any>;
+    fetchProcessingLevel: (id: string) => Promise<any>;
+    fetchWorkspaceProcessingLevels: (id: string) => Promise<any>;
+    updateProcessingLevel: (newPL: ProcessingLevel, oldPL?: ProcessingLevel | null) => Promise<any>;
+    deleteProcessingLevel: (id: string) => Promise<any>;
+    createSensor: (sensor: Sensor) => Promise<any>;
+    fetchSensors: () => Promise<any>;
+    fetchSensor: (id: string) => Promise<any>;
+    fetchWorkspaceSensors: (id: string) => Promise<any>;
+    updateSensor: (newSensor: Sensor, oldSensor?: Sensor | null) => Promise<any>;
+    deleteSensor: (id: string) => Promise<any>;
+    createResultQualifier: (resultQualifier: ResultQualifier) => Promise<any>;
+    fetchResultQualifiers: () => Promise<any>;
+    fetchWorkspaceResultQualifiers: (id: string) => Promise<any>;
+    updateResultQualifier: (newResultQualifier: ResultQualifier, oldResultQualifier?: ResultQualifier | null) => Promise<any>;
+    deleteResultQualifier: (id: string) => Promise<any>;
+    createOrchestrationSystem: (system: OrchestrationSystem) => Promise<any>;
+    fetchOrchestrationSystems: () => Promise<any>;
+    fetchWorkspaceOrchestrationSystems: (id: string) => Promise<any>;
+    fetchOrchestrationSystem: (id: string) => Promise<any>;
+    updateOrchestrationSystem: (id: string, system: OrchestrationSystem) => Promise<any>;
+    deleteOrchestrationSystem: (id: string) => Promise<any>;
+    createDataSource: (dataSource: DataSource) => Promise<any>;
+    fetchDataSources: () => Promise<any>;
+    fetchWorkspaceDataSources: (id: string) => Promise<any>;
+    fetchDataSource: (id: string) => Promise<any>;
+    updateDataSource: (newS: DataSource) => Promise<any>;
+    updateDataSourcePartial: (newS: DataSource) => Promise<any>;
+    deleteDataSource: (id: string) => Promise<any>;
+    linkDatastreamToDataSource: (dataSourceId: string, datastreamId: string) => Promise<any>;
+    unlinkDatastreamFromDataSource: (dataSourceId: string, datastreamId: string) => Promise<any>;
+    fetchObservations: (endpoint: string) => Promise<any>;
+    deleteObservationsForDatastream: (datastreamId: string) => Promise<any>;
+    fetchUserTypes: () => Promise<any>;
+    fetchOrganizationTypes: () => Promise<any>;
+    fetchSiteTypes: () => Promise<any>;
+    fetchSamplingFeatureTypes: () => Promise<any>;
+    fetchSensorEncodingTypes: () => Promise<any>;
+    fetchMethodTypes: () => Promise<any>;
+    fetchVariableTypes: () => Promise<any>;
+    fetchUnitTypes: () => Promise<any>;
+    fetchDatastreamStatuses: () => Promise<any>;
+    fetchDatastreamAggregations: () => Promise<any>;
+    fetchSampledMediums: () => Promise<any>;
+};
+export {};

package/dist/services/apiMethods.d.ts

@@ -0,0 +1,8 @@
+export declare const apiMethods: {
+    fetch(endpoint: string, options?: any): Promise<any>;
+    patch(endpoint: string, body: any, originalBody?: any, options?: any): Promise<any>;
+    post(endpoint: string, body?: any, options?: any): Promise<any>;
+    put(endpoint: string, body?: any, options?: any): Promise<any>;
+    delete(endpoint: string, body?: any, options?: any): Promise<any>;
+    paginatedFetch<T>(base: string, pageSize?: number): Promise<any>;
+};

package/dist/services/createPatchObject.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Creates an object that represents the differences (patches) between the
+ * original and the updated objects.
+ *
+ * This function iterates through the properties of the updated object and compares each property
+ * with the corresponding property in the original object. If a difference is found:
+ * 1. For properties that are objects, it recursively computes the nested differences.
+ * 2. For other properties, it directly assigns the updated value.
+ *
+ * Note: The function only checks properties that exist in the updated object.
+ *
+ * @param {any} original - The original object to compare from.
+ * @param {any} updated - The updated object to compare against.
+ * @returns {any} An object representing the differences between the two input objects.
+ *                If two properties are identical, they won't appear in the result.
+ */
+export declare function createPatchObject(original: any, updated: any): any;

package/dist/services/getCSRFToken.d.ts

@@ -0,0 +1 @@
+export declare function getCSRFToken(): string | null;

package/dist/services/index.d.ts

@@ -0,0 +1,6 @@
+export * from './api';
+export * from './apiMethods';
+export * from './createPatchObject';
+export * from './getCSRFToken';
+export * from './requestInterceptor';
+export * from './responseInterceptor';

package/dist/services/requestInterceptor.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Intercepts and enhances a request options object.
+ *
+ * - Adds Django AllAuth 'sessionid' to all requests
+ * - Adds CSRF Token to non-GET requests
+ * - If a body is present and it's an object, the body is stringified.
+ *
+ * @param {any} options - The original request options object.
+ *
+ * @returns {any} The enhanced request options with possible modified headers and body.
+ */
+export declare function requestInterceptor(options: any): any;

package/dist/services/responseInterceptor.d.ts

@@ -0,0 +1,2 @@
+export declare function extractErrorMessage(body: any): any;
+export declare function responseInterceptor(response: Response): Promise<any>;

package/dist/types/index.d.ts

@@ -0,0 +1,372 @@
+import { DataSource } from "@/models";
+import { ObservationRecord } from "@/utils/plotting/observation-record";
+export type EnumDictionary<T extends string | symbol | number, U> = {
+    [K in T]: U;
+};
+export declare enum TimeUnit {
+    SECOND = "s",
+    MINUTE = "m",
+    HOUR = "h",
+    DAY = "D",
+    WEEK = "W",
+    MONTH = "M",
+    YEAR = "Y"
+}
+export declare enum EnumEditOperations {
+    ADD_POINTS = "ADD_POINTS",
+    CHANGE_VALUES = "CHANGE_VALUES",
+    /**
+     * Single-operation assignment of distinct values at distinct indices.
+     * Args: `(indices: number[], values: number[])` — parallel arrays where
+     * `values[i]` is written to `dataY[indices[i]]`. No workers, no per-row
+     * ceremony. Intended for table-driven edits.
+     */
+    ASSIGN_VALUES_BULK = "ASSIGN_VALUES_BULK",
+    DELETE_POINTS = "DELETE_POINTS",
+    DRIFT_CORRECTION = "DRIFT_CORRECTION",
+    INTERPOLATE = "INTERPOLATE",
+    SHIFT_DATETIMES = "SHIFT_DATETIMES",
+    /**
+     * Single-operation assignment of distinct datetimes at distinct indices.
+     * Args: `(indices: number[], datetimes: number[])` — parallel arrays of
+     * epoch-milliseconds. Runs one combined delete + add under the hood.
+     */
+    ASSIGN_DATETIMES_BULK = "ASSIGN_DATETIMES_BULK",
+    FILL_GAPS = "FILL_GAPS"
+}
+export declare enum EnumFilterOperations {
+    FIND_GAPS = "FIND_GAPS",
+    PERSISTENCE = "PERSISTENCE",
+    CHANGE = "CHANGE",
+    RATE_OF_CHANGE = "RATE_OF_CHANGE",
+    VALUE_THRESHOLD = "VALUE_THRESHOLD",
+    DATETIME_RANGE = "DATETIME_RANGE",
+    SELECTION = "SELECTION"
+}
+export declare enum FilterOperation {
+    LT = "Less than",
+    LTE = "Less than or equal to",
+    GT = "Greater than",
+    GTE = "Greater than or equal to",
+    E = "Equal"
+}
+export declare enum Operator {
+    ADD = "ADD",
+    SUB = "SUB",
+    MULT = "MULT",
+    DIV = "DIV",
+    ASSIGN = "ASSIGN"
+}
+export declare enum LogicalOperation {
+    LT = "Less than",
+    LTE = "Less than or equal to",
+    GT = "Greater than",
+    GTE = "Greater than or equal to",
+    E = "Equal"
+}
+export type HistoryItem = {
+    method: EnumEditOperations | EnumFilterOperations;
+    icon: string;
+    isLoading: boolean;
+    args?: any[];
+    duration?: number;
+    selected?: number[];
+    status?: "success" | "failed";
+    /**
+     * Whether the operation actually ran on a web worker or inline on
+     * the main thread. Populated by the `ObservationRecord` dispatch
+     * site based on the calibration decision and any always-inline /
+     * always-worker handler behaviour. Mainly useful in dev for
+     * verifying that the calibration layer is routing as expected —
+     * the qc-app surfaces a small badge per history entry when
+     * `import.meta.env.DEV` is truthy.
+     */
+    executionMode?: "worker" | "inline";
+};
+export type DataPoint = {
+    date: Date;
+    value: number;
+};
+export type DataArray = [string, number][];
+export interface GraphSeries {
+    id: string;
+    name: string;
+    data: ObservationRecord;
+    yAxisLabel: string;
+    seriesOption: any;
+}
+export type TimeSpacingUnit = "seconds" | "minutes" | "hours" | "days";
+export interface Tag {
+    key: string;
+    value: string;
+}
+export type Frequency = "daily" | "weekly" | "monthly" | null;
+export declare class HydroShareArchive {
+    id: string;
+    thingId: string;
+    link: string;
+    frequency: Frequency;
+    path: string;
+    datastreamIds: string[];
+    publicResource: boolean;
+    constructor();
+}
+export declare class PostHydroShareArchive extends HydroShareArchive {
+    resourceTitle?: string;
+    resourceAbstract?: string;
+    resourceKeywords?: string[];
+    constructor();
+}
+export declare class Location {
+    latitude?: number | "";
+    longitude?: number | "";
+    elevation_m?: number | "";
+    elevationDatum: string;
+    state: string;
+    county: string;
+    country: string;
+    constructor();
+}
+export declare class Thing {
+    id: string;
+    workspaceId: string;
+    name: string;
+    location: Location;
+    tags: Tag[];
+    hydroShareArchive?: HydroShareArchive | null;
+    siteType: string;
+    samplingFeatureCode: string;
+    isPrivate: boolean;
+    description: string;
+    samplingFeatureType: string;
+    dataDisclaimer: string;
+    constructor();
+}
+export interface ThingWithColor extends Thing {
+    color?: {
+        borderColor: string;
+        background: string;
+        glyphColor: string;
+    };
+    tagValue?: string;
+}
+export declare class Datastream {
+    id: string;
+    workspaceId: string;
+    name: string;
+    description: string;
+    thingId: string;
+    observationType: string;
+    resultType?: string;
+    status?: string;
+    sampledMedium: string;
+    noDataValue: number;
+    aggregationStatistic: string;
+    unitId: string;
+    observedPropertyId: string;
+    sensorId: string;
+    processingLevelId: string;
+    isPrivate: boolean;
+    isVisible: boolean;
+    phenomenonBeginTime?: string | null;
+    phenomenonEndTime?: string | null;
+    intendedTimeSpacing?: number;
+    intendedTimeSpacingUnit?: TimeSpacingUnit | null;
+    timeAggregationInterval: number | null;
+    timeAggregationIntervalUnit: TimeSpacingUnit;
+    dataSourceId?: string | null;
+    valueCount: number;
+    constructor(thingId?: string);
+}
+export interface DatastreamExtended {
+    id: string;
+    name: string;
+    description: string;
+    observationType: string;
+    resultType?: string;
+    status?: string;
+    sampledMedium: string;
+    noDataValue: number;
+    aggregationStatistic: string;
+    isPrivate: boolean;
+    isVisible: boolean;
+    phenomenonBeginTime?: string | null;
+    phenomenonEndTime?: string | null;
+    intendedTimeSpacing?: number;
+    intendedTimeSpacingUnit?: TimeSpacingUnit | null;
+    timeAggregationInterval: number | null;
+    timeAggregationIntervalUnit: TimeSpacingUnit;
+    dataSourceId?: string | null;
+    valueCount: number;
+    thing: Thing;
+    workspace: Workspace;
+    unit: Unit;
+    observedProperty: ObservedProperty;
+    sensor: Sensor;
+    processingLevel: ProcessingLevel;
+    dataSource: DataSource;
+}
+export declare class Unit {
+    id: string;
+    workspaceId: string;
+    name: string;
+    symbol: string;
+    definition: string;
+    type: string;
+    constructor();
+}
+export declare class Sensor {
+    id: string;
+    workspaceId: string;
+    name: string;
+    description: string;
+    manufacturer: string;
+    model: string;
+    methodType: string;
+    methodCode: string;
+    methodLink: string;
+    encodingType: string;
+    modelLink: string;
+    constructor();
+}
+export declare class ObservedProperty {
+    id: string;
+    workspaceId: string;
+    name: string;
+    definition: string;
+    description: string;
+    type: string;
+    code: string;
+    constructor();
+}
+export declare class ProcessingLevel {
+    id: string;
+    workspaceId: string;
+    code: string;
+    definition: string;
+    explanation: string;
+    constructor();
+}
+export declare class ResultQualifier {
+    id: string;
+    workspaceId: string;
+    code: string;
+    description: string;
+    constructor();
+}
+export declare class Organization {
+    name?: string;
+    code?: string;
+    type?: string;
+    description?: string;
+    link?: string;
+    constructor();
+}
+export declare class User {
+    id: string;
+    email: string;
+    password: string;
+    firstName: string;
+    middleName: string;
+    lastName: string;
+    phone: string;
+    address: string;
+    organization?: Organization | null;
+    type: string;
+    link: string;
+    accountType: "admin" | "standard" | "limited";
+    hydroShareConnected: boolean;
+    constructor();
+}
+export interface Photo {
+    name: string;
+    link: string;
+}
+export declare class OAuthProvider {
+    id: string;
+    name: string;
+    iconLink: string;
+    signupEnabled: boolean;
+    connectEnabled: boolean;
+    constructor();
+}
+export declare enum PermissionAction {
+    Global = "*",
+    View = "view",
+    Create = "create",
+    Edit = "edit",
+    Delete = "delete"
+}
+export declare enum PermissionResource {
+    Global = "*",
+    Workspace = "Workspace",
+    Collaborator = "Collaborator",
+    Thing = "Thing",
+    Datastream = "Datastream",
+    Sensor = "Sensor",
+    Unit = "Unit",
+    ObservedProperty = "ObservedProperty",
+    ProcessingLevel = "ProcessingLevel",
+    Observation = "Observation"
+}
+export interface Permission {
+    action: PermissionAction;
+    resource: PermissionResource;
+}
+export interface CollaboratorRole {
+    name: string;
+    description: string;
+    id: string;
+    workspaceId: string;
+    isApikeyRole: boolean;
+    isUserRole: boolean;
+    permissions: Permission[];
+}
+export declare class ApiKey {
+    id: string;
+    key: string;
+    name: string;
+    description: string;
+    isActive: boolean;
+    expiresAt: string;
+    createdAt: string;
+    lastUsed: string;
+    workspaceId: string;
+    role: CollaboratorRole | null;
+    constructor(init?: Partial<ApiKey>);
+}
+export interface WorkspaceData {
+    id: string;
+    name: string;
+    isPrivate: boolean;
+    owner: User;
+    collaboratorRole: CollaboratorRole;
+    pendingTransferTo?: User | null;
+}
+export declare class Workspace {
+    id: string;
+    name: string;
+    isPrivate: boolean;
+    owner: UserInfo | null;
+    collaboratorRole: CollaboratorRole | null;
+    pendingTransferTo?: UserInfo | null;
+    constructor();
+}
+export interface UserInfo {
+    name: string;
+    email: string;
+    phone: string;
+    address: string;
+    link: string;
+    type: string;
+    organizationName: string;
+}
+export declare class Collaborator {
+    user: UserInfo;
+    role: CollaboratorRole;
+    constructor();
+}
+export interface ApiError {
+    status: number;
+    message?: string;
+}

package/dist/utils/__tests__/observations.spec.d.ts

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

package/dist/utils/ellapsed-time.d.ts

@@ -0,0 +1,4 @@
+export declare const measureEllapsedTime: (fn: () => any, message?: string) => Promise<{
+    response: any;
+    duration: number;
+}>;

package/dist/utils/format.d.ts

@@ -0,0 +1,4 @@
+import { EnumDictionary, TimeUnit } from '@/types';
+export declare const timeUnitMultipliers: EnumDictionary<TimeUnit, number>;
+export declare const formatDate: (date: Date) => string;
+export declare const formatDuration: (duration: number) => string;

package/dist/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './format';
+export * from './ellapsed-time';
+export * from './notifications';
+export * from './observations';
+export * from './plotting/observation-record';
+export * from './plotting/calibration';

package/dist/utils/observations.d.ts

@@ -0,0 +1,5 @@
+export declare function subtractHours(timestamp: string, hours: number): string;
+/** Returns the index of the first value that is greater or equal to the target value */
+export declare const findFirstGreaterOrEqual: (array: number[] | Float64Array<SharedArrayBuffer>, target: number) => number;
+/** Returns the index of the last value that is lesser or equal to the target value */
+export declare const findLastLessOrEqual: (array: number[] | Float64Array<SharedArrayBuffer>, target: number) => number;

package/dist/utils/plotting/__tests__/calibration.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Unit tests for the public surface of `calibration.ts`.
+ *
+ * The module imports `value-threshold.worker?worker&inline` eagerly, which
+ * Vite transforms in the app build but not in Vitest + happy-dom — so we
+ * substitute the same `MockValueThresholdWorker` used by
+ * `observation-record.spec.ts` to give `runBenchmarks()` a working worker
+ * constructor. The mock round-trips via `queueMicrotask`, which is enough
+ * for `ensureCalibration()` to complete synchronously-ish in tests.
+ *
+ * Module state (`activeProfile`, `lastBenchmarkDetail`, `listeners`,
+ * `localStorage`) lives at import scope, so every test begins with a
+ * `clearCalibration()` and a `localStorage.clear()` to avoid cross-
+ * pollination.
+ */
+export {};

package/dist/utils/plotting/__tests__/observation-record-paths.spec.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Coverage-focused tests for `observation-record.ts` that exercise
+ * paths the baseline spec skips:
+ *
+ *   1. **Worker fan-out paths** — every `_operation` routes through
+ *      `shouldUseWorker()` and falls back to an inline core for small
+ *      inputs. The existing `observation-record.spec.ts` uses tiny
+ *      datasets, so only the inline branches run. Here we mock
+ *      `../calibration` so callers can flip `forceWorker = true` and
+ *      drive the worker branches without needing multi-MB fixtures.
+ *   2. **Bulk assignment ops** — `ASSIGN_VALUES_BULK` and
+ *      `ASSIGN_DATETIMES_BULK` aren't touched by the baseline spec.
+ *   3. **Undo / redo** — `undo()` / `redo()` have their own state
+ *      machines that aren't driven by the `dispatch()` tests.
+ *   4. **DATETIME_RANGE, SELECTION pop** — the remaining filter ops.
+ *
+ * Mocks are hoisted via `vi.mock`; the real calibration module is
+ * wrapped so non-mocked helpers (getCalibration, etc.) still work if
+ * anything reaches for them.
+ */
+export {};

package/dist/utils/plotting/__tests__/observation-record.spec.d.ts

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

package/dist/utils/plotting/__tests__/operation-cores.spec.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Direct unit tests for the pure kernels in `operation-cores.ts`. These
+ * functions are the shared source of truth for every `*.worker.ts` with an
+ * inline equivalent, so once they pass here the worker wrappers only need a
+ * thin "message in / message out" check (see `workers.spec.ts`).
+ *
+ * Cores are deliberately framework-free and accept plain typed arrays, so
+ * these tests build buffers from raw `Float32Array` / `Float64Array` rather
+ * than `SharedArrayBuffer`. Semantics are identical and happy-dom doesn't
+ * require the cross-origin-isolation headers SAB would.
+ */
+export {};