use-abcd 0.2.1 → 1.1.0

package/dist/item.d.ts

@@ -0,0 +1,21 @@
+import { Draft } from 'mutative';
+import { Collection } from './collection';
+import { ItemStatus } from './types';
+export declare class Item<T, C = unknown> {
+    private _collection;
+    private _id;
+    private _cachedStatus;
+    private _refCount;
+    constructor(collection: Collection<T, C>, id: string);
+    _retain(): void;
+    _release(): void;
+    get refCount(): number;
+    get id(): string;
+    get data(): T | undefined;
+    update(mutate: (draft: Draft<T>) => void): void;
+    remove(): void;
+    getStatus(): ItemStatus;
+    exists(): boolean;
+    get collection(): Collection<T, C>;
+    _updateId(newId: string): void;
+}

package/dist/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mocks/browser.d.ts

@@ -0,0 +1 @@
+export declare const worker: import('msw/browser').SetupWorker;

package/dist/mocks/handlers.d.ts

@@ -0,0 +1,2 @@
+export declare const handlers: import('msw').HttpHandler[];
+export declare const batchHandlers: import('msw').HttpHandler[];

package/dist/runtime/client.d.ts

@@ -0,0 +1,51 @@
+import { Change, SyncResult } from '../types';
+import { SyncHandlerResult, SyncBatchResult, categorizeResults } from './types';
+export type { SyncHandlerResult, SyncBatchResult };
+export { categorizeResults };
+export type CreateHandler<T> = (data: T, signal: AbortSignal) => Promise<SyncHandlerResult>;
+export type UpdateHandler<T> = (id: string, data: T, signal: AbortSignal) => Promise<SyncHandlerResult>;
+export type DeleteHandler<T> = (id: string, data: T, signal: AbortSignal) => Promise<SyncHandlerResult>;
+export type SyncBuilderConfig<T> = {
+    create?: CreateHandler<T>;
+    update?: UpdateHandler<T>;
+    delete?: DeleteHandler<T>;
+};
+export type SyncBuilder<T> = {
+    onSync: (changes: Change<T>[], signal: AbortSignal) => Promise<SyncResult[]>;
+    handlers: {
+        create?: CreateHandler<T>;
+        update?: UpdateHandler<T>;
+        delete?: DeleteHandler<T>;
+    };
+};
+export type FetchToSyncResultOptions = {
+    fetch: Promise<Response>;
+    parseResponse?: (response: Response) => Promise<{
+        newId?: string;
+    }>;
+    parseError?: string | ((error: unknown) => string);
+};
+export declare function createSyncClient<T>(config: SyncBuilderConfig<T>): SyncBuilder<T>;
+export declare function createSyncClientWithStats<T>(config: SyncBuilderConfig<T>): {
+    onSync: (changes: Change<T>[], signal: AbortSignal) => Promise<SyncResult[]>;
+    onSyncWithStats: (changes: Change<T>[], signal: AbortSignal) => Promise<SyncBatchResult>;
+    handlers: {
+        create?: CreateHandler<T>;
+        update?: UpdateHandler<T>;
+        delete?: DeleteHandler<T>;
+    };
+};
+export declare function syncSuccess(options?: {
+    newId?: string;
+}): SyncHandlerResult;
+export declare function syncError(error: string): SyncHandlerResult;
+export type EndpointSyncClientConfig = {
+    endpoint: string;
+    headers?: Record<string, string>;
+};
+export type EndpointSyncClient<T, Q = unknown> = {
+    onFetch: (query: Q, signal: AbortSignal) => Promise<T[]>;
+    onSync: (changes: Change<T>[], signal: AbortSignal) => Promise<SyncResult[]>;
+};
+export declare function createSyncClientFromEndpoint<T, Q = unknown>(config: string | EndpointSyncClientConfig): EndpointSyncClient<T, Q>;
+export declare function fetchToSyncResult(options: FetchToSyncResultOptions): Promise<SyncHandlerResult>;

package/dist/runtime/client.js

