@focus-reactive/payload-plugin-translator 0.1.0

package/dist/client/entities/translation/api/mutations/useCancelDocumentTranslation.js

@@ -0,0 +1,34 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { ofetch } from 'ofetch';
+import { useTranslateKitConfig } from '../../../../app/config';
+import { handleNextApiError } from '../../../../shared/lib/errors/handleApiError';
+export function useCancelDocumentTranslation() {
+    const queryClient = useQueryClient();
+    const { basePath } = useTranslateKitConfig();
+    return useMutation({
+        mutationKey: [
+            'cancel-document-translation'
+        ],
+        mutationFn: async (variables)=>{
+            await handleNextApiError(()=>{
+                return ofetch(`/api${basePath}/cancel`, {
+                    method: 'delete',
+                    body: {
+                        ids: [
+                            variables.id
+                        ]
+                    }
+                });
+            });
+        },
+        onSuccess: ()=>{
+            queryClient.invalidateQueries({
+                queryKey: [
+                    'document-translation-status'
+                ]
+            });
+        }
+    });
+}
+
+//# sourceMappingURL=useCancelDocumentTranslation.js.map

package/dist/client/entities/translation/api/mutations/useCancelDocumentTranslation.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/client/entities/translation/api/mutations/useCancelDocumentTranslation.ts"],"sourcesContent":["import { useMutation, useQueryClient } from '@tanstack/react-query'\nimport { ofetch } from 'ofetch'\n\nimport { useTranslateKitConfig } from '../../../../app/config'\nimport { handleNextApiError } from '../../../../shared/lib/errors/handleApiError'\n\ntype Variables = {\n  id: string\n}\n\nexport function useCancelDocumentTranslation() {\n  const queryClient = useQueryClient()\n  const { basePath } = useTranslateKitConfig()\n\n  return useMutation({\n    mutationKey: ['cancel-document-translation'],\n    mutationFn: async (variables: Variables): Promise<void> => {\n      await handleNextApiError(() => {\n        return ofetch<{ data: null }>(`/api${basePath}/cancel`, {\n          method: 'delete',\n          body: { ids: [variables.id] },\n        })\n      })\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: ['document-translation-status'] })\n    },\n  })\n}\n"],"names":["useMutation","useQueryClient","ofetch","useTranslateKitConfig","handleNextApiError","useCancelDocumentTranslation","queryClient","basePath","mutationKey","mutationFn","variables","method","body","ids","id","onSuccess","invalidateQueries","queryKey"],"mappings":"AAAA,SAASA,WAAW,EAAEC,cAAc,QAAQ,wBAAuB;AACnE,SAASC,MAAM,QAAQ,SAAQ;AAE/B,SAASC,qBAAqB,QAAQ,yBAAwB;AAC9D,SAASC,kBAAkB,QAAQ,+CAA8C;AAMjF,OAAO,SAASC;IACd,MAAMC,cAAcL;IACpB,MAAM,EAAEM,QAAQ,EAAE,GAAGJ;IAErB,OAAOH,YAAY;QACjBQ,aAAa;YAAC;SAA8B;QAC5CC,YAAY,OAAOC;YACjB,MAAMN,mBAAmB;gBACvB,OAAOF,OAAuB,CAAC,IAAI,EAAEK,SAAS,OAAO,CAAC,EAAE;oBACtDI,QAAQ;oBACRC,MAAM;wBAAEC,KAAK;4BAACH,UAAUI,EAAE;yBAAC;oBAAC;gBAC9B;YACF;QACF;QACAC,WAAW;YACTT,YAAYU,iBAAiB,CAAC;gBAAEC,UAAU;oBAAC;iBAA8B;YAAC;QAC5E;IACF;AACF"}

package/dist/client/entities/translation/api/mutations/useQueueDocumentTranslation.d.ts

