@swoft/gtd-domain/dist/adapters/react/index.js

Getting Things Done (GTD) productivity system - consolidated domain implementation

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/adapters/react/index.ts
var react_exports = {};
__export(react_exports, {
  GTDProvider: () => GTDProvider,
  useActionsByContext: () => useActionsByContext,
  useActionsByProject: () => useActionsByProject,
  useActivateProject: () => useActivateProject,
  useAssignNextAction: () => useAssignNextAction,
  useCancelProject: () => useCancelProject,
  useCaptureInboxItem: () => useCaptureInboxItem,
  useClarifyInboxItem: () => useClarifyInboxItem,
  useCompleteNextAction: () => useCompleteNextAction,
  useCompleteProject: () => useCompleteProject,
  useContexts: () => useContexts,
  useCreateNextAction: () => useCreateNextAction,
  useCreateProject: () => useCreateProject,
  useDeferProject: () => useDeferProject,
  useDeleteInboxItem: () => useDeleteInboxItem,
  useDeleteNextAction: () => useDeleteNextAction,
  useDeleteProject: () => useDeleteProject,
  useGTDClient: () => useGTDClient,
  useInboxItem: () => useInboxItem,
  useInboxItems: () => useInboxItems,
  useNextAction: () => useNextAction,
  useNextActions: () => useNextActions,
  useProcessInboxItem: () => useProcessInboxItem,
  useProject: () => useProject,
  useProjects: () => useProjects,
  useUnassignNextAction: () => useUnassignNextAction,
  useWeeklyReview: () => useWeeklyReview
});
module.exports = __toCommonJS(react_exports);

// src/adapters/react/provider.ts
var import_react = require("react");

// src/contracts/api/backend-response-types.ts
var import_zod = require("zod");
var BackendInboxItemSchema = import_zod.z.object({
  id: import_zod.z.string(),
  content: import_zod.z.string(),
  text: import_zod.z.string().optional(),
  title: import_zod.z.string().optional(),
  status: import_zod.z.enum([
    "unprocessed",
    "processed",
    "clarified"
  ]),
  capturedAt: import_zod.z.string(),
  createdAt: import_zod.z.string(),
  capturedBy: import_zod.z.string(),
  capturedByPerson: import_zod.z.string().nullable().optional(),
  clarification: import_zod.z.string().nullable().optional(),
  description: import_zod.z.string().nullable().optional(),
  isActionable: import_zod.z.boolean().nullable().optional(),
  tags: import_zod.z.array(import_zod.z.string())
});
var BackendProjectSchema = import_zod.z.object({
  id: import_zod.z.string(),
  name: import_zod.z.string().optional(),
  title: import_zod.z.string().optional(),
  description: import_zod.z.string(),
  status: import_zod.z.enum([
    "active",
    "completed",
    "someday",
    "cancelled"
  ]),
  createdAt: import_zod.z.string(),
  ownerId: import_zod.z.string().optional(),
  createdBy: import_zod.z.string().optional(),
  priority: import_zod.z.enum([
    "low",
    "medium",
    "high"
  ]).optional(),
  progress: import_zod.z.object({
    totalActions: import_zod.z.number(),
    completedActions: import_zod.z.number(),
    completionPercentage: import_zod.z.number()
  })
});
var BackendSuccessResponseSchema = /* @__PURE__ */ __name((dataSchema) => import_zod.z.object({
  success: import_zod.z.literal(true),
  data: dataSchema
}), "BackendSuccessResponseSchema");
var BackendErrorResponseSchema = import_zod.z.object({
  success: import_zod.z.literal(false),
  error: import_zod.z.object({
    message: import_zod.z.string(),
    code: import_zod.z.string().optional(),
    details: import_zod.z.record(import_zod.z.any()).optional()
  })
});
var BackendInboxListResponseSchema = import_zod.z.union([
  BackendSuccessResponseSchema(import_zod.z.object({
    items: import_zod.z.array(BackendInboxItemSchema),
    total: import_zod.z.number()
  })),
  BackendErrorResponseSchema
]);
var BackendProjectsListResponseSchema = import_zod.z.union([
  BackendSuccessResponseSchema(import_zod.z.object({
    projects: import_zod.z.array(BackendProjectSchema),
    total: import_zod.z.number().optional()
  })),
  BackendErrorResponseSchema
]);
function isBackendSuccessResponse(response) {
  return response.success === true;
}
__name(isBackendSuccessResponse, "isBackendSuccessResponse");
var BackendApiError = class _BackendApiError extends Error {
  static {
    __name(this, "BackendApiError");
  }
  code;
  details;
  constructor(code, message, details) {
    super(message), this.code = code, this.details = details;
    this.name = "BackendApiError";
  }
  static fromBackendError(errorResponse) {
    return new _BackendApiError(errorResponse.error.code || "UNKNOWN_ERROR", errorResponse.error.message, errorResponse.error.details);
  }
};
var ApiValidationError = class extends Error {
  static {
    __name(this, "ApiValidationError");
  }
  validationErrors;
  constructor(message, validationErrors) {
    super(message), this.validationErrors = validationErrors;
    this.name = "ApiValidationError";
  }
};

