@comapeo/core-react 9.0.1 → 10.0.0

package/dist/esm/lib/react-query.d.ts

@@ -0,0 +1,103 @@
+import type { QueryClient, UseMutationResult } from '@tanstack/react-query';
+import { DistributedPick } from 'type-fest';
+import type { WriteableDocumentType } from './types.js';
+export declare function baseQueryOptions(): {
+    networkMode: "always";
+    retry: false;
+};
+export declare function baseMutationOptions(): {
+    networkMode: "always";
+    retry: false;
+};
+declare const PICKED_MUTATION_RESULT_KEYS: readonly ["error", "mutate", "mutateAsync", "reset", "status"];
+export type FilteredMutationResult<TResult extends UseMutationResult<any, any, any, any>> = DistributedPick<TResult, (typeof PICKED_MUTATION_RESULT_KEYS)[number]>;
+/**
+ * Filters a `UseMutationResult` to only include a subset of its keys, and uses
+ * `DistributedPick` to preserve the discriminated union types of the mutation
+ * result based on the `status` property.
+ */
+export declare function filterMutationResult<TResult extends UseMutationResult<any, any, any, any>>(mutationResult: TResult): DistributedPick<TResult, "error" | "status" | "mutate" | "reset" | "mutateAsync">;
+export declare function getDeviceInfoQueryKey(): readonly ["@comapeo/core-react", "client", "device_info"];
+export declare function getIsArchiveDeviceQueryKey(): readonly ["@comapeo/core-react", "client", "is_archive_device"];
+export declare function getInvitesQueryKey(): readonly ["@comapeo/core-react", "invites"];
+export declare function getInvitesByIdQueryKey({ inviteId }: {
+    inviteId: string;
+}): readonly ["@comapeo/core-react", "invites", {
+    readonly inviteId: string;
+}];
+export declare function getMapQueryKey({ mapId }: {
+    mapId: string;
+}): readonly ["@comapeo/core-react", "maps", string];
+export declare function getMapInfoQueryKey({ mapId }: {
+    mapId: string;
+}): readonly ["@comapeo/core-react", "maps", string, "info"];
+export declare function getStyleJsonUrlQueryKey({ mapId }: {
+    mapId: string;
+}): readonly ["@comapeo/core-react", "maps", string, "stylejson_url"];
+/**
+ * Invalidate queries for this map and the default map (which internally
+ * redirects to custom) so that they will be refetched with the new map data.
+ */
+export declare function invalidateMapQueries(queryClient: QueryClient, { mapId }: {
+    mapId: string;
+}): Promise<void>;
+export declare function getProjectsQueryKey(): readonly ["@comapeo/core-react", "projects"];
+export declare function getProjectByIdQueryKey({ projectId }: {
+    projectId: string;
+}): readonly ["@comapeo/core-react", "projects", string];
+export declare function getProjectSettingsQueryKey({ projectId, }: {
+    projectId: string;
+}): readonly ["@comapeo/core-react", "projects", string, "project_settings"];
+export declare function getProjectRoleQueryKey({ projectId }: {
+    projectId: string;
+}): readonly ["@comapeo/core-react", "projects", string, "role"];
+export declare function getMembersQueryKey({ projectId, includeLeft, }: {
+    projectId: string;
+    includeLeft?: boolean;
+}): readonly ["@comapeo/core-react", "projects", string, "members", {
+    readonly includeLeft: boolean | undefined;
+}];
+export declare function getMemberByIdQueryKey({ projectId, deviceId, }: {
+    projectId: string;
+    deviceId: string;
+}): readonly ["@comapeo/core-react", "projects", string, "members", string];
+export declare function getDocumentCreatedByQueryKey({ projectId, originalVersionId, }: {
+    projectId: string;
+    originalVersionId: string;
+}): readonly ["@comapeo/core-react", "projects", string, "document_created_by", string];
+/**
+ * We call this within a project hook, because that's the only place the API is
+ * exposed right now, but it is the same for all projects, so no need for
+ * scoping the query key to the project
+ */
+export declare function getMediaServerOriginQueryKey(): readonly ["@comapeo/core-react", "media_server_origin"];
+export declare function getDocumentsQueryKey<D extends WriteableDocumentType>({ projectId, docType, }: {
+    projectId: string;
+    docType: D;
+}): readonly ["@comapeo/core-react", "projects", string, D];
+export declare function getManyDocumentsQueryKey<D extends WriteableDocumentType>({ projectId, docType, includeDeleted, lang, }: {
+    projectId: string;
+    docType: D;
+    includeDeleted?: boolean;
+    lang?: string;
+}): readonly ["@comapeo/core-react", "projects", string, D, {
+    readonly includeDeleted: boolean | undefined;
+    readonly lang: string | undefined;
+}];
+export declare function getDocumentByDocIdQueryKey<D extends WriteableDocumentType>({ projectId, docType, docId, lang, }: {
+    projectId: string;
+    docType: D;
+    docId: string;
+    lang?: string;
+}): readonly ["@comapeo/core-react", "projects", string, D, string, {
+    readonly lang: string | undefined;
+}];
+export declare function getDocumentByVersionIdQueryKey<D extends WriteableDocumentType>({ projectId, docType, versionId, lang, }: {
+    projectId: string;
+    docType: D;
+    versionId: string;
+    lang?: string;
+}): readonly ["@comapeo/core-react", "projects", string, D, string, {
+    readonly lang: string | undefined;
+}];
+export {};