@@ -0,0 +1,13 @@
+type TranslationStrategy = 'overwrite' | 'skip_existing';
+type Variables = {
+    source_lng: string;
+    target_lng: string;
+    collection_slug: string;
+    collection_id: Array<string | number>;
+    select_all?: boolean;
+    strategy?: TranslationStrategy;
+    publish_on_translation?: boolean;
+};
+export declare function useQueueDocumentTranslation(): import("@tanstack/react-query").UseMutationResult<void, Error, Variables, unknown>;
+export {};
+//# sourceMappingURL=useQueueDocumentTranslation.d.ts.map

package/dist/client/entities/translation/api/mutations/useQueueDocumentTranslation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useQueueDocumentTranslation.d.ts","sourceRoot":"","sources":["../../../../../../src/client/entities/translation/api/mutations/useQueueDocumentTranslation.ts"],"names":[],"mappings":"AAMA,KAAK,mBAAmB,GAAG,WAAW,GAAG,eAAe,CAAA;AAExD,KAAK,SAAS,GAAG;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,eAAe,EAAE,MAAM,CAAA;IACvB,aAAa,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAA;IACrC,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,QAAQ,CAAC,EAAE,mBAAmB,CAAA;IAC9B,sBAAsB,CAAC,EAAE,OAAO,CAAA;CACjC,CAAA;AAED,wBAAgB,2BAA2B,uFAmB1C"}

package/dist/client/entities/translation/api/mutations/useQueueDocumentTranslation.js

@@ -0,0 +1,33 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { ofetch } from 'ofetch';
+import { useTranslateKitConfig } from '../../../../app/config';
+import { handleNextApiError } from '../../../../shared/lib/errors/handleApiError';
+export function useQueueDocumentTranslation() {
+    const queryClient = useQueryClient();
+    const { basePath } = useTranslateKitConfig();
+    return useMutation({
+        mutationKey: [
+            'queue-document-translation'
+        ],
+        mutationFn: async (variables)=>{
+            await handleNextApiError(()=>ofetch(`/api${basePath}/enqueue`, {
+                    method: 'post',
+                    body: variables
+                }));
+        },
+        onSuccess: ()=>{
+            queryClient.invalidateQueries({
+                queryKey: [
+                    'document-translation-status'
+                ]
+            });
+            queryClient.invalidateQueries({
+                queryKey: [
+                    'collection-translation-status'
+                ]
+            });
+        }
+    });
+}
+
+//# sourceMappingURL=useQueueDocumentTranslation.js.map

