@inspectorhub/field-ui 0.0.0-stage → 0.2.1

package/dist/testing.js

@@ -0,0 +1,612 @@
+import "./chunk-MLKGABMK.js";
+
+// src/testing/fake-data-source.ts
+import * as Y from "yjs";
+
+// src/testing/fake-resources.ts
+function createFakeTemplateSearch(initial) {
+  let result = initial ?? { templates: [], hasMore: false, page: 1, totalPages: 1 };
+  const searches = [];
+  return {
+    get searches() {
+      return searches;
+    },
+    setResult(next) {
+      result = next;
+    },
+    search: async (input) => {
+      searches.push(input);
+      return result;
+    }
+  };
+}
+function createFakeCommentsLibrary(initial = []) {
+  let rows = initial;
+  let saveFailure = null;
+  const lists = [];
+  const touches = [];
+  const saves = [];
+  const edits = [];
+  return {
+    get lists() {
+      return lists;
+    },
+    get touches() {
+      return touches;
+    },
+    saved: () => saves,
+    edited: () => edits,
+    setRows(next) {
+      rows = next;
+    },
+    failSave(error) {
+      saveFailure = error;
+    },
+    list: async (query) => {
+      lists.push(query);
+      return rows;
+    },
+    touch: async (id) => {
+      touches.push(id);
+      return { ok: true };
+    },
+    save: async (entry) => {
+      if (saveFailure !== null) return { ok: false, error: saveFailure };
+      saves.push(entry);
+      return { ok: true };
+    },
+    edit: async (id, entry) => {
+      edits.push({ id, entry });
+      return { ok: true };
+    }
+  };
+}
+function createFakeAiAssist() {
+  const runs = [];
+  let assist = { ok: true, intent: "assist", text: "Improved note", aiCallId: "ai-call-1" };
+  let review = { ok: true, intent: "review" };
+  let gate = null;
+  return {
+    get runs() {
+      return runs;
+    },
+    answerAssist(result) {
+      assist = result;
+    },
+    answerReview(result) {
+      review = result;
+    },
+    hold() {
+      let release = () => void 0;
+      gate = new Promise((resolve) => {
+        release = resolve;
+      });
+      return () => {
+        gate = null;
+        release();
+      };
+    },
+    run: async (input) => {
+      runs.push(input);
+      if (gate !== null) await gate;
+      return input.intent === "assist" ? assist : review;
+    }
+  };
+}
+function createFakeCostItems(initial = []) {
+  let items = initial;
+  let reserveEnabled = false;
+  let saveFails = false;
+  let gate = null;
+  let stored = 0;
+  const lists = [];
+  const writes = [];
+  return {
+    get lists() {
+      return lists;
+    },
+    get writes() {
+      return writes;
+    },
+    setItems(next) {
+      items = next;
+    },
+    setReserveEnabled(enabled) {
+      reserveEnabled = enabled;
+    },
+    failSave() {
+      saveFails = true;
+    },
+    hold() {
+      let release = () => void 0;
+      gate = new Promise((resolve) => {
+        release = resolve;
+      });
+      return () => {
+        gate = null;
+        release();
+      };
+    },
+    list: async (inspectionId) => {
+      lists.push(inspectionId);
+      return { items, reserveEnabled };
+    },
+    save: async (inspectionId, write) => {
+      writes.push({ inspectionId, write });
+      if (gate !== null) await gate;
+      if (saveFails) return { ok: false };
+      if (write.intent === "create") {
+        stored += 1;
+        return { ok: true, data: { id: `stored-${stored}` } };
+      }
+      return { ok: true };
+    }
+  };
+}
+
+// src/testing/fake-panel-resources.ts
+function notOk(failure) {
+  return failure.error === void 0 ? { ok: false } : { ok: false, error: failure.error };
+}
+function createFakeVersionHistory(initial = []) {
+  const captures = [];
+  const restores = [];
+  const gets = [];
+  let snapshots = initial;
+  let content = { projection: {} };
+  let lists = 0;
+  let listFailure = null;
+  let getFailure = null;
+  let captureFailure = null;
+  let restoreFailure = null;
+  return {
+    get captures() {
+      return captures;
+    },
+    get restores() {
+      return restores;
+    },
+    get gets() {
+      return gets;
+    },
+    get lists() {
+      return lists;
+    },
+    setSnapshots(next) {
+      snapshots = next;
+    },
+    setContent(next) {
+      content = next;
+    },
+    failList(error) {
+      listFailure = error === void 0 ? {} : { error };
+    },
+    failGet(error) {
+      getFailure = error === void 0 ? {} : { error };
+    },
+    failCapture(error) {
+      captureFailure = error;
+    },
+    failRestore(error) {
+      restoreFailure = error;
+    },
+    list: async () => {
+      lists += 1;
+      return listFailure === null ? { ok: true, data: snapshots } : notOk(listFailure);
+    },
+    get: async (inspectionId, seq) => {
+      gets.push({ inspectionId, seq });
+      return getFailure === null ? { ok: true, data: content } : notOk(getFailure);
+    },
+    restore: async (inspectionId, seq) => {
+      restores.push({ inspectionId, seq });
+      return restoreFailure === null ? { ok: true } : { ok: false, error: restoreFailure };
+    },
+    capture: async (inspectionId) => {
+      captures.push(inspectionId);
+      return captureFailure === null ? { ok: true } : { ok: false, error: captureFailure };
+    }
+  };
+}
+function createFakeVideo() {
+  const posters = [];
+  const createUploads = [];
+  const uploadedFiles = [];
+  const finalizes = [];
+  let posterUploads = 0;
+  let ticket = {
+    uploadURL: "https://upload.example/stream",
+    provider: "stream",
+    ref: { provider: "stream", streamUid: "uid-1" }
+  };
+  let createFailure = null;
+  let fileFailure = null;
+  let finalizeFailure = null;
+  let createGate = null;
+  return {
+    get posters() {
+      return posters;
+    },
+    get createUploads() {
+      return createUploads;
+    },
+    get uploadedFiles() {
+      return uploadedFiles;
+    },
+    get posterUploads() {
+      return posterUploads;
+    },
+    get finalizes() {
+      return finalizes;
+    },
+    setTicket(next) {
+      ticket = next;
+    },
+    failCreateUpload(error) {
+      createFailure = error === void 0 ? {} : { error };
+    },
+    failUploadFile(error) {
+      fileFailure = error === void 0 ? {} : { error };
+    },
+    failFinalize(error) {
+      finalizeFailure = error === void 0 ? {} : { error };
+    },
+    holdCreateUpload() {
+      let release = () => void 0;
+      createGate = new Promise((resolve) => {
+        release = resolve;
+      });
+      return () => {
+        createGate = null;
+        release();
+      };
+    },
+    createUpload: async (inspectionId, input) => {
+      createUploads.push({ inspectionId, input });
+      if (createGate !== null) await createGate;
+      return createFailure === null ? { ok: true, data: ticket } : notOk(createFailure);
+    },
+    uploadFile: async (t, file, onProgress) => {
+      uploadedFiles.push(file instanceof File ? file.name : "blob");
+      onProgress(100);
+      if (fileFailure !== null) return notOk(fileFailure);
+      return t.provider === "r2" ? { ok: true, data: { mediaId: "media-1", r2Key: "r2/media-1.mp4" } } : { ok: true };
+    },
+    uploadPoster: async () => {
+      posterUploads += 1;
+      return { ok: true, data: { posterKey: "poster-1" } };
+    },
+    setPoster: async (inspectionId, input) => {
+      posters.push({ inspectionId, ...input });
+      return { ok: true };
+    },
+    finalize: async (inspectionId, input) => {
+      finalizes.push({ inspectionId, input });
+      return finalizeFailure === null ? { ok: true, data: { poolId: "pool-1" } } : notOk(finalizeFailure);
+    },
+    remove: async () => ({ ok: true })
+  };
+}
+function createFakeRepairItems(initial = []) {
+  let items = initial;
+  let lists = 0;
+  return {
+    get lists() {
+      return lists;
+    },
+    setItems(next) {
+      items = next;
+    },
+    list: async () => {
+      lists += 1;
+      return items;
+    }
+  };
+}
+function createFakeMediaPool(initial) {
+  let listing = initial ?? { photos: [], answered: true };
+  const lists = [];
+  return {
+    get lists() {
+      return lists;
+    },
+    setListing(next) {
+      listing = next;
+    },
+    list: async (inspectionId) => {
+      lists.push(inspectionId);
+      return listing;
+    }
+  };
+}
+function createFakeSettingsSheet(initial) {
+  let data = initial === void 0 ? { inspection: null, templates: [], photos: [], profiles: [] } : initial;
+  const loads = [];
+  return {
+    get loads() {
+      return loads;
+    },
+    setData(next) {
+      data = next;
+    },
+    load: async (inspectionId) => {
+      loads.push(inspectionId);
+      return data;
+    }
+  };
+}
+
+// src/testing/fake-data-source.ts
+var DEFAULT_SESSION = {
+  tenantSlug: null,
+  videoProvider: "r2",
+  streamCustomerSubdomain: null,
+  collabEditing: false,
+  userId: "fake-user",
+  locale: "en-US",
+  timeZone: null,
+  dateFormat: "us",
+  timeFormat: "12h",
+  tenantDateFormat: "us",
+  tenantTimeFormat: "12h",
+  // The package never interprets a role (`SessionInfo.role` is the host's string), so the
+  // fake uses a neutral value instead of one of the engine's role names.
+  role: "fake-role"
+};
+function pick(value, fallback) {
+  return value === void 0 ? fallback : value;
+}
+function commandKey(cmd) {
+  return "op" in cmd ? `${cmd.type}:${cmd.op}` : cmd.type;
+}
+var DEFAULT_URLS = {
+  photo: (inspectionId, key) => `/fake/photos/${inspectionId}/${key}`,
+  reportPreview: () => null,
+  reportPdf: () => null,
+  costExport: (inspectionId, format) => `/fake/cost-export/${inspectionId}.${format}`,
+  statutoryPreviewPdf: () => null,
+  videoObject: () => null,
+  presenceSocket: (inspectionId) => `ws://fake.invalid/api/inspections/${inspectionId}/presence/ws`,
+  editorPath: (inspectionId) => `/inspections/${inspectionId}/edit`,
+  inspectionsList: () => "/inspections"
+};
+var EMPTY_PCA_NARRATIVE = {
+  transmittalLetter: "",
+  summaryGeneralDescription: "",
+  summaryPhysicalCondition: "",
+  summaryRecommendations: "",
+  purpose: "",
+  scopeOfWork: "",
+  limitationsExceptions: "",
+  reconnaissance: "",
+  additionalConsiderations: ""
+};
+function createEmptyEditorData(overrides = {}) {
+  return {
+    inspection: { id: "insp-1", propertyAddress: "1 Main St" },
+    schema: { sections: [] },
+    results: {},
+    ratingLevels: [],
+    tagLibrary: [],
+    defectCategories: [],
+    units: [],
+    unitProgress: { units: [], commonRated: 0, total: 0 },
+    unitInspectionMode: "tagged",
+    templateSnapshot: { schemaVersion: 2, sections: [] },
+    revisionStatus: null,
+    statutoryDetails: null,
+    statutoryCoverage: null,
+    compliance: {
+      reportSignoffs: [],
+      psq: null,
+      documentReview: [],
+      conformance: { standard: "E2018-24", conforms: false }
+    },
+    pcaNarrative: { ...EMPTY_PCA_NARRATIVE },
+    relianceText: { userReliance: "", pointInTime: "", siteSpecific: "" },
+    commercialPresets: {},
+    nextPublishIsAmendment: false,
+    outboundCoolingWindow: null,
+    resultId: null,
+    ...overrides
+  };
+}
+var DEFAULT_PREFS = {
+  cloneDefault: "rating_notes",
+  autoAdvance: "always",
+  autoAdvanceDelayMs: 200,
+  pinnedTagIds: [],
+  requireDefectFields: "none",
+  agentRepairAccess: "readwrite",
+  reportLinkTtl: "never"
+};
+function createFakePrefs(initial = {}) {
+  let current = { ...DEFAULT_PREFS, ...initial };
+  let failure = null;
+  const patches = [];
+  return {
+    get patches() {
+      return patches;
+    },
+    failPatch(error) {
+      failure = error;
+    },
+    load: async () => ({ ...current, pinnedTagIds: [...current.pinnedTagIds] }),
+    patch: async (delta) => {
+      if (failure !== null) return { ok: false, error: failure };
+      patches.push(delta);
+      current = { ...current, ...delta };
+      return { ok: true, data: { ...current, pinnedTagIds: [...current.pinnedTagIds] } };
+    }
+  };
+}
+function createFakeDataSource(seed) {
+  const commands = [];
+  const purged = [];
+  const notifications = [];
+  const uploads = [];
+  let uploadFailure = null;
+  const failures = /* @__PURE__ */ new Map();
+  const responses = /* @__PURE__ */ new Map();
+  const records = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  let online = seed.online ?? true;
+  let putFailure = null;
+  let reloadCount = 0;
+  let exitCount = 0;
+  let restartCount = 0;
+  const openedUrls = [];
+  const ds = {
+    get commands() {
+      return commands;
+    },
+    get purged() {
+      return purged;
+    },
+    get notifications() {
+      return notifications;
+    },
+    get uploads() {
+      return uploads;
+    },
+    failUpload(error) {
+      uploadFailure = error;
+    },
+    get reloadCount() {
+      return reloadCount;
+    },
+    get restartCount() {
+      return restartCount;
+    },
+    get openedUrls() {
+      return openedUrls;
+    },
+    get exitCount() {
+      return exitCount;
+    },
+    failExecute(type, error) {
+      failures.set(type, error);
+    },
+    failMediaPut(error) {
+      putFailure = error;
+    },
+    respondWith(key, data) {
+      responses.set(key, data);
+    },
+    setOnline(next) {
+      online = next;
+      for (const cb of [...listeners]) cb(next);
+    },
+    load: async () => seed.data,
+    session: () => {
+      const o = seed.session ?? {};
+      return {
+        tenantSlug: pick(o.tenantSlug, DEFAULT_SESSION.tenantSlug),
+        videoProvider: pick(o.videoProvider, DEFAULT_SESSION.videoProvider),
+        streamCustomerSubdomain: pick(o.streamCustomerSubdomain, DEFAULT_SESSION.streamCustomerSubdomain),
+        collabEditing: pick(o.collabEditing, DEFAULT_SESSION.collabEditing),
+        userId: pick(o.userId, DEFAULT_SESSION.userId),
+        role: pick(o.role, DEFAULT_SESSION.role),
+        locale: pick(o.locale, DEFAULT_SESSION.locale),
+        timeZone: pick(o.timeZone, DEFAULT_SESSION.timeZone),
+        dateFormat: pick(o.dateFormat, DEFAULT_SESSION.dateFormat),
+        timeFormat: pick(o.timeFormat, DEFAULT_SESSION.timeFormat),
+        tenantDateFormat: pick(o.tenantDateFormat, DEFAULT_SESSION.tenantDateFormat),
+        tenantTimeFormat: pick(o.tenantTimeFormat, DEFAULT_SESSION.tenantTimeFormat)
+      };
+    },
+    execute: async (inspectionId, cmd, opts) => {
+      commands.push(
+        opts?.idempotencyKey === void 0 ? { inspectionId, cmd } : { inspectionId, cmd, idempotencyKey: opts.idempotencyKey }
+      );
+      const error = failures.get(cmd.type);
+      const data = responses.get(commandKey(cmd));
+      const result = error === void 0 ? { ok: true } : { ok: false, error };
+      if (data !== void 0) result.data = data;
+      return result;
+    },
+    notify: (message, variant, opts) => {
+      notifications.push({
+        message,
+        variant,
+        ...opts?.durationMs === void 0 ? {} : { durationMs: opts.durationMs },
+        ...opts?.action === void 0 ? {} : { action: opts.action }
+      });
+    },
+    reload: () => {
+      reloadCount += 1;
+    },
+    ...seed.without?.includes("restartSession") ? {} : { restartSession: () => void (restartCount += 1) },
+    ...seed.without?.includes("openUrl") ? {} : { openUrl: (url) => void openedUrls.push(url) },
+    exit: () => {
+      exitCount += 1;
+    },
+    isOnline: () => online,
+    onOnlineChange: (cb) => {
+      listeners.add(cb);
+      return () => {
+        listeners.delete(cb);
+      };
+    },
+    collab: {
+      connect: (_inspectionId, opts) => {
+        const doc = new Y.Doc();
+        let destroyed = false;
+        doc.on("update", () => {
+          if (!destroyed) opts.onChange?.();
+        });
+        queueMicrotask(() => opts.onSynced?.());
+        return {
+          doc,
+          persistenceSynced: Promise.resolve(),
+          synced: () => true,
+          destroy: () => {
+            destroyed = true;
+            doc.destroy();
+          }
+        };
+      },
+      purge: async (inspectionId) => {
+        purged.push(inspectionId);
+      }
+    },
+    media: {
+      store: {
+        put: async (rec) => {
+          if (putFailure) throw putFailure;
+          records.set(rec.pendingId, rec);
+        },
+        get: async (pendingId) => records.get(pendingId) ?? null,
+        list: async (inspectionId) => [...records.values()].filter((r) => inspectionId === void 0 || r.inspectionId === inspectionId),
+        delete: async (pendingId) => {
+          records.delete(pendingId);
+        },
+        objectUrl: async (pendingId) => records.has(pendingId) ? `blob:fake/${pendingId}` : null
+      },
+      uploader: (inspectionId, doc) => ({
+        upload: async (rec) => {
+          uploads.push({ inspectionId, rec, hadDoc: doc !== null });
+          return uploadFailure === null ? { ok: true, key: `uploaded/${rec.pendingId}` } : { ok: false, error: uploadFailure };
+        }
+      })
+    },
+    urls: { ...DEFAULT_URLS, ...seed.urls },
+    resources: { ...seed.resources },
+    platform: seed.platform ?? "web"
+  };
+  return ds;
+}
+export {
+  createEmptyEditorData,
+  createFakeAiAssist,
+  createFakeCommentsLibrary,
+  createFakeCostItems,
+  createFakeDataSource,
+  createFakeMediaPool,
+  createFakePrefs,
+  createFakeRepairItems,
+  createFakeSettingsSheet,
+  createFakeTemplateSearch,
+  createFakeVersionHistory,
+  createFakeVideo
+};