@comapeo/core-react 1.0.1 → 2.0.0

package/dist/commonjs/lib/react-query/documents.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDocumentsQueryKey = getDocumentsQueryKey;
+exports.getManyDocumentsQueryKey = getManyDocumentsQueryKey;
+exports.getDocumentByDocIdQueryKey = getDocumentByDocIdQueryKey;
+exports.getDocumentByVersionIdQueryKey = getDocumentByVersionIdQueryKey;
+exports.documentsQueryOptions = documentsQueryOptions;
+exports.documentByDocumentIdQueryOptions = documentByDocumentIdQueryOptions;
+exports.documentByVersionIdQueryOptions = documentByVersionIdQueryOptions;
+exports.createDocumentMutationOptions = createDocumentMutationOptions;
+exports.updateDocumentMutationOptions = updateDocumentMutationOptions;
+exports.deleteDocumentMutationOptions = deleteDocumentMutationOptions;
+const react_query_1 = require("@tanstack/react-query");
+const shared_js_1 = require("./shared.js");
+function getDocumentsQueryKey({ projectId, docType, }) {
+    return [shared_js_1.ROOT_QUERY_KEY, 'projects', projectId, docType];
+}
+function getManyDocumentsQueryKey({ projectId, docType, includeDeleted, lang, }) {
+    return [
+        shared_js_1.ROOT_QUERY_KEY,
+        'projects',
+        projectId,
+        docType,
+        { includeDeleted, lang },
+    ];
+}
+function getDocumentByDocIdQueryKey({ projectId, docType, docId, lang, }) {
+    return [
+        shared_js_1.ROOT_QUERY_KEY,
+        'projects',
+        projectId,
+        docType,
+        docId,
+        { lang },
+    ];
+}
+function getDocumentByVersionIdQueryKey({ projectId, docType, versionId, lang, }) {
+    return [
+        shared_js_1.ROOT_QUERY_KEY,
+        'projects',
+        projectId,
+        docType,
+        versionId,
+        { lang },
+    ];
+}
+function documentsQueryOptions({ projectApi, projectId, docType, includeDeleted, lang, }) {
+    return (0, react_query_1.queryOptions)({
+        ...(0, shared_js_1.baseQueryOptions)(),
+        queryKey: getManyDocumentsQueryKey({
+            projectId,
+            docType,
+            includeDeleted,
+            lang,
+        }),
+        queryFn: async () => {
+            return projectApi[docType].getMany({
+                includeDeleted,
+                lang,
+            });
+        },
+    });
+}
+function documentByDocumentIdQueryOptions({ projectApi, projectId, docType, docId, lang, }) {
+    return (0, react_query_1.queryOptions)({
+        ...(0, shared_js_1.baseQueryOptions)(),
+        queryKey: getDocumentByDocIdQueryKey({
+            projectId,
+            docType,
+            docId,
+            lang,
+        }),
+        queryFn: async () => {
+            return projectApi[docType].getByDocId(docId, {
+                lang,
+                // We want to make sure that this throws in the case that no match is found
+                mustBeFound: true,
+            });
+        },
+    });
+}
+function documentByVersionIdQueryOptions({ projectApi, projectId, docType, versionId, lang, }) {
+    return (0, react_query_1.queryOptions)({
+        ...(0, shared_js_1.baseQueryOptions)(),
+        queryKey: getDocumentByVersionIdQueryKey({
+            projectId,
+            docType,
+            versionId,
+            lang,
+        }),
+        queryFn: async () => {
+            return projectApi[docType].getByVersionId(versionId, { lang });
+        },
+    });
+}
+function createDocumentMutationOptions({ docType, projectApi, projectId, queryClient, }) {
+    return {
+        ...(0, shared_js_1.baseMutationOptions)(),
+        mutationFn: async ({ value, }) => {
+            // @ts-expect-error TS not handling this well
+            return projectApi[docType].create({
+                ...value,
+                schemaName: docType,
+            });
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({
+                queryKey: getDocumentsQueryKey({
+                    projectId,
+                    docType,
+                }),
+            });
+        },
+    };
+}
+function updateDocumentMutationOptions({ docType, projectApi, projectId, queryClient, }) {
+    return {
+        ...(0, shared_js_1.baseMutationOptions)(),
+        mutationFn: async ({ versionId, value, }) => {
+            // @ts-expect-error TS not handling this well
+            return projectApi[docType].update(versionId, value);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({
+                queryKey: getDocumentsQueryKey({
+                    projectId,
+                    docType,
+                }),
+            });
+        },
+    };
+}
+function deleteDocumentMutationOptions({ docType, projectApi, projectId, queryClient, }) {
+    return {
+        ...(0, shared_js_1.baseMutationOptions)(),
+        mutationFn: async ({ docId, }) => {
+            // @ts-expect-error TS not handling this well
+            return projectApi[docType].delete(docId);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({
+                queryKey: getDocumentsQueryKey({
+                    projectId,
+                    docType,
+                }),
+            });
+        },
+    };
+}