package/dist/client/entities/translation/api/mutations/useQueueDocumentTranslation.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/client/entities/translation/api/mutations/useQueueDocumentTranslation.ts"],"sourcesContent":["import { useMutation, useQueryClient } from '@tanstack/react-query'\nimport { ofetch } from 'ofetch'\n\nimport { useTranslateKitConfig } from '../../../../app/config'\nimport { handleNextApiError } from '../../../../shared/lib/errors/handleApiError'\n\ntype TranslationStrategy = 'overwrite' | 'skip_existing'\n\ntype Variables = {\n  source_lng: string\n  target_lng: string\n  collection_slug: string\n  collection_id: Array<string | number>\n  select_all?: boolean\n  strategy?: TranslationStrategy\n  publish_on_translation?: boolean\n}\n\nexport function useQueueDocumentTranslation() {\n  const queryClient = useQueryClient()\n  const { basePath } = useTranslateKitConfig()\n\n  return useMutation({\n    mutationKey: ['queue-document-translation'],\n    mutationFn: async (variables: Variables): Promise<void> => {\n      await handleNextApiError(() =>\n        ofetch<{ data: null }>(`/api${basePath}/enqueue`, {\n          method: 'post',\n          body: variables,\n        }),\n      )\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: ['document-translation-status'] })\n      queryClient.invalidateQueries({ queryKey: ['collection-translation-status'] })\n    },\n  })\n}\n"],"names":["useMutation","useQueryClient","ofetch","useTranslateKitConfig","handleNextApiError","useQueueDocumentTranslation","queryClient","basePath","mutationKey","mutationFn","variables","method","body","onSuccess","invalidateQueries","queryKey"],"mappings":"AAAA,SAASA,WAAW,EAAEC,cAAc,QAAQ,wBAAuB;AACnE,SAASC,MAAM,QAAQ,SAAQ;AAE/B,SAASC,qBAAqB,QAAQ,yBAAwB;AAC9D,SAASC,kBAAkB,QAAQ,+CAA8C;AAcjF,OAAO,SAASC;IACd,MAAMC,cAAcL;IACpB,MAAM,EAAEM,QAAQ,EAAE,GAAGJ;IAErB,OAAOH,YAAY;QACjBQ,aAAa;YAAC;SAA6B;QAC3CC,YAAY,OAAOC;YACjB,MAAMN,mBAAmB,IACvBF,OAAuB,CAAC,IAAI,EAAEK,SAAS,QAAQ,CAAC,EAAE;oBAChDI,QAAQ;oBACRC,MAAMF;gBACR;QAEJ;QACAG,WAAW;YACTP,YAAYQ,iBAAiB,CAAC;gBAAEC,UAAU;oBAAC;iBAA8B;YAAC;YAC1ET,YAAYQ,iBAAiB,CAAC;gBAAEC,UAAU;oBAAC;iBAAgC;YAAC;QAC9E;IACF;AACF"}

package/dist/client/entities/translation/api/mutations/useQueueDocumentTranslations.d.ts

@@ -0,0 +1,9 @@
+type Variables = {
+    source_lng: string;
+    target_lng: string;
+    collection_slug: string;
+    collection_id: Array<string | number>;
+};
+export declare function useQueueDocumentTranslations(): import("@tanstack/react-query").UseMutationResult<void, Error, Variables, unknown>;
+export {};
+//# sourceMappingURL=useQueueDocumentTranslations.d.ts.map

package/dist/client/entities/translation/api/mutations/useQueueDocumentTranslations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useQueueDocumentTranslations.d.ts","sourceRoot":"","sources":["../../../../../../src/client/entities/translation/api/mutations/useQueueDocumentTranslations.ts"],"names":[],"mappings":"AAMA,KAAK,SAAS,GAAG;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,eAAe,EAAE,MAAM,CAAA;IACvB,aAAa,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAA;CACtC,CAAA;AAED,wBAAgB,4BAA4B,uFAc3C"}

package/dist/client/entities/translation/api/mutations/useQueueDocumentTranslations.js

@@ -0,0 +1,20 @@
+import { useMutation } from '@tanstack/react-query';
+import { ofetch } from 'ofetch';
+import { useTranslateKitConfig } from '../../../../app/config';
+import { handleNextApiError } from '../../../../shared/lib/errors/handleApiError';
+export function useQueueDocumentTranslations() {
+    const { basePath } = useTranslateKitConfig();
+    return useMutation({
+        mutationKey: [
+            'queue-document-translations'
+        ],
+        mutationFn: async (variables)=>{
+            await handleNextApiError(()=>ofetch(`/api${basePath}/enqueue-many`, {
+                    method: 'post',
+                    body: variables
+                }));
+        }
+    });
+}
+
+//# sourceMappingURL=useQueueDocumentTranslations.js.map