// src/contracts/api/error-handling.ts
function classifyError(error) {
  if (error instanceof TypeError && error.message.includes("fetch")) {
    return {
      type: "NETWORK_ERROR",
      message: "Network connection failed. Please check your internet connection.",
      originalError: error
    };
  }
  if (error instanceof BackendApiError) {
    return {
      type: getErrorTypeFromCode(error.code),
      message: error.message,
      code: error.code,
      details: error.details,
      originalError: error
    };
  }
  if (error instanceof ApiValidationError) {
    return {
      type: "VALIDATION_ERROR",
      message: error.message,
      details: error.validationErrors,
      originalError: error
    };
  }
  if (error.status) {
    return classifyHttpError(error.status, error.message || "HTTP Error");
  }
  return {
    type: "UNKNOWN_ERROR",
    message: error.message || "An unexpected error occurred",
    originalError: error
  };
}
__name(classifyError, "classifyError");
function getErrorTypeFromCode(code) {
  switch (code) {
    case "UNAUTHORIZED":
    case "INVALID_TOKEN":
      return "AUTHENTICATION_ERROR";
    case "FORBIDDEN":
    case "INSUFFICIENT_PERMISSIONS":
      return "AUTHORIZATION_ERROR";
    case "NOT_FOUND":
    case "RESOURCE_NOT_FOUND":
      return "NOT_FOUND_ERROR";
    case "VALIDATION_FAILED":
    case "INVALID_REQUEST":
      return "VALIDATION_ERROR";
    case "SERVER_ERROR":
    case "INTERNAL_ERROR":
      return "SERVER_ERROR";
    case "TIMEOUT":
      return "TIMEOUT_ERROR";
    default:
      return "API_ERROR";
  }
}
__name(getErrorTypeFromCode, "getErrorTypeFromCode");
function classifyHttpError(status, message) {
  if (status === 401) {
    return {
      type: "AUTHENTICATION_ERROR",
      message: "Authentication required. Please log in.",
      code: "UNAUTHORIZED"
    };
  }
  if (status === 403) {
    return {
      type: "AUTHORIZATION_ERROR",
      message: "You do not have permission to perform this action.",
      code: "FORBIDDEN"
    };
  }
  if (status === 404) {
    return {
      type: "NOT_FOUND_ERROR",
      message: "The requested resource was not found.",
      code: "NOT_FOUND"
    };
  }
  if (status >= 400 && status < 500) {
    return {
      type: "VALIDATION_ERROR",
      message: message || "Invalid request",
      code: `HTTP_${status}`
    };
  }
  if (status >= 500) {
    return {
      type: "SERVER_ERROR",
      message: "Server error occurred. Please try again later.",
      code: `HTTP_${status}`
    };
  }
  return {
    type: "UNKNOWN_ERROR",
    message: message || `HTTP error ${status}`,
    code: `HTTP_${status}`
  };
}
__name(classifyHttpError, "classifyHttpError");
var DEFAULT_RETRY_CONFIG = {
  maxRetries: 3,
  retryDelay: 1e3,
  retryableErrors: [
    "NETWORK_ERROR",
    "TIMEOUT_ERROR",
    "SERVER_ERROR"
  ]
};
function shouldRetry(error, config = DEFAULT_RETRY_CONFIG) {
  return config.retryableErrors.includes(error.type);
}
__name(shouldRetry, "shouldRetry");
async function withRetry(operation, config = DEFAULT_RETRY_CONFIG) {
  let lastError;
  for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
    try {
      return await operation();
    } catch (error) {
      lastError = classifyError(error);
      if (attempt === config.maxRetries || !shouldRetry(lastError, config)) {
        throw lastError;
      }
      await new Promise((resolve) => setTimeout(resolve, config.retryDelay * Math.pow(2, attempt)));
    }
  }
  throw lastError;
}
__name(withRetry, "withRetry");
var ConsoleErrorLogger = class {
  static {
    __name(this, "ConsoleErrorLogger");
  }
  logError(error, context) {
    console.error("API Error:", {
      type: error.type,
      message: error.message,
      code: error.code,
      details: error.details,
      context,
      stack: error.originalError?.stack
    });
  }
};
var defaultErrorLogger = new ConsoleErrorLogger();