package/dist/commonjs/lib/react-query/invites.d.ts

@@ -0,0 +1,71 @@
+import type { RoleIdForNewInvite } from '@comapeo/core/dist/roles.js' with { 'resolution-mode': 'import' };
+import type { MapeoClientApi, MapeoProjectApi } from '@comapeo/ipc' with { 'resolution-mode': 'import' };
+import { type QueryClient } from '@tanstack/react-query';
+export declare function getInvitesQueryKey(): readonly ["@comapeo/core-react", "invites"];
+export declare function getPendingInvitesQueryKey(): readonly ["@comapeo/core-react", "invites", {
+    readonly status: "pending";
+}];
+export declare function pendingInvitesQueryOptions({ clientApi, }: {
+    clientApi: MapeoClientApi;
+}): import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<import("@comapeo/core/dist/types.js", { with: { "resolution-mode": "import" } }).MapBuffers<import("@comapeo/core/dist/invite-api.js", { with: { "resolution-mode": "import" } }).InviteInternal>[], Error, import("@comapeo/core/dist/types.js", { with: { "resolution-mode": "import" } }).MapBuffers<import("@comapeo/core/dist/invite-api.js", { with: { "resolution-mode": "import" } }).InviteInternal>[], readonly ["@comapeo/core-react", "invites", {
+    readonly status: "pending";
+}]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<import("@comapeo/core/dist/types.js", { with: { "resolution-mode": "import" } }).MapBuffers<import("@comapeo/core/dist/invite-api.js", { with: { "resolution-mode": "import" } }).InviteInternal>[], readonly ["@comapeo/core-react", "invites", {
+        readonly status: "pending";
+    }], never> | undefined;
+} & {
+    queryKey: readonly ["@comapeo/core-react", "invites", {
+        readonly status: "pending";
+    }] & {
+        [dataTagSymbol]: import("@comapeo/core/dist/types.js", { with: { "resolution-mode": "import" } }).MapBuffers<import("@comapeo/core/dist/invite-api.js", { with: { "resolution-mode": "import" } }).InviteInternal>[];
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export declare function acceptInviteMutationOptions({ clientApi, queryClient, }: {
+    clientApi: MapeoClientApi;
+    queryClient: QueryClient;
+}): {
+    mutationFn: ({ inviteId }: {
+        inviteId: string;
+    }) => Promise<string>;
+    onSuccess: () => void;
+    networkMode: "always";
+    retry: false;
+};
+export declare function rejectInviteMutationOptions({ clientApi, queryClient, }: {
+    clientApi: MapeoClientApi;
+    queryClient: QueryClient;
+}): {
+    mutationFn: ({ inviteId }: {
+        inviteId: string;
+    }) => Promise<void>;
+    onSuccess: () => void;
+    networkMode: "always";
+    retry: false;
+};
+export declare function sendInviteMutationOptions({ projectApi, projectId, queryClient, }: {
+    projectApi: MapeoProjectApi;
+    projectId: string;
+    queryClient: QueryClient;
+}): {
+    mutationFn: ({ deviceId, ...role }: {
+        deviceId: string;
+        roleDescription?: string;
+        roleId: RoleIdForNewInvite;
+        roleName?: string;
+    }) => Promise<"ACCEPT" | "REJECT" | "ALREADY">;
+    onSuccess: () => void;
+    networkMode: "always";
+    retry: false;
+};
+export declare function requestCancelInviteMutationOptions({ projectApi, queryClient, }: {
+    projectApi: MapeoProjectApi;
+    queryClient: QueryClient;
+}): {
+    mutationFn: ({ deviceId }: {
+        deviceId: string;
+    }) => Promise<void>;
+    onSuccess: () => void;
+    networkMode: "always";
+    retry: false;
+};

package/dist/commonjs/lib/react-query/invites.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInvitesQueryKey = getInvitesQueryKey;
+exports.getPendingInvitesQueryKey = getPendingInvitesQueryKey;
+exports.pendingInvitesQueryOptions = pendingInvitesQueryOptions;
+exports.acceptInviteMutationOptions = acceptInviteMutationOptions;
+exports.rejectInviteMutationOptions = rejectInviteMutationOptions;
+exports.sendInviteMutationOptions = sendInviteMutationOptions;
+exports.requestCancelInviteMutationOptions = requestCancelInviteMutationOptions;
+const react_query_1 = require("@tanstack/react-query");
+const projects_js_1 = require("./projects.js");
+const shared_js_1 = require("./shared.js");
+function getInvitesQueryKey() {
+    return [shared_js_1.ROOT_QUERY_KEY, 'invites'];
+}
+function getPendingInvitesQueryKey() {
+    return [shared_js_1.ROOT_QUERY_KEY, 'invites', { status: 'pending' }];
+}
+function pendingInvitesQueryOptions({ clientApi, }) {
+    return (0, react_query_1.queryOptions)({
+        ...(0, shared_js_1.baseQueryOptions)(),
+        queryKey: getPendingInvitesQueryKey(),
+        queryFn: async () => {
+            return clientApi.invite.getPending();
+        },
+    });
+}
+function acceptInviteMutationOptions({ clientApi, queryClient, }) {
+    return {
+        ...(0, shared_js_1.baseMutationOptions)(),
+        mutationFn: async ({ inviteId }) => {
+            return clientApi.invite.accept({ inviteId });
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({
+                queryKey: getInvitesQueryKey(),
+            });
+            queryClient.invalidateQueries({
+                queryKey: (0, projects_js_1.getProjectsQueryKey)(),
+            });
+        },
+    };
+}
+function rejectInviteMutationOptions({ clientApi, queryClient, }) {
+    return {
+        ...(0, shared_js_1.baseMutationOptions)(),
+        mutationFn: async ({ inviteId }) => {
+            return clientApi.invite.reject({ inviteId });
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({
+                queryKey: getInvitesQueryKey(),
+            });
+        },
+    };
+}
+function sendInviteMutationOptions({ projectApi, projectId, queryClient, }) {
+    return {
+        ...(0, shared_js_1.baseMutationOptions)(),
+        mutationFn: async ({ deviceId, ...role }) => {
+            return projectApi.$member.invite(deviceId, role);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({
+                queryKey: getInvitesQueryKey(),
+            });
+            queryClient.invalidateQueries({
+                queryKey: (0, projects_js_1.getMembersQueryKey)({ projectId }),
+            });
+        },
+    };
+}
+function requestCancelInviteMutationOptions({ projectApi, queryClient, }) {
+    return {
+        ...(0, shared_js_1.baseMutationOptions)(),
+        mutationFn: async ({ deviceId }) => {
+            return projectApi.$member.requestCancelInvite(deviceId);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({
+                queryKey: getInvitesQueryKey(),
+            });
+        },
+    };
+}

package/dist/commonjs/lib/react-query/maps.d.ts

@@ -0,0 +1,24 @@
+import type { MapeoClientApi } from '@comapeo/ipc' with { 'resolution-mode': 'import' };
+export declare function getMapsQueryKey(): readonly ["@comapeo/core-react", "maps"];
+export declare function getStyleJsonUrlQueryKey({ refreshToken, }: {
+    refreshToken?: string;
+}): readonly ["@comapeo/core-react", "maps", "stylejson_url", {
+    readonly refreshToken: string | undefined;
+}];
+export declare function mapStyleJsonUrlQueryOptions({ clientApi, refreshToken, }: {
+    clientApi: MapeoClientApi;
+    refreshToken?: string;
+}): import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<string, Error, string, readonly ["@comapeo/core-react", "maps", "stylejson_url", {
+    readonly refreshToken: string | undefined;
+}]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<string, readonly ["@comapeo/core-react", "maps", "stylejson_url", {
+        readonly refreshToken: string | undefined;
+    }], never> | undefined;
+} & {
+    queryKey: readonly ["@comapeo/core-react", "maps", "stylejson_url", {
+        readonly refreshToken: string | undefined;
+    }] & {
+        [dataTagSymbol]: string;
+        [dataTagErrorSymbol]: Error;
+    };
+};

package/dist/commonjs/lib/react-query/maps.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMapsQueryKey = getMapsQueryKey;
+exports.getStyleJsonUrlQueryKey = getStyleJsonUrlQueryKey;
+exports.mapStyleJsonUrlQueryOptions = mapStyleJsonUrlQueryOptions;
+const react_query_1 = require("@tanstack/react-query");
+const shared_js_1 = require("./shared.js");
+function getMapsQueryKey() {
+    return [shared_js_1.ROOT_QUERY_KEY, 'maps'];
+}
+function getStyleJsonUrlQueryKey({ refreshToken, }) {
+    return [shared_js_1.ROOT_QUERY_KEY, 'maps', 'stylejson_url', { refreshToken }];
+}
+function mapStyleJsonUrlQueryOptions({ clientApi, refreshToken, }) {
+    return (0, react_query_1.queryOptions)({
+        ...(0, shared_js_1.baseQueryOptions)(),
+        queryKey: getStyleJsonUrlQueryKey({ refreshToken }),
+        queryFn: async () => {
+            const result = await clientApi.getMapStyleJsonUrl();
+            if (!refreshToken)
+                return result;
+            const u = new URL(result);
+            u.searchParams.set('refresh_token', refreshToken);
+            return u.href;
+        },
+    });
+}