package/dist/client/entities/translation/api/mutations/useQueueDocumentTranslations.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/client/entities/translation/api/mutations/useQueueDocumentTranslations.ts"],"sourcesContent":["import { useMutation } from '@tanstack/react-query'\nimport { ofetch } from 'ofetch'\n\nimport { useTranslateKitConfig } from '../../../../app/config'\nimport { handleNextApiError } from '../../../../shared/lib/errors/handleApiError'\n\ntype Variables = {\n  source_lng: string\n  target_lng: string\n  collection_slug: string\n  collection_id: Array<string | number>\n}\n\nexport function useQueueDocumentTranslations() {\n  const { basePath } = useTranslateKitConfig()\n\n  return useMutation({\n    mutationKey: ['queue-document-translations'],\n    mutationFn: async (variables: Variables): Promise<void> => {\n      await handleNextApiError(() =>\n        ofetch<{ data: null }>(`/api${basePath}/enqueue-many`, {\n          method: 'post',\n          body: variables,\n        }),\n      )\n    },\n  })\n}\n"],"names":["useMutation","ofetch","useTranslateKitConfig","handleNextApiError","useQueueDocumentTranslations","basePath","mutationKey","mutationFn","variables","method","body"],"mappings":"AAAA,SAASA,WAAW,QAAQ,wBAAuB;AACnD,SAASC,MAAM,QAAQ,SAAQ;AAE/B,SAASC,qBAAqB,QAAQ,yBAAwB;AAC9D,SAASC,kBAAkB,QAAQ,+CAA8C;AASjF,OAAO,SAASC;IACd,MAAM,EAAEC,QAAQ,EAAE,GAAGH;IAErB,OAAOF,YAAY;QACjBM,aAAa;YAAC;SAA8B;QAC5CC,YAAY,OAAOC;YACjB,MAAML,mBAAmB,IACvBF,OAAuB,CAAC,IAAI,EAAEI,SAAS,aAAa,CAAC,EAAE;oBACrDI,QAAQ;oBACRC,MAAMF;gBACR;QAEJ;IACF;AACF"}

package/dist/client/entities/translation/api/mutations/useRunDocumentTranslation.d.ts

@@ -0,0 +1,6 @@
+type Variables = {
+    id: string;
+};
+export declare function useRunDocumentTranslation(): import("@tanstack/react-query").UseMutationResult<void, Error, Variables, unknown>;
+export {};
+//# sourceMappingURL=useRunDocumentTranslation.d.ts.map

package/dist/client/entities/translation/api/mutations/useRunDocumentTranslation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRunDocumentTranslation.d.ts","sourceRoot":"","sources":["../../../../../../src/client/entities/translation/api/mutations/useRunDocumentTranslation.ts"],"names":[],"mappings":"AAMA,KAAK,SAAS,GAAG;IACf,EAAE,EAAE,MAAM,CAAA;CACX,CAAA;AAED,wBAAgB,yBAAyB,uFAiBxC"}

package/dist/client/entities/translation/api/mutations/useRunDocumentTranslation.js

@@ -0,0 +1,27 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { ofetch } from 'ofetch';
+import { useTranslateKitConfig } from '../../../../app/config';
+import { handleNextApiError } from '../../../../shared/lib/errors/handleApiError';
+export function useRunDocumentTranslation() {
+    const queryClient = useQueryClient();
+    const { basePath } = useTranslateKitConfig();
+    return useMutation({
+        mutationKey: [
+            'run-document-translation'
+        ],
+        mutationFn: async (variables)=>{
+            await handleNextApiError(()=>ofetch(`/api${basePath}/run/${variables.id}`, {
+                    method: 'post'
+                }));
+        },
+        onSuccess: ()=>{
+            queryClient.invalidateQueries({
+                queryKey: [
+                    'document-translation-status'
+                ]
+            });
+        }
+    });
+}
+
+//# sourceMappingURL=useRunDocumentTranslation.js.map