@@ -0,0 +1,16 @@
+import { c } from "../chunks/types-Dy4rYb2N.js";
+import { c as t, b as a, a as n, f as o, d as S, s as y } from "../chunks/client-VrsFvEIA.js";
+import { createSyncServer as f, serverSyncError as l, serverSyncSuccess as m } from "./server.js";
+export {
+  c as categorizeResults,
+  t as createSyncClient,
+  a as createSyncClientFromEndpoint,
+  n as createSyncClientWithStats,
+  f as createSyncServer,
+  o as fetchToSyncResult,
+  l as serverSyncError,
+  m as serverSyncSuccess,
+  S as syncError,
+  y as syncSuccess
+};
+//# sourceMappingURL=client.js.map

package/dist/runtime/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/runtime/client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/index.d.ts

@@ -0,0 +1,5 @@
+export { type SyncHandlerResult, type SyncBatchResult, type Schema, type SyncRequestBody, type SyncResponseBody, categorizeResults, } from './types';
+export { createSyncClient, createSyncClientWithStats, createSyncClientFromEndpoint, syncSuccess, syncError, fetchToSyncResult, } from './client';
+export type { CreateHandler, UpdateHandler, DeleteHandler, SyncBuilderConfig, SyncBuilder, FetchToSyncResultOptions, EndpointSyncClientConfig, EndpointSyncClient, } from './client';
+export { createSyncServer, serverSyncSuccess, serverSyncError } from './server';
+export type { ServerFetchHandler, ServerCreateHandler, ServerUpdateHandler, ServerDeleteHandler, ServerSyncHandlerConfig, ServerSyncHandler, } from './server';

package/dist/runtime/server.d.ts

@@ -0,0 +1,33 @@
+import { Change, SyncResult } from '../types';
+import { SyncHandlerResult, SyncBatchResult, Schema, SyncRequestBody, SyncResponseBody, categorizeResults } from './types';
+export type { SyncHandlerResult, SyncBatchResult, Schema, SyncRequestBody, SyncResponseBody };
+export { categorizeResults };
+export type ServerFetchHandler<T, Q> = (query: Q) => Promise<T[]> | T[];
+export type ServerCreateHandler<T> = (data: T) => Promise<SyncHandlerResult> | SyncHandlerResult;
+export type ServerUpdateHandler<T> = (id: string, data: T) => Promise<SyncHandlerResult> | SyncHandlerResult;
+export type ServerDeleteHandler<T> = (id: string, data: T) => Promise<SyncHandlerResult> | SyncHandlerResult;
+export type ServerSyncHandlerConfig<T, Q = unknown> = {
+    schema?: Schema<T>;
+    querySchema?: Schema<Q>;
+    fetch?: ServerFetchHandler<T, Q>;
+    create?: ServerCreateHandler<T>;
+    update?: ServerUpdateHandler<T>;
+    delete?: ServerDeleteHandler<T>;
+};
+export type ServerSyncHandler<T, Q = unknown> = {
+    handler: (request: Request) => Promise<Response>;
+    fetchItems: (query: Q) => Promise<T[]>;
+    processChanges: (changes: Change<T>[]) => Promise<SyncResult[]>;
+    processChangesWithStats: (changes: Change<T>[]) => Promise<SyncBatchResult>;
+    handlers: {
+        fetch?: ServerFetchHandler<T, Q>;
+        create?: ServerCreateHandler<T>;
+        update?: ServerUpdateHandler<T>;
+        delete?: ServerDeleteHandler<T>;
+    };
+};
+export declare function serverSyncSuccess(options?: {
+    newId?: string;
+}): SyncHandlerResult;
+export declare function serverSyncError(error: string): SyncHandlerResult;
+export declare function createSyncServer<T, Q = unknown>(config: ServerSyncHandlerConfig<T, Q>): ServerSyncHandler<T, Q>;

package/dist/runtime/server.js