// src/client/gtd-client.ts
var GTDClient = class {
  static {
    __name(this, "GTDClient");
  }
  http;
  basePath;
  config;
  constructor(http, basePath = "/api/productivity/gtd", config = {}) {
    this.http = http;
    this.basePath = basePath;
    this.config = {
      enableValidation: true,
      enableRetry: true,
      errorLogger: defaultErrorLogger,
      ...config
    };
  }
  async executeRequest(operation) {
    try {
      if (this.config.enableRetry) {
        return await withRetry(operation);
      }
      return await operation();
    } catch (error) {
      const standardError = classifyError(error);
      this.config.errorLogger?.logError(standardError);
      throw standardError;
    }
  }
  validateResponse(data, schema, operationName) {
    if (!this.config.enableValidation) {
      return data;
    }
    const result = schema.safeParse(data);
    if (!result.success) {
      throw new ApiValidationError(`Invalid response format for ${operationName}`, result.error.issues);
    }
    return result.data;
  }
  // Inbox Operations
  async getInboxItems(filters) {
    return this.executeRequest(async () => {
      const queryParams = filters ? new URLSearchParams(Object.entries(filters).filter(([_, value]) => value !== void 0).reduce((acc, [key, value]) => ({
        ...acc,
        [key]: String(value)
      }), {})).toString() : "";
      const url = queryParams ? `${this.basePath}/inbox?${queryParams}` : `${this.basePath}/inbox`;
      const rawResponse = await this.http.get(url, {
        headers: {
          "Content-Type": "application/json"
        }
      });
      const validatedResponse = this.validateResponse(rawResponse, BackendInboxListResponseSchema, "getInboxItems");
      if (!isBackendSuccessResponse(validatedResponse)) {
        throw BackendApiError.fromBackendError(validatedResponse);
      }
      const { data } = validatedResponse;
      return {
        items: data.items.map((item) => ({
          id: item.id,
          originalContent: item.content || item.text || item.title || "",
          capturedAt: item.capturedAt,
          capturedByPersonId: item.capturedBy || "unknown",
          processingStatus: item.status === "processed" ? "processed" : "unprocessed",
          clarification: item.clarification || void 0,
          isActionable: item.isActionable || void 0,
          // These fields are not available in backend response yet - use undefined for now
          lastRefinedAt: void 0,
          refinedByPersonId: void 0
        })),
        pagination: {
          totalCount: data.total
        },
        totalCount: data.total
      };
    });
  }
  async getInboxItem(id) {
    const response = await this.http.get(`${this.basePath}/inbox/${id}`);
    return response.item || null;
  }
  async captureInboxItem(request) {
    const response = await this.http.post(`${this.basePath}/inbox`, request);
    return response.item || response;
  }
  async refineInboxItem(id, request) {
    const response = await this.http.post(`${this.basePath}/inbox/${id}/refine`, request);
    return response.item || response;
  }
  async clarifyInboxItem(id, request) {
    const response = await this.http.post(`${this.basePath}/inbox/${id}/clarify`, request);
    return response.item || response;
  }
  async processInboxItem(id, request) {
    return this.http.post(`${this.basePath}/inbox/${id}/process`, request);
  }
  async deleteInboxItem(id) {
    await this.http.delete(`${this.basePath}/inbox/${id}`);
  }
  // Project Operations
  async getProjects(filters) {
    const queryParams = filters ? new URLSearchParams(Object.entries(filters).filter(([_, value]) => value !== void 0).reduce((acc, [key, value]) => ({
      ...acc,
      [key]: String(value)
    }), {})).toString() : "";
    const url = queryParams ? `${this.basePath}/projects?${queryParams}` : `${this.basePath}/projects`;
    const response = await this.http.get(url);
    if (response.items && response.total !== void 0) {
      return {
        items: response.items,
        pagination: {
          totalCount: response.total,
          page: response.meta?.page,
          pageSize: response.meta?.limit
        },
        totalCount: response.total
      };
    }
    const items = Array.isArray(response) ? response : [];
    return {
      items,
      pagination: {
        totalCount: items.length
      },
      totalCount: items.length
    };
  }
  async getProject(id) {
    const response = await this.http.get(`${this.basePath}/projects/${id}`);
    return response.item || null;
  }
  async createProject(request) {
    const response = await this.http.post(`${this.basePath}/projects`, request);
    return response.item || response;
  }
  async completeProject(id, completedBy, completionNotes) {
    const response = await this.http.post(`${this.basePath}/projects/${id}/complete`, {
      completedBy,
      completionNotes
    });
    return response.item || response;
  }
  async deferProject(id) {
    const response = await this.http.post(`${this.basePath}/projects/${id}/defer`);
    return response.item || response;
  }
  async activateProject(id) {
    const response = await this.http.post(`${this.basePath}/projects/${id}/activate`);
    return response.item || response;
  }
  async cancelProject(id) {
    const response = await this.http.post(`${this.basePath}/projects/${id}/cancel`);
    return response.item || response;
  }
  async deleteProject(id) {
    await this.http.delete(`${this.basePath}/projects/${id}`);
  }
  // Next Action Operations
  async getNextActions(filters) {
    const queryParams = filters ? new URLSearchParams(Object.entries(filters).filter(([_, value]) => value !== void 0).reduce((acc, [key, value]) => ({
      ...acc,
      [key]: String(value)
    }), {})).toString() : "";
    const url = queryParams ? `${this.basePath}/actions?${queryParams}` : `${this.basePath}/actions`;
    const response = await this.http.get(url);
    if (response.items && response.total !== void 0) {
      return {
        items: response.items,
        pagination: {
          totalCount: response.total,
          page: response.meta?.page,
          pageSize: response.meta?.limit
        },
        totalCount: response.total
      };
    }
    const items = Array.isArray(response) ? response : [];
    return {
      items,
      pagination: {
        totalCount: items.length
      },
      totalCount: items.length
    };
  }
  async getNextAction(id) {
    const response = await this.http.get(`${this.basePath}/actions/${id}`);
    return response.item || null;
  }
  async createNextAction(request) {
    const response = await this.http.post(`${this.basePath}/actions`, request);
    return response.item || response;
  }
  async assignNextAction(id, request) {
    const response = await this.http.post(`${this.basePath}/actions/${id}/assign`, request);
    return response.item || response;
  }
  async unassignNextAction(id) {
    const response = await this.http.post(`${this.basePath}/actions/${id}/unassign`);
    return response.item || response;
  }
  async completeNextAction(id) {
    const response = await this.http.post(`${this.basePath}/actions/${id}/complete`);
    return response.item || response;
  }
  async deleteNextAction(id) {
    await this.http.delete(`${this.basePath}/actions/${id}`);
  }
  // Convenience methods that match the existing frontend API
  async getActionsByProject(projectId) {
    return this.getNextActions({
      projectId
    });
  }
  async getActionsByContext(context) {
    return this.getNextActions({
      context
    });
  }
  async getContexts() {
    const response = await this.http.get(`${this.basePath}/contexts`);
    const contexts = Array.isArray(response) ? response : [];
    return {
      items: contexts,
      pagination: {
        totalCount: contexts.length
      },
      totalCount: contexts.length
    };
  }
  // Weekly Review
  async getWeeklyReview(reviewedBy) {
    const queryParams = new URLSearchParams({
      reviewedBy
    }).toString();
    const response = await this.http.get(`${this.basePath}/weekly-review?${queryParams}`, {
      headers: {
        "Content-Type": "application/json"
      }
    });
    return response.review || response;
  }
};