package/dist/client/entities/translation/api/mutations/useRunDocumentTranslation.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/client/entities/translation/api/mutations/useRunDocumentTranslation.ts"],"sourcesContent":["import { useMutation, useQueryClient } from '@tanstack/react-query'\nimport { ofetch } from 'ofetch'\n\nimport { useTranslateKitConfig } from '../../../../app/config'\nimport { handleNextApiError } from '../../../../shared/lib/errors/handleApiError'\n\ntype Variables = {\n  id: string\n}\n\nexport function useRunDocumentTranslation() {\n  const queryClient = useQueryClient()\n  const { basePath } = useTranslateKitConfig()\n\n  return useMutation({\n    mutationKey: ['run-document-translation'],\n    mutationFn: async (variables: Variables): Promise<void> => {\n      await handleNextApiError(() =>\n        ofetch<{ data: null }>(`/api${basePath}/run/${variables.id}`, {\n          method: 'post',\n        }),\n      )\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: ['document-translation-status'] })\n    },\n  })\n}\n"],"names":["useMutation","useQueryClient","ofetch","useTranslateKitConfig","handleNextApiError","useRunDocumentTranslation","queryClient","basePath","mutationKey","mutationFn","variables","id","method","onSuccess","invalidateQueries","queryKey"],"mappings":"AAAA,SAASA,WAAW,EAAEC,cAAc,QAAQ,wBAAuB;AACnE,SAASC,MAAM,QAAQ,SAAQ;AAE/B,SAASC,qBAAqB,QAAQ,yBAAwB;AAC9D,SAASC,kBAAkB,QAAQ,+CAA8C;AAMjF,OAAO,SAASC;IACd,MAAMC,cAAcL;IACpB,MAAM,EAAEM,QAAQ,EAAE,GAAGJ;IAErB,OAAOH,YAAY;QACjBQ,aAAa;YAAC;SAA2B;QACzCC,YAAY,OAAOC;YACjB,MAAMN,mBAAmB,IACvBF,OAAuB,CAAC,IAAI,EAAEK,SAAS,KAAK,EAAEG,UAAUC,EAAE,EAAE,EAAE;oBAC5DC,QAAQ;gBACV;QAEJ;QACAC,WAAW;YACTP,YAAYQ,iBAAiB,CAAC;gBAAEC,UAAU;oBAAC;iBAA8B;YAAC;QAC5E;IACF;AACF"}

package/dist/client/entities/translation/api/queries/useCollectionTranslationStatus.d.ts

@@ -0,0 +1,179 @@
+import type { CollectionSlug } from 'payload';
+import type { GroupedCollectionTranslationStatus } from '../../model/types';
+type Props = {
+    collection: CollectionSlug;
+};
+type Options = {
+    enabled?: boolean;
+};
+export declare function useCollectionTranslationStatus({ collection }: Props, options?: Options): {
+    invalidate: () => void;
+    data: GroupedCollectionTranslationStatus;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<GroupedCollectionTranslationStatus, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<GroupedCollectionTranslationStatus>;
+} | {
+    invalidate: () => void;
+    data: GroupedCollectionTranslationStatus;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<GroupedCollectionTranslationStatus, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<GroupedCollectionTranslationStatus>;
+} | {
+    invalidate: () => void;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<GroupedCollectionTranslationStatus, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<GroupedCollectionTranslationStatus>;
+} | {
+    invalidate: () => void;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<GroupedCollectionTranslationStatus, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<GroupedCollectionTranslationStatus>;
+} | {
+    invalidate: () => void;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<GroupedCollectionTranslationStatus, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<GroupedCollectionTranslationStatus>;
+} | {
+    invalidate: () => void;
+    data: GroupedCollectionTranslationStatus;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<GroupedCollectionTranslationStatus, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<GroupedCollectionTranslationStatus>;
+};
+export {};
+//# sourceMappingURL=useCollectionTranslationStatus.d.ts.map

package/dist/client/entities/translation/api/queries/useCollectionTranslationStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCollectionTranslationStatus.d.ts","sourceRoot":"","sources":["../../../../../../src/client/entities/translation/api/queries/useCollectionTranslationStatus.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAM7C,OAAO,KAAK,EAA+B,kCAAkC,EAAE,MAAM,mBAAmB,CAAA;AAExG,KAAK,KAAK,GAAG;IACX,UAAU,EAAE,cAAc,CAAA;CAC3B,CAAA;AAED,KAAK,OAAO,GAAG;IACb,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,CAAA;AAQD,wBAAgB,8BAA8B,CAAC,EAAE,UAAU,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4CtF"}