package/dist/esm/lib/react-query.js

@@ -0,0 +1,162 @@
+import { DEFAULT_MAP_ID } from '@comapeo/map-server';
+// #region Shared
+const ROOT_QUERY_KEY = '@comapeo/core-react';
+// Since the API is running locally, queries should run regardless of network
+// status, and should not be retried. In React Native the API consumer would
+// have to manually set the network mode, but we still should keep these options
+// to avoid surprises. Not using the queryClient `defaultOptions` because the API
+// consumer might also use the same queryClient for network queries
+export function baseQueryOptions() {
+    return {
+        networkMode: 'always',
+        retry: false,
+    };
+}
+export function baseMutationOptions() {
+    return {
+        networkMode: 'always',
+        retry: false,
+    };
+}
+const PICKED_MUTATION_RESULT_KEYS = [
+    'error',
+    'mutate',
+    'mutateAsync',
+    'reset',
+    'status',
+];
+/**
+ * Filters a `UseMutationResult` to only include a subset of its keys, and uses
+ * `DistributedPick` to preserve the discriminated union types of the mutation
+ * result based on the `status` property.
+ */
+export function filterMutationResult(mutationResult) {
+    const filteredResult = {};
+    for (const key of PICKED_MUTATION_RESULT_KEYS) {
+        filteredResult[key] = mutationResult[key];
+    }
+    return filteredResult;
+}
+// #endregion
+// #region Client
+function getClientQueryKey() {
+    return [ROOT_QUERY_KEY, 'client'];
+}
+export function getDeviceInfoQueryKey() {
+    return [...getClientQueryKey(), 'device_info'];
+}
+export function getIsArchiveDeviceQueryKey() {
+    return [...getClientQueryKey(), 'is_archive_device'];
+}
+// #endregion
+// #region Invites
+export function getInvitesQueryKey() {
+    return [ROOT_QUERY_KEY, 'invites'];
+}
+export function getInvitesByIdQueryKey({ inviteId }) {
+    return [ROOT_QUERY_KEY, 'invites', { inviteId }];
+}
+// #endregion
+// #region Maps
+const MAPS_ROOT_QUERY_KEY = [ROOT_QUERY_KEY, 'maps'];
+export function getMapQueryKey({ mapId }) {
+    return [...MAPS_ROOT_QUERY_KEY, mapId];
+}
+export function getMapInfoQueryKey({ mapId }) {
+    return [...getMapQueryKey({ mapId }), 'info'];
+}
+export function getStyleJsonUrlQueryKey({ mapId }) {
+    return [...getMapQueryKey({ mapId }), 'stylejson_url'];
+}
+/**
+ * Invalidate queries for this map and the default map (which internally
+ * redirects to custom) so that they will be refetched with the new map data.
+ */
+export async function invalidateMapQueries(queryClient, { mapId }) {
+    await Promise.all([
+        queryClient.invalidateQueries({
+            queryKey: getMapQueryKey({ mapId }),
+        }),
+        queryClient.invalidateQueries({
+            queryKey: getMapQueryKey({ mapId: DEFAULT_MAP_ID }),
+        }),
+    ]);
+}
+// #endregion
+// #region Projects
+export function getProjectsQueryKey() {
+    return [ROOT_QUERY_KEY, 'projects'];
+}
+export function getProjectByIdQueryKey({ projectId }) {
+    return [ROOT_QUERY_KEY, 'projects', projectId];
+}
+export function getProjectSettingsQueryKey({ projectId, }) {
+    return [ROOT_QUERY_KEY, 'projects', projectId, 'project_settings'];
+}
+export function getProjectRoleQueryKey({ projectId }) {
+    return [ROOT_QUERY_KEY, 'projects', projectId, 'role'];
+}
+export function getMembersQueryKey({ projectId, includeLeft, }) {
+    return [
+        ROOT_QUERY_KEY,
+        'projects',
+        projectId,
+        'members',
+        { includeLeft },
+    ];
+}
+export function getMemberByIdQueryKey({ projectId, deviceId, }) {
+    return [ROOT_QUERY_KEY, 'projects', projectId, 'members', deviceId];
+}
+export function getDocumentCreatedByQueryKey({ projectId, originalVersionId, }) {
+    return [
+        ROOT_QUERY_KEY,
+        'projects',
+        projectId,
+        'document_created_by',
+        originalVersionId,
+    ];
+}
+/**
+ * We call this within a project hook, because that's the only place the API is
+ * exposed right now, but it is the same for all projects, so no need for
+ * scoping the query key to the project
+ */
+export function getMediaServerOriginQueryKey() {
+    return [ROOT_QUERY_KEY, 'media_server_origin'];
+}
+// #endregion
+// #region Documents
+export function getDocumentsQueryKey({ projectId, docType, }) {
+    return [ROOT_QUERY_KEY, 'projects', projectId, docType];
+}
+export function getManyDocumentsQueryKey({ projectId, docType, includeDeleted, lang, }) {
+    return [
+        ROOT_QUERY_KEY,
+        'projects',
+        projectId,
+        docType,
+        { includeDeleted, lang },
+    ];
+}
+export function getDocumentByDocIdQueryKey({ projectId, docType, docId, lang, }) {
+    return [
+        ROOT_QUERY_KEY,
+        'projects',
+        projectId,
+        docType,
+        docId,
+        { lang },
+    ];
+}
+export function getDocumentByVersionIdQueryKey({ projectId, docType, versionId, lang, }) {
+    return [
+        ROOT_QUERY_KEY,
+        'projects',
+        projectId,
+        docType,
+        versionId,
+        { lang },
+    ];
+}
+// #endregion