// src/adapters/react/provider.ts
var GTDClientContext = (0, import_react.createContext)(null);
function GTDProvider({ children, httpClient, basePath }) {
  const client = (0, import_react.useMemo)(() => new GTDClient(httpClient, basePath), [
    httpClient,
    basePath
  ]);
  return (0, import_react.createElement)(GTDClientContext.Provider, {
    value: client
  }, children);
}
__name(GTDProvider, "GTDProvider");
function useGTDClient() {
  const client = (0, import_react.useContext)(GTDClientContext);
  if (!client) {
    throw new Error("useGTDClient must be used within a GTDProvider. Make sure to wrap your app with <GTDProvider httpClient={...}>");
  }
  return client;
}
__name(useGTDClient, "useGTDClient");

// src/adapters/react/hooks/use-inbox.ts
var import_react_query = require("@tanstack/react-query");
var INBOX_QUERY_KEY = [
  "gtd",
  "inbox"
];
function useInboxItems(filters) {
  const client = useGTDClient();
  return (0, import_react_query.useQuery)({
    queryKey: [
      ...INBOX_QUERY_KEY,
      filters
    ],
    queryFn: /* @__PURE__ */ __name(() => client.getInboxItems(filters), "queryFn"),
    staleTime: 30 * 1e3
  });
}
__name(useInboxItems, "useInboxItems");
function useInboxItem(id) {
  const client = useGTDClient();
  return (0, import_react_query.useQuery)({
    queryKey: [
      ...INBOX_QUERY_KEY,
      id
    ],
    queryFn: /* @__PURE__ */ __name(() => client.getInboxItem(id), "queryFn"),
    enabled: !!id,
    staleTime: 30 * 1e3
  });
}
__name(useInboxItem, "useInboxItem");
function useCaptureInboxItem() {
  const client = useGTDClient();
  const queryClient = (0, import_react_query.useQueryClient)();
  return (0, import_react_query.useMutation)({
    mutationFn: /* @__PURE__ */ __name((request) => client.captureInboxItem(request), "mutationFn"),
    onSuccess: /* @__PURE__ */ __name(() => {
      queryClient.invalidateQueries({
        queryKey: INBOX_QUERY_KEY
      });
    }, "onSuccess")
  });
}
__name(useCaptureInboxItem, "useCaptureInboxItem");
function useClarifyInboxItem() {
  const client = useGTDClient();
  const queryClient = (0, import_react_query.useQueryClient)();
  return (0, import_react_query.useMutation)({
    mutationFn: /* @__PURE__ */ __name(({ id, request }) => client.clarifyInboxItem(id, request), "mutationFn"),
    onSuccess: /* @__PURE__ */ __name((data, variables) => {
      queryClient.setQueryData([
        ...INBOX_QUERY_KEY,
        variables.id
      ], data);
      queryClient.invalidateQueries({
        queryKey: INBOX_QUERY_KEY,
        exact: false
      });
    }, "onSuccess")
  });
}
__name(useClarifyInboxItem, "useClarifyInboxItem");
function useProcessInboxItem() {
  const client = useGTDClient();
  const queryClient = (0, import_react_query.useQueryClient)();
  return (0, import_react_query.useMutation)({
    mutationFn: /* @__PURE__ */ __name(({ id, request }) => client.processInboxItem(id, request), "mutationFn"),
    onSuccess: /* @__PURE__ */ __name(() => {
      queryClient.invalidateQueries({
        queryKey: [
          "gtd"
        ]
      });
    }, "onSuccess")
  });
}
__name(useProcessInboxItem, "useProcessInboxItem");
function useDeleteInboxItem() {
  const client = useGTDClient();
  const queryClient = (0, import_react_query.useQueryClient)();
  return (0, import_react_query.useMutation)({
    mutationFn: /* @__PURE__ */ __name((id) => client.deleteInboxItem(id), "mutationFn"),
    onSuccess: /* @__PURE__ */ __name((_, id) => {
      queryClient.removeQueries({
        queryKey: [
          ...INBOX_QUERY_KEY,
          id
        ]
      });
      queryClient.invalidateQueries({
        queryKey: INBOX_QUERY_KEY,
        exact: false
      });
    }, "onSuccess")
  });
}
__name(useDeleteInboxItem, "useDeleteInboxItem");