package/dist/client/entities/translation/api/queries/useCollectionTranslationStatus.js

@@ -0,0 +1,67 @@
+import { useQuery, useQueryClient } from '@tanstack/react-query';
+import { ofetch } from 'ofetch';
+import { useCallback } from 'react';
+import { useTranslateKitConfig } from '../../../../app/config';
+import { handleNextApiError } from '../../../../shared/lib/errors/handleApiError';
+import { DocumentTranslationStatus } from '../../model/enums';
+const getCollectionTranslationQueryKey = ({ collection })=>{
+    return [
+        'collection-translation-status',
+        collection
+    ];
+};
+const POLLING_INTERVAL_MILLISECONDS = 20000 // 20 sec
+;
+export function useCollectionTranslationStatus({ collection }, options) {
+    const queryClient = useQueryClient();
+    const { basePath } = useTranslateKitConfig();
+    const query = useQuery({
+        queryKey: getCollectionTranslationQueryKey({
+            collection
+        }),
+        queryFn: async ({ signal })=>{
+            return handleNextApiError(async ()=>{
+                const response = await ofetch(`/api${basePath}/collection/${collection}`, {
+                    method: 'get',
+                    signal
+                });
+                return response.data;
+            });
+        },
+        enabled: options?.enabled,
+        refetchInterval: (query)=>{
+            const docs = query.state.data?.docs;
+            const pending = docs?.some((doc)=>doc.status === DocumentTranslationStatus.PENDING);
+            const running = docs?.some((doc)=>doc.status === DocumentTranslationStatus.RUNNING);
+            return pending || running ? POLLING_INTERVAL_MILLISECONDS : false;
+        },
+        select: (data)=>{
+            const grouped = {
+                [DocumentTranslationStatus.PENDING]: [],
+                [DocumentTranslationStatus.RUNNING]: [],
+                [DocumentTranslationStatus.COMPLETED]: [],
+                [DocumentTranslationStatus.FAILED]: []
+            };
+            data.docs.forEach((doc)=>{
+                if (grouped[doc.status]) grouped[doc.status].push(doc);
+            });
+            return grouped;
+        }
+    });
+    const invalidate = useCallback(()=>{
+        queryClient.invalidateQueries({
+            queryKey: getCollectionTranslationQueryKey({
+                collection
+            })
+        });
+    }, [
+        collection,
+        queryClient
+    ]);
+    return {
+        ...query,
+        invalidate
+    };
+}
+
+//# sourceMappingURL=useCollectionTranslationStatus.js.map