@@ -0,0 +1,121 @@
+import { c as y } from "../chunks/types-Dy4rYb2N.js";
+const d = (r, e) => new Response(JSON.stringify(r), {
+  status: e,
+  headers: { "Content-Type": "application/json" }
+}), a = {
+  success: (r) => d(r, 200),
+  methodNotAllowed: () => d({ error: "Method not allowed. Use POST." }, 405),
+  invalidJson: () => d({ error: "Invalid JSON body" }, 400),
+  invalidPayload: () => d({ error: "Request body must contain 'query' and/or 'changes'" }, 400),
+  validationError: (r) => d({ error: `Validation error: ${r}` }, 400),
+  notConfigured: (r) => d({ error: `${r} handler not configured` }, 501),
+  serverError: (r) => d({ error: r instanceof Error ? r.message : "Internal server error" }, 500)
+};
+function h() {
+  return {
+    create: {
+      guard: (r) => !!r.create,
+      execute: (r, e) => e.create(r.data),
+      toResult: (r, e) => e.success === !0 ? { id: r.id, status: "success", newId: e.newId } : { id: r.id, status: "error", error: e.error },
+      notConfiguredError: "Create handler not configured"
+    },
+    update: {
+      guard: (r) => !!r.update,
+      execute: (r, e) => e.update(r.id, r.data),
+      toResult: (r, e) => e.success === !0 ? { id: r.id, status: "success" } : { id: r.id, status: "error", error: e.error },
+      notConfiguredError: "Update handler not configured"
+    },
+    delete: {
+      guard: (r) => !!r.delete,
+      execute: (r, e) => e.delete(r.id, r.data),
+      toResult: (r, e) => e.success === !0 ? { id: r.id, status: "success" } : { id: r.id, status: "error", error: e.error },
+      notConfiguredError: "Delete handler not configured"
+    }
+  };
+}
+function f(r, e) {
+  if (!e) return { valid: !0, data: r };
+  const o = e.safeParse(r);
+  return o.success === !0 ? { valid: !0, data: o.data } : { valid: !1, error: o.error.message };
+}
+async function p(r, e) {
+  const n = h()[r.type];
+  if (!n)
+    return { id: r.id, status: "error", error: `Unknown change type: ${r.type}` };
+  if (!n.guard(e))
+    return { id: r.id, status: "error", error: n.notConfiguredError };
+  const u = f(r.data, e.schema);
+  if (u.valid === !1)
+    return { id: r.id, status: "error", error: `Validation failed: ${u.error}` };
+  try {
+    const i = await n.execute({ ...r, data: u.data }, e);
+    return n.toResult(r, i);
+  } catch (i) {
+    return {
+      id: r.id,
+      status: "error",
+      error: i instanceof Error ? i.message : "Unknown error"
+    };
+  }
+}
+function w(r) {
+  return { success: !0, ...r };
+}
+function m(r) {
+  return { success: !1, error: r };
+}
+function C(r) {
+  const e = async (s) => {
+    if (!r.fetch) throw new Error("Fetch handler not configured");
+    return r.fetch(s);
+  }, o = async (s) => Promise.all(s.map((t) => p(t, r))), n = async (s) => {
+    const t = await o(s);
+    return y(t);
+  }, u = async (s) => {
+    let t;
+    try {
+      t = await s.json();
+    } catch {
+      return a.invalidJson();
+    }
+    if (!t.query && !t.changes)
+      return a.invalidPayload();
+    const c = {};
+    if (t.query !== void 0) {
+      if (!r.fetch) return a.notConfigured("Fetch");
+      const l = f(t.query, r.querySchema);
+      if (l.valid === !1) return a.validationError(l.error);
+      c.results = await e(l.data);
+    }
+    if (t.changes !== void 0) {
+      if (!Array.isArray(t.changes)) return a.invalidPayload();
+      c.syncResults = await o(t.changes);
+    }
+    return a.success(c);
+  };
+  return {
+    handler: async (s) => {
+      try {
+        return s.method !== "POST" ? a.methodNotAllowed() : await u(s);
+      } catch (t) {
+        return a.serverError(t);
+      }
+    },
+    fetchItems: e,
+    processChanges: o,
+    processChangesWithStats: n,
+    handlers: {
+      fetch: r.fetch,
+      create: r.create,
+      update: r.update,
+      delete: r.delete
+    }
+  };
+}
+export {
+  y as categorizeResults,
+  C as createSyncServer,
+  m as serverSyncError,
+  w as serverSyncSuccess
+};
+//# sourceMappingURL=server.js.map