package/dist/esm/lib/sync.d.ts

@@ -1,12 +1,9 @@
-import type { MapeoProjectApi } from '@comapeo/ipc' with {
-    'resolution-mode': 'import'
-};
+import type { MapeoProjectApi } from '@comapeo/ipc';
 export type SyncState = Awaited<ReturnType<MapeoProjectApi['$sync']['getState']>>;
-export declare function getDataSyncCountForDevice(syncStateForDevice: SyncState['remoteDeviceSyncState'][string]): number;
 export declare class SyncStore {
     #private;
     constructor(project: MapeoProjectApi);
     subscribe: (listener: () => void) => () => void;
-    getStateSnapshot: () => import("@comapeo/core/dist/sync/sync-api.js").State | null;
+    getStateSnapshot: () => SyncState | null;
     getDataProgressSnapshot: () => number | null;
 }

package/dist/esm/lib/sync.js

@@ -1,4 +1,4 @@
-export function getDataSyncCountForDevice(syncStateForDevice) {
+function getDataSyncCountForDevice(syncStateForDevice) {
     const { data } = syncStateForDevice;
     return data.want + data.wanted;
 }

package/dist/esm/lib/types.d.ts

@@ -1,11 +1,9 @@
-import type { MapeoDoc, MapeoValue } from '@comapeo/schema' with {
-    'resolution-mode': 'import'
-};
-export type WriteableDocumentType = Extract<MapeoDoc['schemaName'], 'field' | 'observation' | 'preset' | 'track' | 'remoteDetectionAlert'>;
-export type WriteableValue<D extends WriteableDocumentType> = Extract<MapeoValue, {
+import type { ComapeoDoc, ComapeoValue } from '@comapeo/core/schema.js';
+export type WriteableDocumentType = Extract<ComapeoDoc['schemaName'], 'field' | 'observation' | 'preset' | 'track' | 'remoteDetectionAlert'>;
+export type WriteableValue<D extends WriteableDocumentType> = Extract<ComapeoValue, {
     schemaName: D;
 }>;
-export type WriteableDocument<D extends WriteableDocumentType> = Extract<MapeoDoc, {
+export type WriteableDocument<D extends WriteableDocumentType> = Extract<ComapeoDoc, {
     schemaName: D;
 }>;
 export {};