package/dist/client/entities/translation/api/queries/useCollectionTranslationStatus.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/client/entities/translation/api/queries/useCollectionTranslationStatus.ts"],"sourcesContent":["import { useQuery, useQueryClient } from '@tanstack/react-query'\nimport { ofetch } from 'ofetch'\nimport type { CollectionSlug } from 'payload'\nimport { useCallback } from 'react'\n\nimport { useTranslateKitConfig } from '../../../../app/config'\nimport { handleNextApiError } from '../../../../shared/lib/errors/handleApiError'\nimport { DocumentTranslationStatus } from '../../model/enums'\nimport type { CollectionTranslationStatus, GroupedCollectionTranslationStatus } from '../../model/types'\n\ntype Props = {\n  collection: CollectionSlug\n}\n\ntype Options = {\n  enabled?: boolean\n}\n\nconst getCollectionTranslationQueryKey = ({ collection }: Props) => {\n  return ['collection-translation-status', collection]\n}\n\nconst POLLING_INTERVAL_MILLISECONDS = 20000 // 20 sec\n\nexport function useCollectionTranslationStatus({ collection }: Props, options?: Options) {\n  const queryClient = useQueryClient()\n  const { basePath } = useTranslateKitConfig()\n\n  const query = useQuery<CollectionTranslationStatus, Error, GroupedCollectionTranslationStatus>({\n    queryKey: getCollectionTranslationQueryKey({ collection }),\n    queryFn: async ({ signal }) => {\n      return handleNextApiError(async () => {\n        const response = await ofetch<{ data: CollectionTranslationStatus }>(\n          `/api${basePath}/collection/${collection}`,\n          { method: 'get', signal },\n        )\n\n        return response.data\n      })\n    },\n    enabled: options?.enabled,\n    refetchInterval: (query) => {\n      const docs = query.state.data?.docs\n      const pending = docs?.some((doc) => doc.status === DocumentTranslationStatus.PENDING)\n      const running = docs?.some((doc) => doc.status === DocumentTranslationStatus.RUNNING)\n      return pending || running ? POLLING_INTERVAL_MILLISECONDS : false\n    },\n    select: (data): GroupedCollectionTranslationStatus => {\n      const grouped: GroupedCollectionTranslationStatus = {\n        [DocumentTranslationStatus.PENDING]: [],\n        [DocumentTranslationStatus.RUNNING]: [],\n        [DocumentTranslationStatus.COMPLETED]: [],\n        [DocumentTranslationStatus.FAILED]: [],\n      }\n\n      data.docs.forEach((doc) => {\n        if (grouped[doc.status]) grouped[doc.status].push(doc)\n      })\n\n      return grouped\n    },\n  })\n\n  const invalidate = useCallback(() => {\n    queryClient.invalidateQueries({ queryKey: getCollectionTranslationQueryKey({ collection }) })\n  }, [collection, queryClient])\n\n  return { ...query, invalidate }\n}\n"],"names":["useQuery","useQueryClient","ofetch","useCallback","useTranslateKitConfig","handleNextApiError","DocumentTranslationStatus","getCollectionTranslationQueryKey","collection","POLLING_INTERVAL_MILLISECONDS","useCollectionTranslationStatus","options","queryClient","basePath","query","queryKey","queryFn","signal","response","method","data","enabled","refetchInterval","docs","state","pending","some","doc","status","PENDING","running","RUNNING","select","grouped","COMPLETED","FAILED","forEach","push","invalidate","invalidateQueries"],"mappings":"AAAA,SAASA,QAAQ,EAAEC,cAAc,QAAQ,wBAAuB;AAChE,SAASC,MAAM,QAAQ,SAAQ;AAE/B,SAASC,WAAW,QAAQ,QAAO;AAEnC,SAASC,qBAAqB,QAAQ,yBAAwB;AAC9D,SAASC,kBAAkB,QAAQ,+CAA8C;AACjF,SAASC,yBAAyB,QAAQ,oBAAmB;AAW7D,MAAMC,mCAAmC,CAAC,EAAEC,UAAU,EAAS;IAC7D,OAAO;QAAC;QAAiCA;KAAW;AACtD;AAEA,MAAMC,gCAAgC,MAAM,SAAS;;AAErD,OAAO,SAASC,+BAA+B,EAAEF,UAAU,EAAS,EAAEG,OAAiB;IACrF,MAAMC,cAAcX;IACpB,MAAM,EAAEY,QAAQ,EAAE,GAAGT;IAErB,MAAMU,QAAQd,SAAiF;QAC7Fe,UAAUR,iCAAiC;YAAEC;QAAW;QACxDQ,SAAS,OAAO,EAAEC,MAAM,EAAE;YACxB,OAAOZ,mBAAmB;gBACxB,MAAMa,WAAW,MAAMhB,OACrB,CAAC,IAAI,EAAEW,SAAS,YAAY,EAAEL,YAAY,EAC1C;oBAAEW,QAAQ;oBAAOF;gBAAO;gBAG1B,OAAOC,SAASE,IAAI;YACtB;QACF;QACAC,SAASV,SAASU;QAClBC,iBAAiB,CAACR;YAChB,MAAMS,OAAOT,MAAMU,KAAK,CAACJ,IAAI,EAAEG;YAC/B,MAAME,UAAUF,MAAMG,KAAK,CAACC,MAAQA,IAAIC,MAAM,KAAKtB,0BAA0BuB,OAAO;YACpF,MAAMC,UAAUP,MAAMG,KAAK,CAACC,MAAQA,IAAIC,MAAM,KAAKtB,0BAA0ByB,OAAO;YACpF,OAAON,WAAWK,UAAUrB,gCAAgC;QAC9D;QACAuB,QAAQ,CAACZ;YACP,MAAMa,UAA8C;gBAClD,CAAC3B,0BAA0BuB,OAAO,CAAC,EAAE,EAAE;gBACvC,CAACvB,0BAA0ByB,OAAO,CAAC,EAAE,EAAE;gBACvC,CAACzB,0BAA0B4B,SAAS,CAAC,EAAE,EAAE;gBACzC,CAAC5B,0BAA0B6B,MAAM,CAAC,EAAE,EAAE;YACxC;YAEAf,KAAKG,IAAI,CAACa,OAAO,CAAC,CAACT;gBACjB,IAAIM,OAAO,CAACN,IAAIC,MAAM,CAAC,EAAEK,OAAO,CAACN,IAAIC,MAAM,CAAC,CAACS,IAAI,CAACV;YACpD;YAEA,OAAOM;QACT;IACF;IAEA,MAAMK,aAAanC,YAAY;QAC7BS,YAAY2B,iBAAiB,CAAC;YAAExB,UAAUR,iCAAiC;gBAAEC;YAAW;QAAG;IAC7F,GAAG;QAACA;QAAYI;KAAY;IAE5B,OAAO;QAAE,GAAGE,KAAK;QAAEwB;IAAW;AAChC"}