// src/adapters/react/hooks/use-projects.ts
var import_react_query2 = require("@tanstack/react-query");
var PROJECTS_QUERY_KEY = [
  "gtd",
  "projects"
];
function useProjects(filters) {
  const client = useGTDClient();
  return (0, import_react_query2.useQuery)({
    queryKey: [
      ...PROJECTS_QUERY_KEY,
      filters
    ],
    queryFn: /* @__PURE__ */ __name(() => client.getProjects(filters), "queryFn"),
    staleTime: 60 * 1e3
  });
}
__name(useProjects, "useProjects");
function useProject(id) {
  const client = useGTDClient();
  return (0, import_react_query2.useQuery)({
    queryKey: [
      ...PROJECTS_QUERY_KEY,
      id
    ],
    queryFn: /* @__PURE__ */ __name(() => client.getProject(id), "queryFn"),
    enabled: !!id,
    staleTime: 60 * 1e3
  });
}
__name(useProject, "useProject");
function useCreateProject() {
  const client = useGTDClient();
  const queryClient = (0, import_react_query2.useQueryClient)();
  return (0, import_react_query2.useMutation)({
    mutationFn: /* @__PURE__ */ __name((request) => client.createProject(request), "mutationFn"),
    onSuccess: /* @__PURE__ */ __name(() => {
      queryClient.invalidateQueries({
        queryKey: PROJECTS_QUERY_KEY
      });
    }, "onSuccess")
  });
}
__name(useCreateProject, "useCreateProject");
function useCompleteProject() {
  const client = useGTDClient();
  const queryClient = (0, import_react_query2.useQueryClient)();
  return (0, import_react_query2.useMutation)({
    mutationFn: /* @__PURE__ */ __name(({ id, completedBy, notes }) => client.completeProject(id, completedBy, notes), "mutationFn"),
    onSuccess: /* @__PURE__ */ __name((data, variables) => {
      queryClient.setQueryData([
        ...PROJECTS_QUERY_KEY,
        variables.id
      ], data);
      queryClient.invalidateQueries({
        queryKey: PROJECTS_QUERY_KEY,
        exact: false
      });
    }, "onSuccess")
  });
}
__name(useCompleteProject, "useCompleteProject");
function useDeferProject() {
  const client = useGTDClient();
  const queryClient = (0, import_react_query2.useQueryClient)();
  return (0, import_react_query2.useMutation)({
    mutationFn: /* @__PURE__ */ __name((id) => client.deferProject(id), "mutationFn"),
    onSuccess: /* @__PURE__ */ __name((data, id) => {
      queryClient.setQueryData([
        ...PROJECTS_QUERY_KEY,
        id
      ], data);
      queryClient.invalidateQueries({
        queryKey: PROJECTS_QUERY_KEY,
        exact: false
      });
    }, "onSuccess")
  });
}
__name(useDeferProject, "useDeferProject");
function useActivateProject() {
  const client = useGTDClient();
  const queryClient = (0, import_react_query2.useQueryClient)();
  return (0, import_react_query2.useMutation)({
    mutationFn: /* @__PURE__ */ __name((id) => client.activateProject(id), "mutationFn"),
    onSuccess: /* @__PURE__ */ __name((data, id) => {
      queryClient.setQueryData([
        ...PROJECTS_QUERY_KEY,
        id
      ], data);
      queryClient.invalidateQueries({
        queryKey: PROJECTS_QUERY_KEY,
        exact: false
      });
    }, "onSuccess")
  });
}
__name(useActivateProject, "useActivateProject");
function useCancelProject() {
  const client = useGTDClient();
  const queryClient = (0, import_react_query2.useQueryClient)();
  return (0, import_react_query2.useMutation)({
    mutationFn: /* @__PURE__ */ __name((id) => client.cancelProject(id), "mutationFn"),
    onSuccess: /* @__PURE__ */ __name((data, id) => {
      queryClient.setQueryData([
        ...PROJECTS_QUERY_KEY,
        id
      ], data);
      queryClient.invalidateQueries({
        queryKey: PROJECTS_QUERY_KEY,
        exact: false
      });
    }, "onSuccess")
  });
}
__name(useCancelProject, "useCancelProject");
function useDeleteProject() {
  const client = useGTDClient();
  const queryClient = (0, import_react_query2.useQueryClient)();
  return (0, import_react_query2.useMutation)({
    mutationFn: /* @__PURE__ */ __name((id) => client.deleteProject(id), "mutationFn"),
    onSuccess: /* @__PURE__ */ __name((_, id) => {
      queryClient.removeQueries({
        queryKey: [
          ...PROJECTS_QUERY_KEY,
          id
        ]
      });
      queryClient.invalidateQueries({
        queryKey: PROJECTS_QUERY_KEY,
        exact: false
      });
    }, "onSuccess")
  });
}
__name(useDeleteProject, "useDeleteProject");

