@uwrl/qc-utils 0.0.19 → 0.0.20

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__/ellapsed-time.spec.d.ts

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

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

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

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

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

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/notifications.d.ts

@@ -0,0 +1,46 @@
+export declare const DEFAULT_SNACK_DURATION = 3000;
+export declare enum SnackColor {
+    Warning = "warning",
+    Success = "success",
+    Error = "error",
+    Info = "info"
+}
+export declare enum SnackIcon {
+    Success = "mdi-checkbox-marked-circle",
+    Warning = "mdi-alert",
+    Error = "mdi-alert-circle",
+    Info = "mdi-information",
+    None = "none"
+}
+export declare enum SnackTitle {
+    Warning = "Warning",
+    Success = "Success",
+    Error = "Error",
+    Info = "Info"
+}
+export declare enum Position {
+    Center = "center",
+    Left = "left",
+    Right = "right",
+    Bottom = "bottom",
+    Top = "top"
+}
+export declare class Snack {
+    message: string;
+    color: SnackColor;
+    icon: SnackIcon;
+    title: SnackTitle;
+    timeout: number;
+    position: Position;
+    visible: boolean;
+    constructor(message?: string, color?: SnackColor, icon?: SnackIcon, title?: SnackTitle, timeout?: number, position?: Position, visible?: boolean);
+}
+export declare class Snackbar {
+    private static subject;
+    static get snack$(): import("rxjs").Observable<Snack>;
+    private static createSnackbar;
+    static success(message: string): void;
+    static warn(message: string): void;
+    static error(message: string): void;
+    static info(message: string): void;
+}

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<ArrayBufferLike>, 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<ArrayBufferLike>, 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__/mock.d.ts

@@ -0,0 +1,4 @@
+export declare const mockDatastream: {
+    phenomenon_time: string[];
+    result: number[];
+};

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 {};

package/dist/utils/plotting/__tests__/workerMocks.d.ts

@@ -0,0 +1,119 @@
+/**
+ * In-process mock implementations of every worker used by `ObservationRecord`.
+ *
+ * The real workers are loaded via Vite's `?worker&inline` query, which is not
+ * available in Vitest + happy-dom. Each mock here re-implements the logic of
+ * the matching `*.worker.ts` file and runs synchronously via `queueMicrotask`,
+ * which is enough to exercise every code path in `observation-record.ts`
+ * end-to-end. The handler is scheduled via microtask so the caller has a chance
+ * to assign `onmessage` before the response is dispatched (matching the real
+ * Worker API contract).
+ */
+export declare const MockDeleteDataWorker: {
+    new (): {
+        onmessage: ((event: {
+            data: any;
+        }) => void) | null;
+        postMessage(data: any): void;
+        terminate(): void;
+    };
+};
+export declare const MockAddDataWorker: {
+    new (): {
+        onmessage: ((event: {
+            data: any;
+        }) => void) | null;
+        postMessage(data: any): void;
+        terminate(): void;
+    };
+};
+export declare const MockChangeValuesWorker: {
+    new (): {
+        onmessage: ((event: {
+            data: any;
+        }) => void) | null;
+        postMessage(data: any): void;
+        terminate(): void;
+    };
+};
+export declare const MockInterpolateWorker: {
+    new (): {
+        onmessage: ((event: {
+            data: any;
+        }) => void) | null;
+        postMessage(data: any): void;
+        terminate(): void;
+    };
+};
+export declare const MockDriftCorrectionWorker: {
+    new (): {
+        onmessage: ((event: {
+            data: any;
+        }) => void) | null;
+        postMessage(data: any): void;
+        terminate(): void;
+    };
+};
+export declare const MockShiftDatetimesWorker: {
+    new (): {
+        onmessage: ((event: {
+            data: any;
+        }) => void) | null;
+        postMessage(data: any): void;
+        terminate(): void;
+    };
+};
+export declare const MockFillGapsWorker: {
+    new (): {
+        onmessage: ((event: {
+            data: any;
+        }) => void) | null;
+        postMessage(data: any): void;
+        terminate(): void;
+    };
+};
+export declare const MockFindGapsWorker: {
+    new (): {
+        onmessage: ((event: {
+            data: any;
+        }) => void) | null;
+        postMessage(data: any): void;
+        terminate(): void;
+    };
+};
+export declare const MockPersistenceWorker: {
+    new (): {
+        onmessage: ((event: {
+            data: any;
+        }) => void) | null;
+        postMessage(data: any): void;
+        terminate(): void;
+    };
+};
+export declare const MockChangeWorker: {
+    new (): {
+        onmessage: ((event: {
+            data: any;
+        }) => void) | null;
+        postMessage(data: any): void;
+        terminate(): void;
+    };
+};
+export declare const MockRateOfChangeWorker: {
+    new (): {
+        onmessage: ((event: {
+            data: any;
+        }) => void) | null;
+        postMessage(data: any): void;
+        terminate(): void;
+    };
+};
+export declare const MockValueThresholdWorker: {
+    new (): {
+        onmessage: ((event: {
+            data: any;
+        }) => void) | null;
+        postMessage(data: any): void;
+        terminate(): void;
+    };
+};

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

@@ -0,0 +1,18 @@
+/**
+ * Wiring smoke tests for every `*.worker.ts` module.
+ *
+ * The algorithmic behaviour of each kernel is covered in
+ * `operation-cores.spec.ts`, so these tests only verify the worker
+ * handler is installed and forwards its payload to its core — i.e. the
+ * thin shell is plumbed correctly. Two workers still carry inline
+ * logic that has no core counterpart (`drift-correction.worker.ts` and
+ * `shift-datetimes.worker.ts`), so we keep behavioural assertions for
+ * those.
+ *
+ * Each worker file registers its handler via `self.onmessage = ...` at
+ * module evaluation time. We import each module once, capture its
+ * handler, and invoke it synchronously with `self.postMessage`
+ * redirected to a local capture buffer. `self` resolves to the global
+ * `Window` under happy-dom.
+ */
+export {};

package/dist/utils/plotting/add-data.worker.d.ts

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