package/dist/runtime/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sources":["../../src/runtime/server.ts"],"sourcesContent":["import type { Change, SyncResult } from \"../types\";\nimport {\n  type SyncHandlerResult,\n  type SyncBatchResult,\n  type Schema,\n  type SyncRequestBody,\n  type SyncResponseBody,\n  categorizeResults,\n} from \"./types\";\n\n// Re-export shared types for server module consumers\nexport type { SyncHandlerResult, SyncBatchResult, Schema, SyncRequestBody, SyncResponseBody };\nexport { categorizeResults };\n\n// ============================================================================\n// Types\n// ============================================================================\n\nexport type ServerFetchHandler<T, Q> = (query: Q) => Promise<T[]> | T[];\nexport type ServerCreateHandler<T> = (data: T) => Promise<SyncHandlerResult> | SyncHandlerResult;\nexport type ServerUpdateHandler<T> = (\n  id: string,\n  data: T,\n) => Promise<SyncHandlerResult> | SyncHandlerResult;\nexport type ServerDeleteHandler<T> = (\n  id: string,\n  data: T,\n) => Promise<SyncHandlerResult> | SyncHandlerResult;\n\nexport type ServerSyncHandlerConfig<T, Q = unknown> = {\n  schema?: Schema<T>;\n  querySchema?: Schema<Q>;\n  fetch?: ServerFetchHandler<T, Q>;\n  create?: ServerCreateHandler<T>;\n  update?: ServerUpdateHandler<T>;\n  delete?: ServerDeleteHandler<T>;\n};\n\nexport type ServerSyncHandler<T, Q = unknown> = {\n  handler: (request: Request) => Promise<Response>;\n  fetchItems: (query: Q) => Promise<T[]>;\n  processChanges: (changes: Change<T>[]) => Promise<SyncResult[]>;\n  processChangesWithStats: (changes: Change<T>[]) => Promise<SyncBatchResult>;\n  handlers: {\n    fetch?: ServerFetchHandler<T, Q>;\n    create?: ServerCreateHandler<T>;\n    update?: ServerUpdateHandler<T>;\n    delete?: ServerDeleteHandler<T>;\n  };\n};\n\n// ============================================================================\n// Response Helpers\n// ============================================================================\n\nconst jsonResponse = (body: unknown, status: number): Response =>\n  new Response(JSON.stringify(body), {\n    status,\n    headers: { \"Content-Type\": \"application/json\" },\n  });\n\nconst responses = {\n  success: (data: unknown) => jsonResponse(data, 200),\n  methodNotAllowed: () => jsonResponse({ error: \"Method not allowed. Use POST.\" }, 405),\n  invalidJson: () => jsonResponse({ error: \"Invalid JSON body\" }, 400),\n  invalidPayload: () =>\n    jsonResponse({ error: \"Request body must contain 'query' and/or 'changes'\" }, 400),\n  validationError: (message: string) =>\n    jsonResponse({ error: `Validation error: ${message}` }, 400),\n  notConfigured: (handler: string) =>\n    jsonResponse({ error: `${handler} handler not configured` }, 501),\n  serverError: (error: unknown) =>\n    jsonResponse({ error: error instanceof Error ? error.message : \"Internal server error\" }, 500),\n} as const;\n\n// ============================================================================\n// Change Processing\n// ============================================================================\n\ntype ChangeProcessor<T, Q> = {\n  guard: (config: ServerSyncHandlerConfig<T, Q>) => boolean;\n  execute: (\n    change: Change<T>,\n    config: ServerSyncHandlerConfig<T, Q>,\n  ) => Promise<SyncHandlerResult> | SyncHandlerResult;\n  toResult: (change: Change<T>, result: SyncHandlerResult) => SyncResult;\n  notConfiguredError: string;\n};\n\nfunction createChangeProcessors<T, Q>(): Record<string, ChangeProcessor<T, Q>> {\n  return {\n    create: {\n      guard: (config) => !!config.create,\n      execute: (change, config) => config.create!(change.data),\n      toResult: (change, result) =>\n        result.success === true\n          ? { id: change.id, status: \"success\" as const, newId: result.newId }\n          : { id: change.id, status: \"error\" as const, error: result.error },\n      notConfiguredError: \"Create handler not configured\",\n    },\n\n    update: {\n      guard: (config) => !!config.update,\n      execute: (change, config) => config.update!(change.id, change.data),\n      toResult: (change, result) =>\n        result.success === true\n          ? { id: change.id, status: \"success\" as const }\n          : { id: change.id, status: \"error\" as const, error: result.error },\n      notConfiguredError: \"Update handler not configured\",\n    },\n\n    delete: {\n      guard: (config) => !!config.delete,\n      execute: (change, config) => config.delete!(change.id, change.data),\n      toResult: (change, result) =>\n        result.success === true\n          ? { id: change.id, status: \"success\" as const }\n          : { id: change.id, status: \"error\" as const, error: result.error },\n      notConfiguredError: \"Delete handler not configured\",\n    },\n  };\n}\n\nfunction validateData<T>(\n  data: unknown,\n  schema?: Schema<T>,\n): { valid: true; data: T } | { valid: false; error: string } {\n  if (!schema) return { valid: true, data: data as T };\n\n  const result = schema.safeParse(data);\n  return result.success === true\n    ? { valid: true, data: result.data }\n    : { valid: false, error: result.error.message };\n}\n\nasync function processServerChange<T, Q>(\n  change: Change<T>,\n  config: ServerSyncHandlerConfig<T, Q>,\n): Promise<SyncResult> {\n  const processors = createChangeProcessors<T, Q>();\n  const processor = processors[change.type];\n\n  if (!processor) {\n    return { id: change.id, status: \"error\", error: `Unknown change type: ${change.type}` };\n  }\n\n  if (!processor.guard(config)) {\n    return { id: change.id, status: \"error\", error: processor.notConfiguredError };\n  }\n\n  const validation = validateData(change.data, config.schema);\n  if (validation.valid === false) {\n    return { id: change.id, status: \"error\", error: `Validation failed: ${validation.error}` };\n  }\n\n  try {\n    const result = await processor.execute({ ...change, data: validation.data }, config);\n    return processor.toResult(change, result);\n  } catch (error) {\n    return {\n      id: change.id,\n      status: \"error\",\n      error: error instanceof Error ? error.message : \"Unknown error\",\n    };\n  }\n}\n\n// ============================================================================\n// Public API\n// ============================================================================\n\nexport function serverSyncSuccess(options?: { newId?: string }): SyncHandlerResult {\n  return { success: true, ...options };\n}\n\nexport function serverSyncError(error: string): SyncHandlerResult {\n  return { success: false, error };\n}\n\nexport function createSyncServer<T, Q = unknown>(\n  config: ServerSyncHandlerConfig<T, Q>,\n): ServerSyncHandler<T, Q> {\n  const fetchItems = async (query: Q): Promise<T[]> => {\n    if (!config.fetch) throw new Error(\"Fetch handler not configured\");\n    return config.fetch(query);\n  };\n\n  const processChanges = async (changes: Change<T>[]): Promise<SyncResult[]> => {\n    return Promise.all(changes.map((change) => processServerChange(change, config)));\n  };\n\n  const processChangesWithStats = async (changes: Change<T>[]): Promise<SyncBatchResult> => {\n    const results = await processChanges(changes);\n    return categorizeResults(results);\n  };\n\n  const handlePost = async (request: Request): Promise<Response> => {\n    let body: SyncRequestBody<T, Q>;\n    try {\n      body = await request.json();\n    } catch {\n      return responses.invalidJson();\n    }\n\n    if (!body.query && !body.changes) {\n      return responses.invalidPayload();\n    }\n\n    const responseBody: SyncResponseBody<T> = {};\n\n    if (body.query !== undefined) {\n      if (!config.fetch) return responses.notConfigured(\"Fetch\");\n\n      const validation = validateData<Q>(body.query, config.querySchema);\n      if (validation.valid === false) return responses.validationError(validation.error);\n\n      responseBody.results = await fetchItems(validation.data);\n    }\n\n    if (body.changes !== undefined) {\n      if (!Array.isArray(body.changes)) return responses.invalidPayload();\n      responseBody.syncResults = await processChanges(body.changes);\n    }\n\n    return responses.success(responseBody);\n  };\n\n  const handler = async (request: Request): Promise<Response> => {\n    try {\n      if (request.method !== \"POST\") return responses.methodNotAllowed();\n      return await handlePost(request);\n    } catch (error) {\n      return responses.serverError(error);\n    }\n  };\n\n  return {\n    handler,\n    fetchItems,\n    processChanges,\n    processChangesWithStats,\n    handlers: {\n      fetch: config.fetch,\n      create: config.create,\n      update: config.update,\n      delete: config.delete,\n    },\n  };\n}\n"],"names":["jsonResponse","body","status","responses","data","message","handler","error","createChangeProcessors","config","change","result","validateData","schema","processServerChange","processor","validation","serverSyncSuccess","options","serverSyncError","createSyncServer","fetchItems","query","processChanges","changes","processChangesWithStats","results","categorizeResults","handlePost","request","responseBody"],"mappings":"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"}