package/dist/client/entities/translation/api/queries/useDocumentTranslation.d.ts

@@ -0,0 +1,180 @@
+import type { CollectionSlug } from 'payload';
+import type { DocumentTranslation } from '../../model/types';
+type Props = {
+    collection: CollectionSlug;
+    id: string;
+};
+type Options = {
+    enabled?: boolean;
+};
+export declare function useDocumentTranslation({ collection, id }: Props, options?: Options): {
+    invalidate: () => void;
+    data: DocumentTranslation;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<DocumentTranslation, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<DocumentTranslation>;
+} | {
+    invalidate: () => void;
+    data: DocumentTranslation;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<DocumentTranslation, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<DocumentTranslation>;
+} | {
+    invalidate: () => void;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<DocumentTranslation, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<DocumentTranslation>;
+} | {
+    invalidate: () => void;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<DocumentTranslation, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<DocumentTranslation>;
+} | {
+    invalidate: () => void;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<DocumentTranslation, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<DocumentTranslation>;
+} | {
+    invalidate: () => void;
+    data: DocumentTranslation;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<DocumentTranslation, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<DocumentTranslation>;
+};
+export {};
+//# sourceMappingURL=useDocumentTranslation.d.ts.map

package/dist/client/entities/translation/api/queries/useDocumentTranslation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDocumentTranslation.d.ts","sourceRoot":"","sources":["../../../../../../src/client/entities/translation/api/queries/useDocumentTranslation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAK7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AAE5D,KAAK,KAAK,GAAG;IACX,UAAU,EAAE,cAAc,CAAA;IAC1B,EAAE,EAAE,MAAM,CAAA;CACX,CAAA;AAED,KAAK,OAAO,GAAG;IACb,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,CAAA;AAQD,wBAAgB,sBAAsB,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BlF"}