kaafil-react-uikit 0.1.0-beta.1

package/dist/chunk-PJRZCOFF.cjs

@@ -0,0 +1,958 @@
+'use strict';
+
+var chunkLL243STJ_cjs = require('./chunk-LL243STJ.cjs');
+var chunkPTQ2CJKE_cjs = require('./chunk-PTQ2CJKE.cjs');
+var chunkEM7JV3D7_cjs = require('./chunk-EM7JV3D7.cjs');
+var react = require('react');
+var client = require('kaafil-js/client');
+
+function useAgencyAdminMe() {
+  const client = chunkEM7JV3D7_cjs.useKaafilClient();
+  const [result, setResult] = react.useState({ status: "loading" });
+  react.useEffect(() => {
+    let cancelled = false;
+    setResult({ status: "loading" });
+    client.agencyAdminMe.read().then((response) => {
+      if (cancelled) {
+        return;
+      }
+      setResult({ status: "ready", agencyAdmin: response.agencyAdmin });
+    }).catch(() => {
+      if (!cancelled) {
+        setResult({ status: "error" });
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [client]);
+  return result;
+}
+function useAgencyChecklistTemplates() {
+  const client = chunkEM7JV3D7_cjs.useKaafilClient();
+  const [templates, setTemplates] = react.useState([]);
+  const [loaded, setLoaded] = react.useState(false);
+  const [lastFetchFailed, setLastFetchFailed] = react.useState(false);
+  const refresh = react.useCallback(async () => {
+    try {
+      const response = await client.checklists.agencyTemplates.list({});
+      setTemplates(response.templates);
+      setLoaded(true);
+      setLastFetchFailed(false);
+    } catch {
+      setLastFetchFailed(true);
+    }
+  }, [client]);
+  react.useEffect(() => {
+    void refresh();
+  }, [refresh]);
+  const createTemplate = react.useCallback(
+    async (input) => {
+      const response = await client.checklists.agencyTemplates.create(input);
+      void refresh();
+      return response;
+    },
+    [client, refresh]
+  );
+  const patchTemplate = react.useCallback(
+    async (input) => {
+      const response = await client.checklists.agencyTemplates.patch(input);
+      void refresh();
+      return response;
+    },
+    [client, refresh]
+  );
+  const removeTemplate = react.useCallback(
+    async (input) => {
+      await client.checklists.agencyTemplates.remove(input);
+      void refresh();
+    },
+    [client, refresh]
+  );
+  const publishTemplate = react.useCallback(
+    async (input) => {
+      const response = await client.checklists.agencyTemplates.publish(input);
+      void refresh();
+      return response;
+    },
+    [client, refresh]
+  );
+  return {
+    templates,
+    loaded,
+    lastFetchFailed,
+    refresh,
+    createTemplate,
+    patchTemplate,
+    removeTemplate,
+    publishTemplate
+  };
+}
+function useAgencyForms() {
+  const client = chunkEM7JV3D7_cjs.useKaafilClient();
+  const [forms, setForms] = react.useState([]);
+  const [loaded, setLoaded] = react.useState(false);
+  const [lastFetchFailed, setLastFetchFailed] = react.useState(false);
+  const refresh = react.useCallback(async () => {
+    try {
+      const response = await client.forms.list({});
+      setForms(response.items);
+      setLoaded(true);
+      setLastFetchFailed(false);
+    } catch {
+      setLastFetchFailed(true);
+    }
+  }, [client]);
+  react.useEffect(() => {
+    void refresh();
+  }, [refresh]);
+  const createForm = react.useCallback(
+    async (input) => {
+      const response = await client.forms.create(input);
+      void refresh();
+      return response;
+    },
+    [client, refresh]
+  );
+  const getForm = react.useCallback(
+    async (formId) => client.forms.get({ formId }),
+    [client]
+  );
+  const patchForm = react.useCallback(
+    async (input) => {
+      const response = await client.forms.patch(input);
+      void refresh();
+      return response;
+    },
+    [client, refresh]
+  );
+  const deleteForm = react.useCallback(
+    async (input) => {
+      await client.forms.delete(input);
+      void refresh();
+    },
+    [client, refresh]
+  );
+  const archiveForm = react.useCallback(
+    async (formId) => {
+      const response = await client.forms.archive({ formId });
+      void refresh();
+      return response;
+    },
+    [client, refresh]
+  );
+  const unarchiveForm = react.useCallback(
+    async (formId) => {
+      const response = await client.forms.unarchive({ formId });
+      void refresh();
+      return response;
+    },
+    [client, refresh]
+  );
+  const publishForm = react.useCallback(
+    async (formId) => {
+      const response = await client.forms.publish({ formId });
+      void refresh();
+      return response;
+    },
+    [client, refresh]
+  );
+  const closeForm = react.useCallback(
+    async (formId) => {
+      const response = await client.forms.close({ formId });
+      void refresh();
+      return response;
+    },
+    [client, refresh]
+  );
+  const reopenForm = react.useCallback(
+    async (formId) => {
+      const response = await client.forms.reopen({ formId });
+      void refresh();
+      return response;
+    },
+    [client, refresh]
+  );
+  const cloneForm = react.useCallback(
+    async (input) => {
+      const response = await client.forms.clone(input);
+      void refresh();
+      return response;
+    },
+    [client, refresh]
+  );
+  const reorderForm = react.useCallback(
+    async (input) => {
+      await client.forms.reorder(input);
+    },
+    [client]
+  );
+  const createSection = react.useCallback(
+    async (input) => client.forms.sections.create(input),
+    [client]
+  );
+  const patchSection = react.useCallback(
+    async (input) => client.forms.sections.patch(input),
+    [client]
+  );
+  const deleteSection = react.useCallback(
+    async (input) => {
+      await client.forms.sections.delete(input);
+    },
+    [client]
+  );
+  const createField = react.useCallback(
+    async (input) => client.forms.fields.create(input),
+    [client]
+  );
+  const patchField = react.useCallback(
+    async (input) => client.forms.fields.patch(input),
+    [client]
+  );
+  const deleteField = react.useCallback(
+    async (input) => {
+      await client.forms.fields.delete(input);
+    },
+    [client]
+  );
+  const listBindings = react.useCallback(async () => {
+    const response = await client.forms.bindings.list();
+    return response.items;
+  }, [client]);
+  return {
+    forms,
+    loaded,
+    lastFetchFailed,
+    refresh,
+    createForm,
+    getForm,
+    patchForm,
+    deleteForm,
+    archiveForm,
+    unarchiveForm,
+    publishForm,
+    closeForm,
+    reopenForm,
+    cloneForm,
+    reorderForm,
+    createSection,
+    patchSection,
+    deleteSection,
+    createField,
+    patchField,
+    deleteField,
+    listBindings
+  };
+}
+function useAgencyJourneyTriggers() {
+  const client = chunkEM7JV3D7_cjs.useKaafilClient();
+  const [triggers, setTriggers] = react.useState([]);
+  const [loaded, setLoaded] = react.useState(false);
+  const [lastFetchFailed, setLastFetchFailed] = react.useState(false);
+  const refresh = react.useCallback(async () => {
+    try {
+      const response = await client.journey.triggers.list({});
+      setTriggers(response);
+      setLoaded(true);
+      setLastFetchFailed(false);
+    } catch {
+      setLastFetchFailed(true);
+    }
+  }, [client]);
+  react.useEffect(() => {
+    void refresh();
+  }, [refresh]);
+  const patchTrigger = react.useCallback(
+    async (input) => {
+      const response = await client.journey.triggers.patch(input);
+      void refresh();
+      return response;
+    },
+    [client, refresh]
+  );
+  return { triggers, loaded, lastFetchFailed, refresh, patchTrigger };
+}
+function useAgencyManagerProfile(managerRef) {
+  const client = chunkEM7JV3D7_cjs.useKaafilClient();
+  const [read, setRead] = react.useState(void 0);
+  const [readFailed, setReadFailed] = react.useState(false);
+  const refresh = react.useCallback(async () => {
+    try {
+      const response = await client.agencies.managers.get({ managerRef });
+      setRead(response);
+      setReadFailed(false);
+    } catch {
+      setReadFailed(true);
+    }
+  }, [client, managerRef]);
+  react.useEffect(() => {
+    void refresh();
+  }, [refresh]);
+  return { read, readFailed, refresh };
+}
+function useAgencySettings() {
+  const client = chunkEM7JV3D7_cjs.useKaafilClient();
+  const [document, setDocument] = react.useState(void 0);
+  const [loaded, setLoaded] = react.useState(false);
+  const [lastFetchFailed, setLastFetchFailed] = react.useState(false);
+  const refresh = react.useCallback(async () => {
+    try {
+      const response = await client.agencies.settings.get({});
+      setDocument(response);
+      setLoaded(true);
+      setLastFetchFailed(false);
+    } catch {
+      setLastFetchFailed(true);
+    }
+  }, [client]);
+  react.useEffect(() => {
+    void refresh();
+  }, [refresh]);
+  const patchSettings = react.useCallback(
+    async (input) => {
+      const response = await client.agencies.settings.patch(input);
+      void refresh();
+      return response;
+    },
+    [client, refresh]
+  );
+  return { document, loaded, lastFetchFailed, refresh, patchSettings };
+}
+function useAgencyTrip(tripRef) {
+  const client = chunkEM7JV3D7_cjs.useKaafilClient();
+  const [read, setRead] = react.useState(void 0);
+  const [readFailed, setReadFailed] = react.useState(false);
+  const refresh = react.useCallback(async () => {
+    try {
+      const response = await client.agencies.trips.get({ tripRef });
+      setRead(response);
+      setReadFailed(false);
+    } catch {
+      setReadFailed(true);
+    }
+  }, [client, tripRef]);
+  react.useEffect(() => {
+    void refresh();
+  }, [refresh]);
+  return { read, readFailed, refresh };
+}
+var DEFAULT_PAGE_LIMIT = 20;
+var GROUPED_PAGE_LIMIT = 200;
+function useAgencyTripManifest(tripRef) {
+  const client = chunkEM7JV3D7_cjs.useKaafilClient();
+  const [facets, setFacets] = react.useState(void 0);
+  const mountedRef = react.useRef(true);
+  react.useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const makeManifestFetch = react.useCallback(
+    (filters, pageSize) => async (cursor) => {
+      const page = await client.agencies.trips.manifest.listPage({
+        tripRef,
+        ...filters,
+        cursor,
+        limit: pageSize ?? DEFAULT_PAGE_LIMIT
+      });
+      if (mountedRef.current) {
+        setFacets(page.facets);
+      }
+      return {
+        rows: page,
+        nextCursor: page.meta.page.hasNext ? page.meta.page.cursor ?? void 0 : void 0
+      };
+    },
+    [client, tripRef]
+  );
+  return { makeManifestFetch, facets, groupedPageSize: GROUPED_PAGE_LIMIT };
+}
+var DEFAULT_PAGE_LIMIT2 = 20;
+function useAgencyTrips() {
+  const client = chunkEM7JV3D7_cjs.useKaafilClient();
+  const [segmentCounts, setSegmentCounts] = react.useState(
+    void 0
+  );
+  const mountedRef = react.useRef(true);
+  react.useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const makeTripsFetch = react.useCallback(
+    (filters) => async (cursor) => {
+      const page = await client.agencies.trips.listPage({
+        ...filters,
+        cursor,
+        limit: DEFAULT_PAGE_LIMIT2
+      });
+      if (mountedRef.current) {
+        setSegmentCounts(page.facets.segments);
+      }
+      return {
+        rows: page,
+        nextCursor: page.meta.page.hasNext ? page.meta.page.cursor ?? void 0 : void 0
+      };
+    },
+    [client]
+  );
+  return { makeTripsFetch, segmentCounts };
+}
+var useBookingsInternal = chunkLL243STJ_cjs.createDomainHook("bookings", (tripRef) => {
+  const {
+    rows: bookings,
+    syncedAt,
+    refreshLive
+  } = chunkLL243STJ_cjs.useSnapshotList(tripRef, "bookings", {
+    live: async (liveClient, ref) => {
+      const response = await liveClient.bookings.list({ tripRef: ref });
+      return { rows: [...response], syncedAt: response.meta.serverTime };
+    }
+  });
+  const vouchersMutation = chunkEM7JV3D7_cjs.useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => engine.enqueue({
+      tripRef,
+      method: client.SyncOpMethod.Patch,
+      path: `/api/v1/trips/${tripRef}/bookings/${input.bookingRef}/vouchers`,
+      // Hardcoded literal, not imported: `OperationId` is not exported from
+      // `kaafil-js/client`'s public surface (the reasoning `useRooming.ts`
+      // documents). Verified against `kaafil-js/src/generated/security.ts`:
+      // `OperationId.ReplaceBookingVouchers === 'replaceBookingVouchers'`.
+      operationId: "replaceBookingVouchers",
+      body: { voucherFileKeys: [...input.voucherFileKeys] }
+    }),
+    // THE DESK LANE, and the only lane that matters in practice: filing a
+    // voucher is desk work and a desk console mounts no `OfflineShell`. The
+    // outbox lane above exists because this hook cannot know which shell it
+    // is under, not because a manager can call this route — they cannot.
+    direct: (liveClient, input) => liveClient.bookings.vouchers.replace({
+      tripRef,
+      bookingRef: input.bookingRef,
+      voucherFileKeys: [...input.voucherFileKeys]
+    })
+  });
+  const mutate = vouchersMutation.mutate;
+  const replaceVouchers = react.useCallback(
+    async (input) => {
+      await mutate(input);
+      await refreshLive();
+    },
+    [mutate, refreshLive]
+  );
+  return { bookings, syncedAt, refreshLive, replaceVouchers };
+});
+function useBookings(tripRef) {
+  return useBookingsInternal(tripRef);
+}
+function useCapabilityStatuses(tripRef) {
+  const { rows, loaded } = chunkEM7JV3D7_cjs.useCapabilityRows(tripRef);
+  const statuses = react.useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const row of rows) map.set(row.capability, chunkEM7JV3D7_cjs.deriveCapabilityTriple(row).status);
+    return map;
+  }, [rows]);
+  return { statuses, loaded };
+}
+var DEFAULT_PAGE_LIMIT3 = 20;
+var DirectoriesWriteError = class _DirectoriesWriteError extends Error {
+  classification;
+  constructor(classification) {
+    super(
+      classification.cause instanceof Error ? classification.cause.message : "The directory write failed."
+    );
+    this.name = "DirectoriesWriteError";
+    Object.setPrototypeOf(this, _DirectoriesWriteError.prototype);
+    this.classification = classification;
+  }
+};
+function useDirectories(agencyRef) {
+  const client = chunkEM7JV3D7_cjs.useKaafilClient();
+  const serverTime = chunkPTQ2CJKE_cjs.useServerTime();
+  const makeManagersFetch = react.useCallback(
+    (filters) => async (cursor) => {
+      const page = await client.agencies.managers.listPage({
+        ...filters,
+        cursor,
+        limit: DEFAULT_PAGE_LIMIT3
+      });
+      return {
+        rows: page,
+        nextCursor: page.meta.page.hasNext ? page.meta.page.cursor ?? void 0 : void 0
+      };
+    },
+    [client]
+  );
+  const makeTravellersFetch = react.useCallback(
+    (filters) => async (cursor) => {
+      const page = await client.travellers.listForAgencyPage({
+        ...filters,
+        cursor,
+        limit: DEFAULT_PAGE_LIMIT3
+      });
+      return {
+        rows: page,
+        nextCursor: page.meta.page.hasNext ? page.meta.page.cursor ?? void 0 : void 0
+      };
+    },
+    [client]
+  );
+  const listTripManifest = react.useCallback(
+    async (tripRef) => {
+      const response = await client.travellers.listForTrip({ tripRef });
+      return response;
+    },
+    [client]
+  );
+  const promoteManager = react.useCallback(
+    async (input) => {
+      try {
+        return await client.trips.managers.patch({
+          tripRef: input.tripRef,
+          managerRef: input.managerRef,
+          version: input.version,
+          role: input.role,
+          isLead: input.isLead
+        });
+      } catch (error) {
+        throw new DirectoriesWriteError(chunkLL243STJ_cjs.classifyError(error));
+      }
+    },
+    [client]
+  );
+  const assignManager = react.useCallback(
+    async (input) => {
+      try {
+        await client.trips.managers.assign({
+          tripRef: input.tripRef,
+          managerRef: input.managerRef,
+          ...input.role === void 0 ? {} : { role: input.role },
+          ...input.isLead === void 0 ? {} : { isLead: input.isLead }
+        });
+      } catch (error) {
+        throw new DirectoriesWriteError(chunkLL243STJ_cjs.classifyError(error));
+      }
+    },
+    [client]
+  );
+  const unassignManager = react.useCallback(
+    async (input) => {
+      try {
+        await client.trips.managers.unassign({
+          tripRef: input.tripRef,
+          managerRef: input.managerRef
+        });
+      } catch (error) {
+        throw new DirectoriesWriteError(chunkLL243STJ_cjs.classifyError(error));
+      }
+    },
+    [client]
+  );
+  const addTraveller = react.useCallback(
+    async (input) => {
+      try {
+        const response = await client.trips.travellers.pushManifest({
+          tripRef: input.tripRef,
+          travellers: [
+            {
+              externalTravellerId: input.externalTravellerId,
+              fullName: input.fullName,
+              phone: input.phone,
+              sourceUpdatedAt: serverTime.now()
+            }
+          ]
+        });
+        const item = response.items.find(
+          (entry) => entry.externalTravellerId === input.externalTravellerId
+        );
+        if (item === void 0 || item.verdict !== "applied") {
+          throw new DirectoriesWriteError({
+            path: "surface-to-user",
+            code: item?.verdict === "rejected" ? "BUSINESS_RULE_VIOLATION" : void 0,
+            status: void 0,
+            unsatisfiableScheme: false,
+            cause: void 0
+          });
+        }
+        return item.externalTravellerId;
+      } catch (error) {
+        if (error instanceof DirectoriesWriteError) {
+          throw error;
+        }
+        throw new DirectoriesWriteError(chunkLL243STJ_cjs.classifyError(error));
+      }
+    },
+    [client, serverTime]
+  );
+  const createAgencyTraveller = react.useCallback(
+    async (input) => {
+      try {
+        return await client.travellers.create({
+          fullName: input.fullName,
+          phone: input.phone,
+          email: input.email,
+          locale: input.locale,
+          externalTravellerId: input.externalTravellerId
+        });
+      } catch (error) {
+        throw new DirectoriesWriteError(chunkLL243STJ_cjs.classifyError(error));
+      }
+    },
+    [client]
+  );
+  const removeFromManifest = react.useCallback(
+    async (input) => {
+      try {
+        await client.trips.travellers.remove({
+          tripRef: input.tripRef,
+          travellerRef: input.travellerRef
+        });
+      } catch (error) {
+        throw new DirectoriesWriteError(chunkLL243STJ_cjs.classifyError(error));
+      }
+    },
+    [client]
+  );
+  const createParty = react.useCallback(
+    async (input) => {
+      try {
+        return await client.trips.parties.add({
+          tripRef: input.tripRef,
+          kind: input.kind,
+          ...input.label !== void 0 ? { label: input.label } : {},
+          travellerRefs: [...input.travellerRefs]
+        });
+      } catch (error) {
+        throw new DirectoriesWriteError(chunkLL243STJ_cjs.classifyError(error));
+      }
+    },
+    [client]
+  );
+  const patchParty = react.useCallback(
+    async (input) => {
+      try {
+        return await client.trips.parties.patch({
+          tripRef: input.tripRef,
+          partyId: input.partyId,
+          version: input.version,
+          ...input.kind !== void 0 ? { kind: input.kind } : {},
+          ...input.label !== void 0 ? { label: input.label } : {},
+          ...input.travellerRefs !== void 0 ? { travellerRefs: [...input.travellerRefs] } : {}
+        });
+      } catch (error) {
+        throw new DirectoriesWriteError(chunkLL243STJ_cjs.classifyError(error));
+      }
+    },
+    [client]
+  );
+  const deleteParty = react.useCallback(
+    async (input) => {
+      try {
+        await client.trips.parties.remove({ tripRef: input.tripRef, partyId: input.partyId });
+      } catch (error) {
+        throw new DirectoriesWriteError(chunkLL243STJ_cjs.classifyError(error));
+      }
+    },
+    [client]
+  );
+  const addTravellerNote = react.useCallback(
+    async (input) => {
+      try {
+        await client.travellers.addNote({
+          tripRef: input.tripRef,
+          travellerRef: input.travellerRef,
+          body: input.body
+        });
+      } catch (error) {
+        throw new DirectoriesWriteError(chunkLL243STJ_cjs.classifyError(error));
+      }
+    },
+    [client]
+  );
+  return {
+    makeManagersFetch,
+    makeTravellersFetch,
+    listTripManifest,
+    promoteManager,
+    assignManager,
+    unassignManager,
+    addTraveller,
+    createAgencyTraveller,
+    removeFromManifest,
+    createParty,
+    patchParty,
+    deleteParty,
+    addTravellerNote
+  };
+}
+function usePaginatedList(fetch, options) {
+  const [rows, setRows] = react.useState([]);
+  const [hasNext, setHasNext] = react.useState(false);
+  const [pageIndex, setPageIndex] = react.useState(0);
+  const fetchRef = react.useRef(fetch);
+  fetchRef.current = fetch;
+  const cursorsRef = react.useRef([void 0]);
+  const loadPage = react.useCallback(async (index) => {
+    const cursor = cursorsRef.current[index];
+    const result = await fetchRef.current(cursor);
+    cursorsRef.current = cursorsRef.current.slice(0, index + 1);
+    if (result.nextCursor !== void 0) {
+      cursorsRef.current[index + 1] = result.nextCursor;
+    }
+    setRows(result.rows);
+    setHasNext(result.nextCursor !== void 0);
+    setPageIndex(index);
+  }, []);
+  react.useEffect(() => {
+    void loadPage(0);
+  }, [loadPage]);
+  const loadNext = react.useCallback(async () => {
+    if (!hasNext) {
+      return;
+    }
+    await loadPage(pageIndex + 1);
+  }, [hasNext, pageIndex, loadPage]);
+  const loadPrev = react.useCallback(async () => {
+    if (pageIndex === 0) {
+      return;
+    }
+    await loadPage(pageIndex - 1);
+  }, [pageIndex, loadPage]);
+  return { rows, hasNext, hasPrev: pageIndex > 0, loadNext, loadPrev };
+}
+var SHARE_SECTION_KEYS = [
+  "itinerary",
+  "rooming",
+  "seating",
+  "checklists",
+  "pickup",
+  "accommodation",
+  "transport",
+  "activities",
+  "documents",
+  "money",
+  "managerContact",
+  "agencyContact",
+  "household",
+  "forms"
+];
+function familySafeSections(isFamilyLink) {
+  return isFamilyLink ? SHARE_SECTION_KEYS.filter((key) => key !== "money") : SHARE_SECTION_KEYS;
+}
+var ShareLinkWriteError = class extends Error {
+  classification;
+  constructor(classification) {
+    super("Share-link write failed");
+    this.name = "ShareLinkWriteError";
+    this.classification = classification;
+  }
+};
+function useShareLinks(tripRef, travellerRef) {
+  const client = chunkEM7JV3D7_cjs.useKaafilClient();
+  const [links, setLinks] = react.useState(void 0);
+  const [readFailed, setReadFailed] = react.useState(false);
+  const refresh = react.useCallback(async () => {
+    try {
+      const response = await client.shareTokens.list({
+        tripRef,
+        ...travellerRef !== null ? { travellerRef } : {}
+      });
+      setLinks(response);
+      setReadFailed(false);
+    } catch (error) {
+      setReadFailed(true);
+    }
+  }, [client, tripRef, travellerRef]);
+  react.useEffect(() => {
+    void refresh();
+  }, [refresh]);
+  const mint = react.useCallback(
+    async (input) => {
+      try {
+        const minted = await client.shareTokens.create({
+          tripRef,
+          ...input.travellerRef !== void 0 ? { travellerRef: input.travellerRef } : {},
+          ...input.sections !== void 0 ? { config: { sections: input.sections } } : {},
+          ...input.ttlDays !== void 0 ? { ttlDays: input.ttlDays } : {},
+          ...input.expiresAt !== void 0 ? { expiresAt: input.expiresAt } : {}
+        });
+        await refresh();
+        return minted;
+      } catch (error) {
+        throw new ShareLinkWriteError(chunkLL243STJ_cjs.classifyError(error));
+      }
+    },
+    [client, tripRef, refresh]
+  );
+  const revoke = react.useCallback(
+    async (id) => {
+      try {
+        await client.shareTokens.revoke({ id });
+        await refresh();
+      } catch (error) {
+        throw new ShareLinkWriteError(chunkLL243STJ_cjs.classifyError(error));
+      }
+    },
+    [client, refresh]
+  );
+  const patch = react.useCallback(
+    async (input) => {
+      try {
+        await client.shareTokens.patch({
+          id: input.id,
+          version: input.version,
+          ...input.sections !== void 0 ? { config: { sections: input.sections } } : {},
+          ...input.expiresAt !== void 0 ? { expiresAt: input.expiresAt } : {}
+        });
+        await refresh();
+      } catch (error) {
+        throw new ShareLinkWriteError(chunkLL243STJ_cjs.classifyError(error));
+      }
+    },
+    [client, refresh]
+  );
+  const regenerate = react.useCallback(
+    async (id) => {
+      try {
+        const minted = await client.shareTokens.regenerate({ id });
+        await refresh();
+        return minted;
+      } catch (error) {
+        throw new ShareLinkWriteError(chunkLL243STJ_cjs.classifyError(error));
+      }
+    },
+    [client, refresh]
+  );
+  return { links, readFailed, refresh, mint, revoke, patch, regenerate };
+}
+function useTravellerFormResponses(tripRef, travellerRef) {
+  const client = chunkEM7JV3D7_cjs.useKaafilClient();
+  const [responses, setResponses] = react.useState(
+    void 0
+  );
+  const [readFailed, setReadFailed] = react.useState(false);
+  const refresh = react.useCallback(async () => {
+    if (travellerRef === null) {
+      setResponses(void 0);
+      setReadFailed(false);
+      return;
+    }
+    try {
+      const response = await client.forms.trip.travellerResponses.list({ tripRef, travellerRef });
+      setResponses(response.items);
+      setReadFailed(false);
+    } catch {
+      setReadFailed(true);
+    }
+  }, [client, tripRef, travellerRef]);
+  react.useEffect(() => {
+    void refresh();
+  }, [refresh]);
+  return { responses, readFailed, refresh };
+}
+
+// src/core/routing/deepLinks.ts
+var CLOSEOUT_ACTION_TAB = {
+  open_collections: "payments",
+  open_expenses: "expenses",
+  open_float: "float",
+  open_checklist: "checklist",
+  open_mandatory_checklist: "checklist",
+  open_forms: "forms",
+  open_rooming: "rooming",
+  open_seating: "vehicles",
+  open_pickups: "pickups",
+  open_itinerary: "itinerary",
+  open_past_itinerary: "itinerary",
+  open_vendors: "vendors"
+};
+var BLOCKER_PRESET_FILTER = {
+  balance_due: "outstanding",
+  missing_receipt: "missing-receipt",
+  open_mandatory_checklist: "open-mandatory",
+  required_form_gap: "outstanding-respondents",
+  unassigned_rooming: "unassigned",
+  // Mirrors `unassigned_rooming` — the spec gives seating the identical
+  // arrival contract, pointed at the seating pool instead of the bed pool.
+  unseated_travellers: "unassigned"
+  // DELIBERATELY ABSENT, each for its own reason:
+  //   `float_not_returned`, `pickup_no_show`, `open_past_itinerary` — these
+  //     arrive by `highlightId` on a single row, not by narrowing a list.
+  //   `reimbursements_pending` — see this map's header; filtering the
+  //     expense ledger to missing receipts would be actively wrong here.
+  //   `unrated_vendors` — see `resolveBlockerDeepLink`.
+};
+function resolveBlockerDeepLink(input) {
+  const tab = CLOSEOUT_ACTION_TAB[input.actionKey];
+  if (tab === void 0) return null;
+  const presetFilter = input.key === void 0 ? void 0 : BLOCKER_PRESET_FILTER[input.key];
+  return {
+    tab,
+    ...presetFilter !== void 0 ? { presetFilter } : {},
+    ...input.highlightId !== void 0 ? { highlightId: input.highlightId } : {}
+  };
+}
+var PARAM_TAB = "kfTab";
+var PARAM_HIGHLIGHT = "kfHighlight";
+var PARAM_FILTER = "kfFilter";
+function toSearchParams(link) {
+  const params = new URLSearchParams();
+  if (link.tab !== void 0) params.set(PARAM_TAB, link.tab);
+  if (link.highlightId !== void 0) params.set(PARAM_HIGHLIGHT, link.highlightId);
+  if (link.presetFilter !== void 0) params.set(PARAM_FILTER, link.presetFilter);
+  return params;
+}
+function fromSearchParams(params) {
+  const rawTab = params.get(PARAM_TAB);
+  const highlightId = params.get(PARAM_HIGHLIGHT);
+  const presetFilter = params.get(PARAM_FILTER);
+  if (rawTab === null && highlightId === null && presetFilter === null) return null;
+  const initialTab = isTripTabKey(rawTab) ? rawTab : void 0;
+  return {
+    ...initialTab !== void 0 ? { initialTab } : {},
+    ...highlightId !== null ? { highlightId } : {},
+    ...presetFilter !== null ? { presetFilter } : {}
+  };
+}
+function isTripTabKey(value) {
+  if (value === null || value === void 0) return false;
+  return Object.hasOwn(TRIP_TAB_KEY_SET, value);
+}
+var TRIP_TAB_KEY_SET = {
+  itinerary: true,
+  pickups: true,
+  rooming: true,
+  vehicles: true,
+  vendors: true,
+  payments: true,
+  expenses: true,
+  float: true,
+  checklist: true,
+  forms: true
+};
+
+exports.CLOSEOUT_ACTION_TAB = CLOSEOUT_ACTION_TAB;
+exports.familySafeSections = familySafeSections;
+exports.fromSearchParams = fromSearchParams;
+exports.isTripTabKey = isTripTabKey;
+exports.resolveBlockerDeepLink = resolveBlockerDeepLink;
+exports.toSearchParams = toSearchParams;
+exports.useAgencyAdminMe = useAgencyAdminMe;
+exports.useAgencyChecklistTemplates = useAgencyChecklistTemplates;
+exports.useAgencyForms = useAgencyForms;
+exports.useAgencyJourneyTriggers = useAgencyJourneyTriggers;
+exports.useAgencyManagerProfile = useAgencyManagerProfile;
+exports.useAgencySettings = useAgencySettings;
+exports.useAgencyTrip = useAgencyTrip;
+exports.useAgencyTripManifest = useAgencyTripManifest;
+exports.useAgencyTrips = useAgencyTrips;
+exports.useBookings = useBookings;
+exports.useCapabilityStatuses = useCapabilityStatuses;
+exports.useDirectories = useDirectories;
+exports.usePaginatedList = usePaginatedList;
+exports.useShareLinks = useShareLinks;
+exports.useTravellerFormResponses = useTravellerFormResponses;
+//# sourceMappingURL=chunk-PJRZCOFF.cjs.map
+//# sourceMappingURL=chunk-PJRZCOFF.cjs.map