@inspectorhub/field-ui 0.0.0-stage → 0.2.1

package/dist/testing.d.ts

@@ -0,0 +1,247 @@
+import { FieldResources, AiAssistInput, AiAssistResult, CommentsLibraryQuery, CommentsLibraryEntry, CommentsLibraryRow, CostItemWrite, CostItemView, TemplateSearchResult, MediaPoolListing, RepairItemOption, SettingsSheetData, VersionSnapshotEntry, VersionSnapshotContent, VideoFinalizeInput, VideoUploadTicket, FieldCommand, FieldDataSource, NotifyVariant, PendingMediaRecord, CommandDataMap, InspectionPrefs, CommandResult, EditorData, SessionInfo, FieldUrls } from './index.js';
+import 'yjs';
+
+/** The `templateSearch` resource: answers `result` (an empty single page by default) and records each input. */
+interface FakeTemplateSearch {
+    search(input: {
+        q: string;
+        page: number;
+    }): Promise<TemplateSearchResult>;
+    readonly searches: readonly {
+        q: string;
+        page: number;
+    }[];
+    /** Replace the page every later search answers. */
+    setResult(result: TemplateSearchResult): void;
+}
+declare function createFakeTemplateSearch(initial?: TemplateSearchResult): FakeTemplateSearch;
+type CommentsLibraryResource = NonNullable<FieldResources['commentsLibrary']>;
+/** The `commentsLibrary` resource: lists `rows`, records every list, touch, save and edit. */
+interface FakeCommentsLibrary extends CommentsLibraryResource {
+    /** The query of every `list`, in call order (`undefined` when none was passed). */
+    readonly lists: readonly (CommentsLibraryQuery | undefined)[];
+    readonly touches: readonly string[];
+    /** The entry of every stored `save`, in call order. */
+    saved(): readonly CommentsLibraryEntry[];
+    /** The id and entry of every `edit`, in call order. */
+    edited(): readonly {
+        id: string;
+        entry: CommentsLibraryEntry;
+    }[];
+    /** Replace the rows every later `list` answers. */
+    setRows(rows: CommentsLibraryRow[]): void;
+    /** Make every later `save` answer `{ ok: false, error }` and store nothing. */
+    failSave(error: string): void;
+}
+declare function createFakeCommentsLibrary(initial?: CommentsLibraryRow[]): FakeCommentsLibrary;
+type AiAssistResource = NonNullable<FieldResources['aiAssist']>;
+/** The `aiAssist` resource: records every request and answers a configurable result per intent. */
+interface FakeAiAssist extends AiAssistResource {
+    /** Every request, in call order. */
+    readonly runs: readonly AiAssistInput[];
+    /** Replace the answer of every later `assist` (default: a draft with the call id `ai-call-1`). */
+    answerAssist(result: AiAssistResult): void;
+    /** Replace the answer of every later `review` (default: recorded). */
+    answerReview(result: AiAssistResult): void;
+    /** Make every later request wait until the returned function is called, to hold one in flight. */
+    hold(): () => void;
+}
+declare function createFakeAiAssist(): FakeAiAssist;
+type CostItemsResource = NonNullable<FieldResources['costItems']>;
+/**
+ * The `costItems` resource: lists `items`, records every list and write. A `create` answers the id `stored-N`
+ * (N counting from 1); `update` and `delete` answer ok. `hold` keeps every later write in flight.
+ */
+interface FakeCostItems extends CostItemsResource {
+    /** Inspection ids passed to `list`, in call order. */
+    readonly lists: readonly string[];
+    /** Every write passed to `save`, in call order. */
+    readonly writes: readonly {
+        inspectionId: string;
+        write: CostItemWrite;
+    }[];
+    /** Replace the lines every later `list` answers. */
+    setItems(items: CostItemView[]): void;
+    /** Replace the reserve-schedule switch every later `list` answers. */
+    setReserveEnabled(enabled: boolean): void;
+    /** Make every later `save` answer `{ ok: false }`. */
+    failSave(): void;
+    /** Keep every later `save` in flight until the returned function is called. */
+    hold(): () => void;
+}
+declare function createFakeCostItems(initial?: CostItemView[]): FakeCostItems;
+
+type VersionHistoryResource = NonNullable<FieldResources['versionHistory']>;
+type VideoResource = NonNullable<FieldResources['video']>;
+/** The `versionHistory` resource: lists `snapshots`, records every capture, restore and get. */
+interface FakeVersionHistory extends VersionHistoryResource {
+    /** Inspection ids passed to `capture`, in call order. */
+    readonly captures: readonly string[];
+    /** `{ inspectionId, seq }` passed to `restore`, in call order. */
+    readonly restores: readonly {
+        inspectionId: string;
+        seq: number;
+    }[];
+    /** `{ inspectionId, seq }` passed to `get`, in call order. */
+    readonly gets: readonly {
+        inspectionId: string;
+        seq: number;
+    }[];
+    /** Number of `list` calls. */
+    readonly lists: number;
+    /** Replace the versions every later `list` answers. */
+    setSnapshots(snapshots: VersionSnapshotEntry[]): void;
+    /** Replace the content every later `get` answers. */
+    setContent(content: VersionSnapshotContent): void;
+    /** Make every later `list` answer not-ok (the host could not read it). */
+    failList(error?: string): void;
+    /** Make every later `get` answer not-ok. */
+    failGet(error?: string): void;
+    /** Make every later `capture` answer `{ ok: false, error }`. */
+    failCapture(error: string): void;
+    /** Make every later `restore` answer `{ ok: false, error }`. */
+    failRestore(error: string): void;
+}
+declare function createFakeVersionHistory(initial?: VersionSnapshotEntry[]): FakeVersionHistory;
+/**
+ * The `video` resource. Every member answers a neutral success (a stream ticket, a pool row `pool-1`) and
+ * records its call; `fail*` makes a step answer not-ok, `holdCreateUpload` keeps one in flight until released.
+ */
+interface FakeVideo extends VideoResource {
+    /** Arguments of every `setPoster`, in call order. */
+    readonly posters: readonly {
+        inspectionId: string;
+        streamUid: string;
+        posterPct: number;
+    }[];
+    /** `{ inspectionId, input }` of every `createUpload`, in call order. */
+    readonly createUploads: readonly {
+        inspectionId: string;
+        input: {
+            itemId?: string;
+        };
+    }[];
+    /** File names of every `uploadFile`, in call order. */
+    readonly uploadedFiles: readonly string[];
+    /** Number of `uploadPoster` calls. */
+    readonly posterUploads: number;
+    /** The input of every `finalize`, in call order. */
+    readonly finalizes: readonly {
+        inspectionId: string;
+        input: VideoFinalizeInput;
+    }[];
+    /** Replace the ticket every later `createUpload` answers. */
+    setTicket(ticket: VideoUploadTicket): void;
+    /** Make every later `createUpload` answer `{ ok: false }` (with `error` when given). */
+    failCreateUpload(error?: string): void;
+    /** Make every later `uploadFile` answer `{ ok: false }`. */
+    failUploadFile(error?: string): void;
+    /** Make every later `finalize` answer `{ ok: false }`. */
+    failFinalize(error?: string): void;
+    /** Keep every later `createUpload` in flight until the returned function is called. */
+    holdCreateUpload(): () => void;
+}
+declare function createFakeVideo(): FakeVideo;
+/** The `repairItems` resource: lists `items` and counts the reads. */
+interface FakeRepairItems extends NonNullable<FieldResources['repairItems']> {
+    readonly lists: number;
+    setItems(items: RepairItemOption[]): void;
+}
+declare function createFakeRepairItems(initial?: RepairItemOption[]): FakeRepairItems;
+/** The `mediaPool` resource: answers `listing` (an answered, empty pool by default) and records each read. */
+interface FakeMediaPool extends NonNullable<FieldResources['mediaPool']> {
+    readonly lists: readonly string[];
+    setListing(listing: MediaPoolListing): void;
+}
+declare function createFakeMediaPool(initial?: MediaPoolListing): FakeMediaPool;
+/** The `settingsSheet` resource: answers `data` (an empty sheet by default, `null` once `setData(null)`) and records each read. */
+interface FakeSettingsSheet extends NonNullable<FieldResources['settingsSheet']> {
+    readonly loads: readonly string[];
+    setData(data: SettingsSheetData | null): void;
+}
+declare function createFakeSettingsSheet(initial?: SettingsSheetData | null): FakeSettingsSheet;
+
+interface FakeSeed {
+    data: EditorData;
+    session?: Partial<SessionInfo>;
+    urls?: Partial<FieldUrls>;
+    /** Defaults to empty: every optional capability is absent. */
+    resources?: FieldResources;
+    platform?: FieldDataSource['platform'];
+    /** Initial connectivity; defaults to online. */
+    online?: boolean;
+    /** Host members the fake leaves out, to exercise the editor's fallback for a host that lacks them. */
+    without?: readonly ('restartSession' | 'openUrl')[];
+}
+interface ExecutedCommand {
+    inspectionId: string;
+    cmd: FieldCommand;
+    /** Present only when the caller passed `ExecuteOptions.idempotencyKey`. */
+    idempotencyKey?: string;
+}
+/** A `FieldDataSource` backed by memory, with hooks for tests to inspect and perturb it. */
+interface FakeDataSource extends FieldDataSource {
+    /** Every command passed to `execute`, in call order. */
+    readonly commands: readonly ExecutedCommand[];
+    /** Inspection ids passed to `collab.purge`, in call order. */
+    readonly purged: readonly string[];
+    readonly reloadCount: number;
+    /** Number of `restartSession` calls. */
+    readonly restartCount: number;
+    /** Every address passed to `openUrl`, in call order. */
+    readonly openedUrls: readonly string[];
+    readonly exitCount: number;
+    /** Every `notify` call, in call order. */
+    readonly notifications: readonly {
+        message: string;
+        variant: NotifyVariant | undefined;
+        /** Present only when the caller passed `NotifyOptions.durationMs`. */
+        durationMs?: number;
+        /** Present only when the caller passed `NotifyOptions.action`; `run` is its handler, so a test can press it. */
+        action?: {
+            label: string;
+            run: () => void;
+        };
+    }[];
+    /** Every `media.uploader(...).upload` call, in call order. `hadDoc` is whether a results document was passed. */
+    readonly uploads: readonly {
+        inspectionId: string;
+        rec: PendingMediaRecord;
+        hadDoc: boolean;
+    }[];
+    /** Make every later upload answer `{ ok: false, error }`. */
+    failUpload(error: string): void;
+    /**
+     * Make every later command of this type answer `{ ok: false, error }`. A response
+     * registered with `respondWith` for the same command still rides along as `data`,
+     * which is how a failed autofill carries its reason.
+     */
+    failExecute(type: FieldCommand['type'], error: string): void;
+    /** Attach `data` to every later answer for this command (`type`, or `type:op`). */
+    respondWith<K extends keyof CommandDataMap>(key: K, data: CommandDataMap[K]): void;
+    /** Make every later `media.store.put` reject with this error. */
+    failMediaPut(error: Error): void;
+    /** Flip connectivity and notify subscribers. */
+    setOnline(online: boolean): void;
+}
+/**
+ * An `EditorData` for an inspection with nothing in it. The members the loader
+ * always returns as objects carry the loader's default shape; the members it can
+ * return as null are null. The text defaults are empty because the real boilerplate
+ * belongs to the host.
+ */
+declare function createEmptyEditorData(overrides?: Partial<EditorData>): EditorData;
+/** The `prefs` resource, in memory. Pass it as `resources.prefs`. */
+interface FakePrefs {
+    load(): Promise<InspectionPrefs>;
+    patch(delta: Partial<InspectionPrefs>): Promise<CommandResult<InspectionPrefs>>;
+    /** Every delta passed to a successful `patch`, in call order. */
+    readonly patches: readonly Partial<InspectionPrefs>[];
+    /** Make every later `patch` answer `{ ok: false, error }` and store nothing. */
+    failPatch(error: string): void;
+}
+declare function createFakePrefs(initial?: Partial<InspectionPrefs>): FakePrefs;
+declare function createFakeDataSource(seed: FakeSeed): FakeDataSource;
+
+export { createEmptyEditorData, createFakeAiAssist, createFakeCommentsLibrary, createFakeCostItems, createFakeDataSource, createFakeMediaPool, createFakePrefs, createFakeRepairItems, createFakeSettingsSheet, createFakeTemplateSearch, createFakeVersionHistory, createFakeVideo };
+export type { ExecutedCommand, FakeAiAssist, FakeCommentsLibrary, FakeCostItems, FakeDataSource, FakeMediaPool, FakePrefs, FakeRepairItems, FakeSeed, FakeSettingsSheet, FakeTemplateSearch, FakeVersionHistory, FakeVideo };