package/dist/runtime/server.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/types.d.ts

@@ -0,0 +1,70 @@
+import { Change, SyncResult } from '../types';
+/**
+ * Result of a sync operation handler.
+ * Used by both client-side and server-side handlers.
+ */
+export type SyncHandlerResult = {
+    success: true;
+    newId?: string;
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * Zod-like schema interface (duck typing to avoid hard dependency)
+ */
+export type Schema<T> = {
+    safeParse: (data: unknown) => {
+        success: true;
+        data: T;
+    } | {
+        success: false;
+        error: {
+            message: string;
+        };
+    };
+};
+/**
+ * Aggregated results from sync operations.
+ * Provides categorized results and summary statistics.
+ */
+export type SyncBatchResult = {
+    /** All results from the sync operation */
+    results: SyncResult[];
+    /** Results that succeeded */
+    successful: SyncResult[];
+    /** Results that failed */
+    failed: SyncResult[];
+    /** Whether all operations succeeded */
+    allSucceeded: boolean;
+    /** Whether any operations succeeded */
+    anySucceeded: boolean;
+    /** Summary counts */
+    summary: {
+        total: number;
+        succeeded: number;
+        failed: number;
+    };
+};
+/**
+ * Categorize sync results into successful and failed
+ */
+export declare function categorizeResults(results: SyncResult[]): SyncBatchResult;
+/**
+ * Request body for the unified POST endpoint
+ */
+export type SyncRequestBody<T, Q = unknown> = {
+    /** Query parameters for fetching items */
+    query?: Q;
+    /** Changes to sync */
+    changes?: Change<T>[];
+};
+/**
+ * Response body from the unified POST endpoint
+ */
+export type SyncResponseBody<T> = {
+    /** Fetched items (when query was provided) */
+    results?: T[];
+    /** Sync results (when changes were provided) */
+    syncResults?: SyncResult[];
+};

package/dist/sync-queue.d.ts

@@ -0,0 +1,29 @@
+import { Change, SyncQueueState, SyncResult, IdMapping } from './types';
+export type SyncQueueConfig<T> = {
+    debounce: number;
+    maxRetries: number;
+    onSync: (changes: Change<T>[], signal: AbortSignal) => Promise<SyncResult[]>;
+    onIdRemap?: (mappings: IdMapping[]) => void;
+};
+export declare class SyncQueue<T> {
+    private _config;
+    private _state;
+    private _subscribers;
+    private _debounceTimer;
+    private _abortController;
+    constructor(config: SyncQueueConfig<T>);
+    enqueue(change: Change<T>): void;
+    pause(): void;
+    resume(): void;
+    retryAll(): void;
+    retry(id: string): void;
+    resetRetries(id: string): void;
+    getState(): SyncQueueState<T>;
+    subscribe(callback: () => void): () => void;
+    private _updateState;
+    private _scheduleFlush;
+    private _clearTimer;
+    private _flush;
+    private _processResults;
+    private _handleError;
+}

package/dist/sync-queue.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types.d.ts

@@ -0,0 +1,61 @@
+export type JsonValue = string | number | boolean | null | undefined;
+export type PlainObject = {
+    [key: string]: JsonValue | PlainObject | JsonValue[] | PlainObject[];
+};
+export type Result = {
+    status: "success" | "error";
+    error?: string;
+};
+export type Fn<A, R = void> = (arg: A) => R;
+export type Mutator<T> = (draft: T) => void;
+export type SyncState = "idle" | "fetching" | "syncing";
+export type ItemSyncStatus = "pending" | "syncing" | "success" | "error";
+export type ChangeType = "create" | "update" | "delete";
+export type Change<T> = {
+    id: string;
+    type: ChangeType;
+    data: T;
+};
+export type ItemStatus = {
+    type: ChangeType;
+    status: ItemSyncStatus;
+    retries: number;
+    error?: string;
+} | null;
+export type SyncResult = {
+    id: string;
+    status: "success" | "error";
+    error?: string;
+    newId?: string;
+};
+export type IdMapping = {
+    tempId: string;
+    newId: string;
+};
+export type SyncError<T> = {
+    error: string;
+    retries: number;
+    operations: Change<T>[];
+};
+export type SyncQueueState<T> = {
+    queue: Map<string, Change<T>[]>;
+    inFlight: Map<string, Change<T>[]>;
+    errors: Map<string, SyncError<T>>;
+    isPaused: boolean;
+    isSyncing: boolean;
+};
+export type FetchState = "idle" | "fetching" | "error";
+export type Config<T, C> = {
+    id: string;
+    initialContext: C;
+    getId: (item: T) => string;
+    setId?: (item: T, newId: string) => T;
+    syncDebounce?: number;
+    syncRetries?: number;
+    refetchOnMutation?: boolean;
+    cacheCapacity?: number;
+    cacheTtl?: number;
+    fetchRetries?: number;
+    onFetch: (context: C, signal: AbortSignal) => Promise<T[]>;
+    onSync?: (changes: Change<T>[], signal: AbortSignal) => Promise<SyncResult[]>;
+};

package/dist/useCrud.d.ts

@@ -1,169 +1,28 @@
-declare type CachedItem = {
-    data: unknown;
-    ts: number;
-};
-
-export declare type CrudConfig<T extends Item = Item, C extends object = object, M extends object = object> = {
-    id: string;
-    context: C;
-    debounce?: number;
-    caching?: {
-        capacity: number;
-        age: number;
-    };
-    fetch?: FetchFn<T, M>;
-    create?: TransitionFn<T>;
-    update?: TransitionFn<T>;
-    remove?: TransitionFn<T>;
-    getServerSnapshot?: () => StoreState<T>;
-};
-
-/**
- * Cache implementation for storing and managing fetch results
- * with configurable age and capacity limits.
- */
-declare class FetchCache {
-    age: number;
-    capacity: number;
-    storage: Map<string, CachedItem>;
-    constructor(age?: number, capacity?: number);
-    invalidate(): void;
-    reset(age: number, capacity: number): void;
-    get(id: string): unknown;
-    put(id: string, item: unknown): void;
-    remove(id: string): void;
-    withCache: (id: string, callback: () => Promise<unknown>) => Promise<unknown>;
-}
-
-export declare type FetchFn<T extends Item = Item, M extends object = object> = (option: QueryOption) => Promise<{
-    items: T[];
-    metadata?: M;
-}>;
-
-export declare type Item = {
-    id: string;
-} & Record<string, any>;
-
-export declare type ItemWithState<T extends Item = Item, State extends TransitionStates = TransitionStates> = {
-    data: T;
-    optimistic: boolean;
-    errors: Map<string, string[]>;
-    transitions: Map<string | "default", [State, State extends "idle" ? undefined : T, ts: number]>;
-};
-
-export declare type QueryOption = {
-    signal: AbortSignal;
-    context: unknown;
-};
-
-/**
- * Core state management store for CRUD operations.
- * Handles data fetching, caching, and state transitions for items.
- * @template T - Type of items managed by the store, must extend Item base type
- */
-declare class Store<T extends Item = Item, C extends object = object, M extends object = object> {
-    private id;
-    private config;
-    batched: boolean;
-    state: StoreState<T, C, M>;
-    subscribers: Set<() => void>;
-    controllers: Map<string, AbortController>;
-    fetchController: AbortController;
-    fetchCache: FetchCache;
-    constructor(id: string, config: CrudConfig<T, C, M>);
-    executeFetch: (newContext: C) => Promise<void>;
-    executeRemove: (input: T) => Promise<void>;
-    executeUpdate: ({ item, updater, isOptimistic, skipSave, tag, }: {
-        item: T;
-        updater?: Updater<T>;
-        isOptimistic?: boolean;
-        skipSave?: boolean;
-        tag?: string;
-    }) => Promise<void>;
-    executeCreate: (input: Partial<T>) => Promise<void>;
-    private getCacheKey;
-    private getControlerId;
-    customLog: (title?: string, ...messages: any[]) => void;
-    private batch;
-    private setItems;
-    private setMetadata;
-    private setContext;
-    private remove;
-    private updateItem;
-    clearFetchCache: () => void;
-    private startFetch;
-    private endFetch;
-    cancelFetch: () => void;
-    cancelOperation: (id: string, tag?: string) => void;
-    private startTransition;
-    private notify;
-    getSnapshot: () => StoreState<T, C, M>;
-    subscribe: (fn: () => void) => () => void;
-    static instances: Map<string, Store<any>>;
-    static createStore<T extends Item = Item, C extends object = object, M extends object = object>(config: CrudConfig<T, C, M>): Store<T, C>;
-}
-
-export declare type StoreState<T extends Item = Item, C extends object = object, M extends object = object> = {
-    context: C;
-    items: Map<string, ItemWithState<T>>;
-    fetchState: {
-        isLoading: boolean;
-        errors: string[];
-        metadata?: M;
-    };
-};
-
-export declare type TransitionFn<T extends Item = Item> = (item: Partial<T>, option: QueryOption) => Promise<{
-    id: string;
-}>;
-
-export declare type TransitionStates = "create" | "update" | "delete" | "idle" | "changed";
-
-export declare type Updater<T> = (updatable: T) => void;
-
-/**
- * Main hook for managing CRUD operations with automatic state management.
- * Provides access to items, metadata, loading states, and CRUD operations.
- * @template T - Type of items to manage, must extend Item base type
- * @template C - Type of context object used in operations
- * @param config - Configuration object for CRUD operations
- * @returns Object containing items, state information, and CRUD operation handlers
- */
-export declare function useCrud<T extends Item = Item, C extends object = object, M extends object = object>(config: CrudConfig<T, C, M>): {
-    itemsById: Map<string, ItemWithState<T, TransitionStates>>;
-    items: ItemWithState<T, TransitionStates>[];
-    fetchState: {
-        isLoading: boolean;
-        errors: string[];
-        metadata?: M;
-    };
-    hasError: boolean;
-    cancelFetch: () => void;
-    cancelOperation: (id: string, tag?: string) => void;
-    refetch: () => void;
-    create: (item: Partial<T>) => void;
-    remove: (item: T) => void;
-    store: Store<T, C, object>;
-};
-
-export declare function useItemState<T extends Item = Item>(storeId: string, item: ItemWithState<T>): [
-T,
-    {
-    errors: Map<string, string[]>;
-    states: Set<string>;
-    save: () => void;
-    change: (cb: Updater<T>, tag?: string) => void;
-    update: (cb: Updater<T>, options?: {
-        tag?: string;
-        isOptimistic?: boolean;
-    }) => void;
-    remove: () => void;
-    cancel: () => void;
-    hasError: boolean;
-    errorCount: number;
-    itemWithState: ItemWithState<T>;
-    store: Store<T>;
-}
-];
-
-export { }
+import { Draft } from 'mutative';
+import { Config, Mutator } from './types';
+export type { Config, Change, SyncResult, ItemStatus, SyncQueueState, SyncState, ChangeType, ItemSyncStatus, FetchState, } from './types';
+export declare function useCrud<T, C>(config: Config<T, C>): {
+    items: Map<string, T>;
+    context: C;
+    syncState: import('./types').SyncState;
+    syncQueue: import('./types').SyncQueueState<T>;
+    loading: boolean;
+    syncing: boolean;
+    fetchStatus: import('./types').FetchState;
+    fetchError: string;
+    create: (item: T) => void;
+    update: (id: string, mutate: (draft: Draft<T>) => void) => void;
+    remove: (id: string) => void;
+    getItem: (id: string) => import('./item').Item<T, C>;
+    getItemStatus: (id: string) => {
+        type: import('./types').ChangeType;
+        status: import('./types').ItemSyncStatus;
+        retries: number;
+        error?: string;
+    };
+    setContext: (patchContext: Mutator<C>) => void;
+    refresh: () => Promise<void>;
+    pauseSync: () => void;
+    resumeSync: () => void;
+    retrySync: (id?: string) => void;
+};