// src/adapters/react/hooks/use-actions.ts
var import_react_query3 = require("@tanstack/react-query");
var ACTIONS_QUERY_KEY = [
  "gtd",
  "actions"
];
var CONTEXTS_QUERY_KEY = [
  "gtd",
  "contexts"
];
function useNextActions(filters) {
  const client = useGTDClient();
  return (0, import_react_query3.useQuery)({
    queryKey: [
      ...ACTIONS_QUERY_KEY,
      filters
    ],
    queryFn: /* @__PURE__ */ __name(() => client.getNextActions(filters), "queryFn"),
    staleTime: 30 * 1e3
  });
}
__name(useNextActions, "useNextActions");
function useNextAction(id) {
  const client = useGTDClient();
  return (0, import_react_query3.useQuery)({
    queryKey: [
      ...ACTIONS_QUERY_KEY,
      id
    ],
    queryFn: /* @__PURE__ */ __name(() => client.getNextAction(id), "queryFn"),
    enabled: !!id,
    staleTime: 30 * 1e3
  });
}
__name(useNextAction, "useNextAction");
function useActionsByProject(projectId) {
  const client = useGTDClient();
  return (0, import_react_query3.useQuery)({
    queryKey: [
      ...ACTIONS_QUERY_KEY,
      "project",
      projectId
    ],
    queryFn: /* @__PURE__ */ __name(() => client.getActionsByProject(projectId), "queryFn"),
    enabled: !!projectId,
    staleTime: 30 * 1e3
  });
}
__name(useActionsByProject, "useActionsByProject");
function useActionsByContext(context) {
  const client = useGTDClient();
  return (0, import_react_query3.useQuery)({
    queryKey: [
      ...ACTIONS_QUERY_KEY,
      "context",
      context
    ],
    queryFn: /* @__PURE__ */ __name(() => client.getActionsByContext(context), "queryFn"),
    enabled: !!context,
    staleTime: 30 * 1e3
  });
}
__name(useActionsByContext, "useActionsByContext");
function useContexts() {
  const client = useGTDClient();
  return (0, import_react_query3.useQuery)({
    queryKey: CONTEXTS_QUERY_KEY,
    queryFn: /* @__PURE__ */ __name(() => client.getContexts(), "queryFn"),
    staleTime: 5 * 60 * 1e3
  });
}
__name(useContexts, "useContexts");
function useCreateNextAction() {
  const client = useGTDClient();
  const queryClient = (0, import_react_query3.useQueryClient)();
  return (0, import_react_query3.useMutation)({
    mutationFn: /* @__PURE__ */ __name((request) => client.createNextAction(request), "mutationFn"),
    onSuccess: /* @__PURE__ */ __name((data) => {
      queryClient.invalidateQueries({
        queryKey: ACTIONS_QUERY_KEY
      });
      if (data.projectId) {
        queryClient.invalidateQueries({
          queryKey: [
            ...ACTIONS_QUERY_KEY,
            "project",
            data.projectId
          ]
        });
      }
      if (data.context) {
        queryClient.invalidateQueries({
          queryKey: [
            ...ACTIONS_QUERY_KEY,
            "context",
            data.context
          ]
        });
      }
    }, "onSuccess")
  });
}
__name(useCreateNextAction, "useCreateNextAction");
function useAssignNextAction() {
  const client = useGTDClient();
  const queryClient = (0, import_react_query3.useQueryClient)();
  return (0, import_react_query3.useMutation)({
    mutationFn: /* @__PURE__ */ __name(({ id, request }) => client.assignNextAction(id, request), "mutationFn"),
    onSuccess: /* @__PURE__ */ __name((data, variables) => {
      queryClient.setQueryData([
        ...ACTIONS_QUERY_KEY,
        variables.id
      ], data);
      queryClient.invalidateQueries({
        queryKey: ACTIONS_QUERY_KEY,
        exact: false
      });
    }, "onSuccess")
  });
}
__name(useAssignNextAction, "useAssignNextAction");
function useUnassignNextAction() {
  const client = useGTDClient();
  const queryClient = (0, import_react_query3.useQueryClient)();
  return (0, import_react_query3.useMutation)({
    mutationFn: /* @__PURE__ */ __name((id) => client.unassignNextAction(id), "mutationFn"),
    onSuccess: /* @__PURE__ */ __name((data, id) => {
      queryClient.setQueryData([
        ...ACTIONS_QUERY_KEY,
        id
      ], data);
      queryClient.invalidateQueries({
        queryKey: ACTIONS_QUERY_KEY,
        exact: false
      });
    }, "onSuccess")
  });
}
__name(useUnassignNextAction, "useUnassignNextAction");
function useCompleteNextAction() {
  const client = useGTDClient();
  const queryClient = (0, import_react_query3.useQueryClient)();
  return (0, import_react_query3.useMutation)({
    mutationFn: /* @__PURE__ */ __name((id) => client.completeNextAction(id), "mutationFn"),
    onSuccess: /* @__PURE__ */ __name((data, id) => {
      queryClient.setQueryData([
        ...ACTIONS_QUERY_KEY,
        id
      ], data);
      queryClient.invalidateQueries({
        queryKey: ACTIONS_QUERY_KEY,
        exact: false
      });
    }, "onSuccess")
  });
}
__name(useCompleteNextAction, "useCompleteNextAction");
function useDeleteNextAction() {
  const client = useGTDClient();
  const queryClient = (0, import_react_query3.useQueryClient)();
  return (0, import_react_query3.useMutation)({
    mutationFn: /* @__PURE__ */ __name((id) => client.deleteNextAction(id), "mutationFn"),
    onSuccess: /* @__PURE__ */ __name((_, id) => {
      queryClient.removeQueries({
        queryKey: [
          ...ACTIONS_QUERY_KEY,
          id
        ]
      });
      queryClient.invalidateQueries({
        queryKey: ACTIONS_QUERY_KEY,
        exact: false
      });
    }, "onSuccess")
  });
}
__name(useDeleteNextAction, "useDeleteNextAction");
function useWeeklyReview(reviewedBy) {
  const client = useGTDClient();
  return (0, import_react_query3.useQuery)({
    queryKey: [
      "gtd",
      "weekly-review",
      reviewedBy
    ],
    queryFn: /* @__PURE__ */ __name(() => client.getWeeklyReview(reviewedBy), "queryFn"),
    staleTime: 60 * 1e3
  });
}
__name(useWeeklyReview, "useWeeklyReview");
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  GTDProvider,
  useActionsByContext,
  useActionsByProject,
  useActivateProject,
  useAssignNextAction,
  useCancelProject,
  useCaptureInboxItem,
  useClarifyInboxItem,
  useCompleteNextAction,
  useCompleteProject,
  useContexts,
  useCreateNextAction,
  useCreateProject,
  useDeferProject,
  useDeleteInboxItem,
  useDeleteNextAction,
  useDeleteProject,
  useGTDClient,
  useInboxItem,
  useInboxItems,
  useNextAction,
  useNextActions,
  useProcessInboxItem,
  useProject,
  useProjects,
  useUnassignNextAction,
  useWeeklyReview
});
//# sourceMappingURL=index.js.map