@mdxui/terminal 2.0.0

package/dist/chunk-JQ5H3WXL.js

@@ -0,0 +1,1291 @@
+// src/data/db.ts
+function createDB(config) {
+  const collections = {};
+  if (config?.collections) {
+    for (const collection of config.collections) {
+      collections[collection.name] = collection;
+    }
+  }
+  const db = {
+    collections,
+    sync: config?.sync,
+    close() {
+    },
+    async clear() {
+      for (const collection of Object.values(collections)) {
+        const docs = await collection.findMany();
+        for (const doc of docs) {
+          const primaryKey = collection.primaryKey || "id";
+          await collection.delete({ [primaryKey]: doc[primaryKey] });
+        }
+      }
+    }
+  };
+  return db;
+}
+
+// src/data/collection.ts
+function matchesFilter(value, filter) {
+  if (filter === null || filter === void 0 || typeof filter !== "object") {
+    return value === filter;
+  }
+  const ops = filter;
+  if ("$eq" in ops && value !== ops.$eq) return false;
+  if ("$ne" in ops && value === ops.$ne) return false;
+  if ("$gt" in ops && !(value > ops.$gt)) return false;
+  if ("$gte" in ops && !(value >= ops.$gte)) return false;
+  if ("$lt" in ops && !(value < ops.$lt)) return false;
+  if ("$lte" in ops && !(value <= ops.$lte)) return false;
+  if ("$in" in ops && !ops.$in.includes(value)) return false;
+  if ("$nin" in ops && ops.$nin.includes(value)) return false;
+  return true;
+}
+function matchesWhere(doc, where) {
+  if ("$or" in where && where.$or) {
+    const orClauses = where.$or;
+    const matchesOr = orClauses.some((clause) => matchesWhere(doc, clause));
+    if (!matchesOr) return false;
+    const { $or, ...rest } = where;
+    if (Object.keys(rest).length === 0) return true;
+    return matchesWhere(doc, rest);
+  }
+  for (const [key, filter] of Object.entries(where)) {
+    if (key === "$or") continue;
+    const value = doc[key];
+    if (!matchesFilter(value, filter)) {
+      return false;
+    }
+  }
+  return true;
+}
+function sortDocuments(docs, orderBy) {
+  const orderClauses = Array.isArray(orderBy) ? orderBy : [orderBy];
+  return [...docs].sort((a, b) => {
+    for (const clause of orderClauses) {
+      const [field, direction] = Object.entries(clause)[0];
+      const aVal = a[field];
+      const bVal = b[field];
+      if (aVal === null || aVal === void 0) {
+        if (bVal !== null && bVal !== void 0) return 1;
+        continue;
+      }
+      if (bVal === null || bVal === void 0) return -1;
+      let comparison = 0;
+      if (typeof aVal === "string") {
+        comparison = aVal.localeCompare(bVal);
+      } else if (typeof aVal === "number") {
+        comparison = aVal - bVal;
+      } else if (aVal instanceof Date) {
+        comparison = aVal.getTime() - bVal.getTime();
+      } else {
+        comparison = String(aVal).localeCompare(String(bVal));
+      }
+      if (comparison !== 0) {
+        return direction === "desc" ? -comparison : comparison;
+      }
+    }
+    return 0;
+  });
+}
+function createCollection(config) {
+  const { name, schema, primaryKey = "id", indexes = [] } = config;
+  const data = /* @__PURE__ */ new Map();
+  const subscribers = /* @__PURE__ */ new Set();
+  const collection = {
+    name,
+    schema,
+    primaryKey,
+    indexes,
+    async insert(doc) {
+      const validated = schema.parse(doc);
+      const id = validated[primaryKey];
+      if (data.has(String(id))) {
+        throw new Error(`Duplicate ${primaryKey}: ${id}`);
+      }
+      data.set(String(id), validated);
+      collection._notify();
+      return validated;
+    },
+    async update(filter, updates) {
+      const updated = [];
+      for (const [key, doc] of data.entries()) {
+        if (matchesWhere(doc, filter)) {
+          const newDoc = { ...doc, ...updates };
+          const validated = schema.parse(newDoc);
+          data.set(key, validated);
+          updated.push(validated);
+        }
+      }
+      if (updated.length > 0) {
+        collection._notify();
+      }
+      return updated;
+    },
+    async delete(filter) {
+      let deleted = false;
+      for (const [key, doc] of data.entries()) {
+        if (matchesWhere(doc, filter)) {
+          data.delete(key);
+          deleted = true;
+        }
+      }
+      if (deleted) {
+        collection._notify();
+      }
+    },
+    async findOne(filter) {
+      for (const doc of data.values()) {
+        if (matchesWhere(doc, filter)) {
+          return doc;
+        }
+      }
+      return null;
+    },
+    async findMany(options) {
+      let results = Array.from(data.values());
+      if (options?.where) {
+        results = results.filter((doc) => matchesWhere(doc, options.where));
+      }
+      if (options?.orderBy) {
+        results = sortDocuments(results, options.orderBy);
+      }
+      if (options?.offset !== void 0) {
+        results = results.slice(options.offset);
+      }
+      if (options?.limit !== void 0) {
+        results = results.slice(0, options.limit);
+      }
+      return results;
+    },
+    subscribe(callback) {
+      subscribers.add(callback);
+      return () => {
+        subscribers.delete(callback);
+      };
+    },
+    _notify() {
+      const allData = Array.from(data.values());
+      for (const callback of subscribers) {
+        callback(allData);
+      }
+    }
+  };
+  return collection;
+}
+
+// src/data/sync.ts
+function createDOSync(config) {
+  if (!config.namespaceUrl) {
+    throw new Error("namespaceUrl is required");
+  }
+  try {
+    new URL(config.namespaceUrl);
+  } catch {
+    throw new Error("Invalid namespaceUrl format");
+  }
+  let ws = null;
+  let authToken = config.authToken;
+  let messageId = 0;
+  let reconnectAttempts = 0;
+  let reconnectTimeout = null;
+  let isClosed = false;
+  let connectionState = "disconnected";
+  const pendingPush = /* @__PURE__ */ new Map();
+  const pendingPull = /* @__PURE__ */ new Map();
+  const subscribers = /* @__PURE__ */ new Set();
+  const connectionStateObservers = /* @__PURE__ */ new Set();
+  const mutationQueue = /* @__PURE__ */ new Map();
+  const reconnectOptions = {
+    enabled: config.reconnect?.enabled ?? false,
+    maxAttempts: config.reconnect?.maxAttempts ?? Infinity,
+    initialDelay: config.reconnect?.initialDelay ?? 1e3,
+    maxDelay: config.reconnect?.maxDelay ?? 3e4
+  };
+  const requestTimeout = config.requestTimeout ?? 3e4;
+  function notifyConnectionStateChange(newState) {
+    if (newState !== connectionState) {
+      connectionState = newState;
+      for (const observer of connectionStateObservers) {
+        observer(connectionState);
+      }
+    }
+  }
+  function queueMutation(changes) {
+    const id = `queued-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    const mutation = {
+      id,
+      changes,
+      queuedAt: Date.now(),
+      retryCount: 0
+    };
+    mutationQueue.set(id, mutation);
+    return mutation;
+  }
+  async function flushMutationQueue() {
+    const mutations = Array.from(mutationQueue.values());
+    for (const mutation of mutations) {
+      try {
+        await push(mutation.changes);
+        mutationQueue.delete(mutation.id);
+      } catch {
+        mutation.retryCount++;
+      }
+    }
+  }
+  function getWebSocketUrl() {
+    const url = new URL(config.namespaceUrl);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    if (authToken) {
+      url.searchParams.set("token", authToken);
+    }
+    return url.toString();
+  }
+  function nextMessageId() {
+    messageId++;
+    return `push-${messageId}`;
+  }
+  function handleMessage(event) {
+    let message;
+    try {
+      message = JSON.parse(event.data);
+    } catch {
+      return;
+    }
+    switch (message.type) {
+      case "ack": {
+        const pending = pendingPush.get(message.id);
+        if (pending) {
+          if (pending.timeoutId) {
+            clearTimeout(pending.timeoutId);
+          }
+          pendingPush.delete(message.id);
+          if (message.status === "error") {
+            pending.reject(new Error(message.error || "Push failed"));
+          } else if (message.status === "conflict") {
+            if (config.conflictResolution === "throw") {
+              pending.reject(new Error("Conflict detected"));
+            } else if (config.conflictResolution === "custom" && config.onConflict && message.conflicts) {
+              config.onConflict(message.conflicts).then(() => pending.resolve());
+            } else {
+              pending.resolve();
+            }
+          } else {
+            pending.resolve();
+          }
+        }
+        break;
+      }
+      case "pull-response": {
+        const entries = Array.from(pendingPull.entries());
+        if (entries.length > 0) {
+          const [id, pending] = entries[0];
+          if (pending.timeoutId) {
+            clearTimeout(pending.timeoutId);
+          }
+          pendingPull.delete(id);
+          pending.resolve(message.changes);
+        }
+        break;
+      }
+      case "sync": {
+        for (const callback of subscribers) {
+          callback(message.changes);
+        }
+        break;
+      }
+    }
+  }
+  function handleError() {
+    notifyConnectionStateChange("disconnected");
+    for (const [id, pending] of pendingPush) {
+      if (pending.timeoutId) {
+        clearTimeout(pending.timeoutId);
+      }
+    }
+    for (const [id, pending] of pendingPull) {
+      if (pending.timeoutId) {
+        clearTimeout(pending.timeoutId);
+      }
+      pending.reject(new Error("WebSocket error"));
+    }
+    pendingPull.clear();
+    scheduleReconnect();
+  }
+  function handleClose() {
+    ws = null;
+    notifyConnectionStateChange("disconnected");
+    if (!isClosed) {
+      scheduleReconnect();
+    }
+  }
+  function scheduleReconnect() {
+    if (!reconnectOptions.enabled || isClosed) {
+      return;
+    }
+    if (reconnectAttempts >= reconnectOptions.maxAttempts) {
+      return;
+    }
+    notifyConnectionStateChange("reconnecting");
+    const delay = Math.min(
+      reconnectOptions.initialDelay * Math.pow(2, reconnectAttempts),
+      reconnectOptions.maxDelay
+    );
+    reconnectAttempts++;
+    reconnectTimeout = setTimeout(() => {
+      if (!isClosed) {
+        connect();
+      }
+    }, delay);
+  }
+  const WS_CONNECTING = 0;
+  const WS_OPEN = 1;
+  const WS_CLOSING = 2;
+  const WS_CLOSED = 3;
+  function connect() {
+    if (ws && ws.readyState === WS_OPEN) {
+      return ws;
+    }
+    if (ws && ws.readyState === WS_CONNECTING) {
+      return ws;
+    }
+    notifyConnectionStateChange("connecting");
+    ws = new WebSocket(getWebSocketUrl());
+    ws.onopen = () => {
+      reconnectAttempts = 0;
+      notifyConnectionStateChange("connected");
+      flushMutationQueue().catch(() => {
+      });
+    };
+    ws.onmessage = handleMessage;
+    ws.onerror = handleError;
+    ws.onclose = handleClose;
+    return ws;
+  }
+  function ensureConnected() {
+    return new Promise((resolve, reject) => {
+      const socket = connect();
+      if (socket.readyState === WS_OPEN) {
+        resolve(socket);
+        return;
+      }
+      const originalOnOpen = socket.onopen;
+      const originalOnError = socket.onerror;
+      socket.onopen = (event) => {
+        socket.onopen = originalOnOpen;
+        socket.onerror = originalOnError;
+        if (originalOnOpen) {
+          originalOnOpen.call(socket, event);
+        }
+        resolve(socket);
+      };
+      socket.onerror = (event) => {
+        socket.onopen = originalOnOpen;
+        socket.onerror = originalOnError;
+        if (originalOnError) {
+          originalOnError.call(socket, event);
+        }
+        reject(new Error("WebSocket connection failed"));
+      };
+    });
+  }
+  function push(changes) {
+    const id = nextMessageId();
+    const isEmptyPush = changes.length === 0;
+    return new Promise((resolve, reject) => {
+      const message = {
+        type: "push",
+        id,
+        changes
+      };
+      if (authToken) {
+        message.auth = { token: authToken };
+      }
+      let timeoutId;
+      if (!isEmptyPush && requestTimeout > 0) {
+        timeoutId = setTimeout(() => {
+          const pending = pendingPush.get(id);
+          if (pending) {
+            pendingPush.delete(id);
+            pending.reject(new Error("Push timeout"));
+          }
+        }, requestTimeout);
+      }
+      if (!isEmptyPush) {
+        pendingPush.set(id, { resolve, reject, timeoutId });
+      }
+      ensureConnected().then((socket) => {
+        socket.send(JSON.stringify(message));
+        if (isEmptyPush) {
+          resolve();
+        }
+      }).catch((error) => {
+        if (!isEmptyPush) {
+          pendingPush.delete(id);
+          if (timeoutId) clearTimeout(timeoutId);
+          queueMutation(changes);
+          resolve();
+        } else {
+        }
+      });
+    });
+  }
+  function pull() {
+    const id = nextMessageId();
+    return new Promise((resolve, reject) => {
+      const message = {
+        type: "pull",
+        id
+      };
+      if (authToken) {
+        message.auth = { token: authToken };
+      }
+      let timeoutId;
+      if (requestTimeout > 0) {
+        timeoutId = setTimeout(() => {
+          const pending = pendingPull.get(id);
+          if (pending) {
+            pendingPull.delete(id);
+            pending.reject(new Error("Pull timeout"));
+          }
+        }, requestTimeout);
+      }
+      pendingPull.set(id, { resolve, reject, timeoutId });
+      ensureConnected().then((socket) => {
+        socket.send(JSON.stringify(message));
+      }).catch((error) => {
+        pendingPull.delete(id);
+        if (timeoutId) clearTimeout(timeoutId);
+        reject(error);
+      });
+    });
+  }
+  function subscribe(callback) {
+    subscribers.add(callback);
+    connect();
+    return () => {
+      subscribers.delete(callback);
+    };
+  }
+  function close() {
+    isClosed = true;
+    if (reconnectTimeout) {
+      clearTimeout(reconnectTimeout);
+      reconnectTimeout = null;
+    }
+    if (ws) {
+      ws.close();
+      ws = null;
+    }
+    notifyConnectionStateChange("disconnected");
+  }
+  function setAuthToken(token) {
+    authToken = token;
+  }
+  function onConnectionStateChange(callback) {
+    connectionStateObservers.add(callback);
+    callback(connectionState);
+    return () => {
+      connectionStateObservers.delete(callback);
+    };
+  }
+  function getConnectionState() {
+    return connectionState;
+  }
+  function getQueuedMutations() {
+    return Array.from(mutationQueue.values());
+  }
+  function getQueueStats() {
+    const mutations = Array.from(mutationQueue.values());
+    if (mutations.length === 0) {
+      return { count: 0, oldestAt: null };
+    }
+    const oldest = Math.min(...mutations.map((m) => m.queuedAt));
+    return { count: mutations.length, oldestAt: oldest };
+  }
+  return {
+    push,
+    pull,
+    subscribe,
+    close,
+    setAuthToken,
+    onConnectionStateChange,
+    getConnectionState,
+    getQueuedMutations,
+    getQueueStats
+  };
+}
+
+// src/data/context.tsx
+import * as React from "react";
+import { createContext, useContext } from "react";
+var DBContext = createContext(void 0);
+function DBProvider({ db, children }) {
+  return React.createElement(DBContext.Provider, { value: db }, children);
+}
+function useDBContext() {
+  const db = useContext(DBContext);
+  if (!db) {
+    throw new Error(
+      "useDBContext must be used within a DBProvider. Wrap your component with <DBProvider db={...}> at a higher level in the component tree."
+    );
+  }
+  return db;
+}
+
+// src/data/hooks.ts
+import { useState, useEffect, useCallback, useRef } from "react";
+function matchesFilter2(value, filter) {
+  if (filter === null || filter === void 0 || typeof filter !== "object") {
+    return value === filter;
+  }
+  const ops = filter;
+  if ("$eq" in ops && value !== ops.$eq) return false;
+  if ("$ne" in ops && value === ops.$ne) return false;
+  if ("$gt" in ops && !(value > ops.$gt)) return false;
+  if ("$gte" in ops && !(value >= ops.$gte)) return false;
+  if ("$lt" in ops && !(value < ops.$lt)) return false;
+  if ("$lte" in ops && !(value <= ops.$lte)) return false;
+  if ("$in" in ops && !ops.$in.includes(value)) return false;
+  if ("$nin" in ops && ops.$nin.includes(value)) return false;
+  return true;
+}
+function matchesWhere2(doc, where) {
+  if ("$or" in where && where.$or) {
+    const orClauses = where.$or;
+    const matchesOr = orClauses.some((clause) => matchesWhere2(doc, clause));
+    if (!matchesOr) return false;
+    const { $or, ...rest } = where;
+    if (Object.keys(rest).length === 0) return true;
+    return matchesWhere2(doc, rest);
+  }
+  for (const [key, filter] of Object.entries(where)) {
+    if (key === "$or") continue;
+    const value = doc[key];
+    if (!matchesFilter2(value, filter)) {
+      return false;
+    }
+  }
+  return true;
+}
+function sortDocuments2(docs, orderBy) {
+  const orderClauses = Array.isArray(orderBy) ? orderBy : [orderBy];
+  return [...docs].sort((a, b) => {
+    for (const clause of orderClauses) {
+      const [field, direction] = Object.entries(clause)[0];
+      const aVal = a[field];
+      const bVal = b[field];
+      if (aVal === null || aVal === void 0) {
+        if (bVal !== null && bVal !== void 0) return 1;
+        continue;
+      }
+      if (bVal === null || bVal === void 0) return -1;
+      let comparison = 0;
+      if (typeof aVal === "string") {
+        comparison = aVal.localeCompare(bVal);
+      } else if (typeof aVal === "number") {
+        comparison = aVal - bVal;
+      } else if (aVal instanceof Date) {
+        comparison = aVal.getTime() - bVal.getTime();
+      } else {
+        comparison = String(aVal).localeCompare(String(bVal));
+      }
+      if (comparison !== 0) {
+        return direction === "desc" ? -comparison : comparison;
+      }
+    }
+    return 0;
+  });
+}
+function useQuery(options) {
+  const db = useDBContext();
+  const [data, setData] = useState(void 0);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(void 0);
+  const { from, where, orderBy, limit, offset } = options;
+  const collection = db.collections[from];
+  const executeQuery = useCallback(async () => {
+    if (!collection) {
+      setError(new Error(`Collection '${from}' not found`));
+      setIsLoading(false);
+      return;
+    }
+    try {
+      const result = await collection.findMany({ where, orderBy, limit, offset });
+      setData(result);
+      setError(void 0);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [collection, from, JSON.stringify(where), JSON.stringify(orderBy), limit, offset]);
+  useEffect(() => {
+    executeQuery();
+  }, [executeQuery]);
+  useEffect(() => {
+    if (!collection) return;
+    const unsubscribe = collection.subscribe((allData) => {
+      let result = allData;
+      if (where) {
+        result = result.filter((doc) => matchesWhere2(doc, where));
+      }
+      if (orderBy) {
+        result = sortDocuments2(result, orderBy);
+      }
+      if (offset !== void 0) {
+        result = result.slice(offset);
+      }
+      if (limit !== void 0) {
+        result = result.slice(0, limit);
+      }
+      setData(result);
+    });
+    return unsubscribe;
+  }, [collection, JSON.stringify(where), JSON.stringify(orderBy), limit, offset]);
+  return {
+    data,
+    isLoading,
+    error,
+    refetch: executeQuery
+  };
+}
+function useMutation(options) {
+  const db = useDBContext();
+  const [isPending, setIsPending] = useState(false);
+  const [error, setError] = useState(void 0);
+  const { collection: collectionName, operation, optimistic = false } = options;
+  const collection = db.collections[collectionName];
+  const rollbackRef = useRef(null);
+  const mutate = useCallback(
+    async (mutationData) => {
+      if (!collection) {
+        throw new Error(`Collection '${collectionName}' not found`);
+      }
+      setIsPending(true);
+      setError(void 0);
+      let rollbackFn = null;
+      try {
+        if (operation === "insert") {
+          const insertData = mutationData;
+          if (optimistic) {
+            await collection.insert(insertData);
+            if (db.sync) {
+              try {
+                await db.sync.push([{ type: "insert", collection: collectionName, data: insertData }]);
+              } catch (syncError) {
+                const primaryKey = collection.primaryKey || "id";
+                await collection.delete({ [primaryKey]: insertData[primaryKey] });
+                throw syncError;
+              }
+            }
+          } else {
+            await collection.insert(insertData);
+            if (db.sync) {
+              await db.sync.push([{ type: "insert", collection: collectionName, data: insertData }]);
+            }
+          }
+        } else if (operation === "update") {
+          const updateData = mutationData;
+          await collection.update(updateData.where, updateData.data);
+          if (db.sync) {
+            await db.sync.push([{ type: "update", collection: collectionName, data: updateData }]);
+          }
+        } else if (operation === "delete") {
+          const deleteData = mutationData;
+          await collection.delete({ id: deleteData.id });
+          if (db.sync) {
+            await db.sync.push([{ type: "delete", collection: collectionName, data: deleteData }]);
+          }
+        }
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsPending(false);
+        rollbackRef.current = null;
+      }
+    },
+    [collection, collectionName, operation, optimistic, db.sync]
+  );
+  const reset = useCallback(() => {
+    setIsPending(false);
+    setError(void 0);
+  }, []);
+  return {
+    mutate,
+    isPending,
+    error,
+    reset
+  };
+}
+
+// src/data/reactive.ts
+import { useState as useState2, useEffect as useEffect2, useCallback as useCallback2, useRef as useRef2 } from "react";
+function useReactiveData(options) {
+  const db = useDBContext();
+  const {
+    collection: collectionName,
+    where,
+    orderBy: initialOrderBy,
+    limit,
+    offset,
+    selectable = false,
+    optimistic = true,
+    primaryKey = "id"
+  } = options;
+  const [data, setData] = useState2([]);
+  const [isLoading, setIsLoading] = useState2(true);
+  const [error, setError] = useState2(void 0);
+  const [isMutating, setIsMutating] = useState2(false);
+  const [sort, setSortState] = useState2(() => {
+    if (!initialOrderBy) return { field: null, direction: "asc" };
+    const orderClauses = Array.isArray(initialOrderBy) ? initialOrderBy : [initialOrderBy];
+    if (orderClauses.length === 0) return { field: null, direction: "asc" };
+    const [field, direction] = Object.entries(orderClauses[0])[0];
+    return { field, direction };
+  });
+  const [selection, setSelection] = useState2({
+    mode: selectable === true ? "single" : selectable === false ? "none" : selectable,
+    selected: /* @__PURE__ */ new Set()
+  });
+  const [pagination, setPagination] = useState2({
+    page: 1,
+    pageSize: limit ?? 20,
+    total: 0
+  });
+  const rollbackDataRef = useRef2([]);
+  const collection = db.collections[collectionName];
+  const currentOrderBy = sort.field ? { [sort.field]: sort.direction } : initialOrderBy;
+  const executeQuery = useCallback2(async () => {
+    if (!collection) {
+      setError(new Error(`Collection '${collectionName}' not found`));
+      setIsLoading(false);
+      return;
+    }
+    try {
+      const result = await collection.findMany({
+        where,
+        orderBy: currentOrderBy,
+        limit,
+        offset
+      });
+      setData(result);
+      setPagination((prev) => ({ ...prev, total: result.length }));
+      setError(void 0);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [collection, collectionName, JSON.stringify(where), JSON.stringify(currentOrderBy), limit, offset]);
+  useEffect2(() => {
+    executeQuery();
+  }, [executeQuery]);
+  useEffect2(() => {
+    if (!collection) return;
+    const unsubscribe = collection.subscribe((allData) => {
+      let result = allData;
+      if (where) {
+        result = result.filter((doc) => matchesWhere3(doc, where));
+      }
+      if (currentOrderBy) {
+        result = sortDocuments3(result, currentOrderBy);
+      }
+      if (offset !== void 0) {
+        result = result.slice(offset);
+      }
+      if (limit !== void 0) {
+        result = result.slice(0, limit);
+      }
+      setData(result);
+      setPagination((prev) => ({ ...prev, total: result.length }));
+    });
+    return unsubscribe;
+  }, [collection, JSON.stringify(where), JSON.stringify(currentOrderBy), limit, offset]);
+  const mutate = {
+    insert: useCallback2(async (newData) => {
+      if (!collection) {
+        throw new Error(`Collection '${collectionName}' not found`);
+      }
+      setIsMutating(true);
+      if (optimistic) {
+        rollbackDataRef.current = [...data];
+        setData((prev) => [...prev, newData]);
+      }
+      try {
+        await collection.insert(newData);
+      } catch (err) {
+        if (optimistic) {
+          setData(rollbackDataRef.current);
+        }
+        throw err;
+      } finally {
+        setIsMutating(false);
+      }
+    }, [collection, collectionName, data, optimistic]),
+    update: useCallback2(async (filter, updates) => {
+      if (!collection) {
+        throw new Error(`Collection '${collectionName}' not found`);
+      }
+      setIsMutating(true);
+      if (optimistic) {
+        rollbackDataRef.current = [...data];
+        setData((prev) => prev.map((item) => {
+          const matches = Object.entries(filter).every(([key, val]) => item[key] === val);
+          return matches ? { ...item, ...updates } : item;
+        }));
+      }
+      try {
+        await collection.update(filter, updates);
+      } catch (err) {
+        if (optimistic) {
+          setData(rollbackDataRef.current);
+        }
+        throw err;
+      } finally {
+        setIsMutating(false);
+      }
+    }, [collection, collectionName, data, optimistic]),
+    delete: useCallback2(async (filter) => {
+      if (!collection) {
+        throw new Error(`Collection '${collectionName}' not found`);
+      }
+      setIsMutating(true);
+      if (optimistic) {
+        rollbackDataRef.current = [...data];
+        setData((prev) => prev.filter((item) => {
+          const matches = Object.entries(filter).every(([key, val]) => item[key] === val);
+          return !matches;
+        }));
+      }
+      try {
+        await collection.delete(filter);
+      } catch (err) {
+        if (optimistic) {
+          setData(rollbackDataRef.current);
+        }
+        throw err;
+      } finally {
+        setIsMutating(false);
+      }
+    }, [collection, collectionName, data, optimistic])
+  };
+  const setSort = useCallback2((field) => {
+    setSortState((prev) => ({
+      field,
+      direction: prev.field === field && prev.direction === "asc" ? "desc" : "asc"
+    }));
+  }, []);
+  const toggleSelect = useCallback2((id) => {
+    setSelection((prev) => {
+      const newSelected = new Set(prev.selected);
+      if (prev.mode === "single") {
+        if (newSelected.has(id)) {
+          newSelected.clear();
+        } else {
+          newSelected.clear();
+          newSelected.add(id);
+        }
+      } else if (prev.mode === "multi") {
+        if (newSelected.has(id)) {
+          newSelected.delete(id);
+        } else {
+          newSelected.add(id);
+        }
+      }
+      return { ...prev, selected: newSelected };
+    });
+  }, []);
+  const selectAll = useCallback2(() => {
+    if (selection.mode === "none") return;
+    const allIds = data.map((item) => String(item[primaryKey]));
+    setSelection((prev) => ({ ...prev, selected: new Set(allIds) }));
+  }, [data, primaryKey, selection.mode]);
+  const clearSelection = useCallback2(() => {
+    setSelection((prev) => ({ ...prev, selected: /* @__PURE__ */ new Set() }));
+  }, []);
+  const setPage = useCallback2((page) => {
+    setPagination((prev) => ({ ...prev, page }));
+  }, []);
+  const setPageSize = useCallback2((size) => {
+    setPagination((prev) => ({ ...prev, pageSize: size, page: 1 }));
+  }, []);
+  return {
+    data,
+    isLoading,
+    error,
+    refetch: executeQuery,
+    mutate,
+    isMutating,
+    sort,
+    setSort,
+    selection,
+    toggleSelect,
+    selectAll,
+    clearSelection,
+    pagination,
+    setPage,
+    setPageSize
+  };
+}
+function useReactiveTable(options) {
+  return useReactiveData(options);
+}
+function useReactiveList(options) {
+  return useReactiveData(options);
+}
+function useReactiveMetrics(options) {
+  const db = useDBContext();
+  const { collection: collectionName, where, metrics: metricDefs } = options;
+  const [metrics, setMetrics] = useState2([]);
+  const [isLoading, setIsLoading] = useState2(true);
+  const [error, setError] = useState2(void 0);
+  const historyRef = useRef2(/* @__PURE__ */ new Map());
+  const collection = db.collections[collectionName];
+  const computeMetrics = useCallback2(async () => {
+    if (!collection) {
+      setError(new Error(`Collection '${collectionName}' not found`));
+      setIsLoading(false);
+      return;
+    }
+    try {
+      const data = await collection.findMany({ where });
+      const computed = metricDefs.map((def) => {
+        const values = data.map((doc) => {
+          const val = doc[def.field];
+          return typeof val === "number" ? val : 0;
+        });
+        let value;
+        switch (def.aggregate) {
+          case "count":
+            value = data.length;
+            break;
+          case "sum":
+            value = values.reduce((a, b) => a + b, 0);
+            break;
+          case "avg":
+            value = values.length > 0 ? values.reduce((a, b) => a + b, 0) / values.length : 0;
+            break;
+          case "min":
+            value = values.length > 0 ? Math.min(...values) : 0;
+            break;
+          case "max":
+            value = values.length > 0 ? Math.max(...values) : 0;
+            break;
+          case "latest":
+            value = values.length > 0 ? values[values.length - 1] : 0;
+            break;
+          default:
+            value = 0;
+        }
+        const history = historyRef.current.get(def.key) || [];
+        history.push(value);
+        if (history.length > 20) history.shift();
+        historyRef.current.set(def.key, history);
+        let trend = "neutral";
+        let trendValue;
+        if (history.length >= 2) {
+          const prev = history[history.length - 2];
+          const current = history[history.length - 1];
+          if (prev !== 0) {
+            trendValue = (current - prev) / prev * 100;
+            trend = trendValue > 0 ? "up" : trendValue < 0 ? "down" : "neutral";
+          }
+        }
+        let formattedValue = value;
+        if (def.format === "currency") {
+          formattedValue = `$${value.toLocaleString()}`;
+        } else if (def.format === "percentage") {
+          formattedValue = `${value.toFixed(1)}%`;
+        }
+        if (def.unit) {
+          formattedValue = `${formattedValue} ${def.unit}`;
+        }
+        return {
+          key: def.key,
+          label: def.label,
+          value: formattedValue,
+          trend,
+          trendValue,
+          sparkline: [...history]
+        };
+      });
+      setMetrics(computed);
+      setError(void 0);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [collection, collectionName, JSON.stringify(where), JSON.stringify(metricDefs)]);
+  useEffect2(() => {
+    computeMetrics();
+  }, [computeMetrics]);
+  useEffect2(() => {
+    if (!collection) return;
+    const unsubscribe = collection.subscribe(() => {
+      computeMetrics();
+    });
+    return unsubscribe;
+  }, [collection, computeMetrics]);
+  return {
+    metrics,
+    isLoading,
+    error,
+    refetch: computeMetrics
+  };
+}
+function useReactiveCard(options) {
+  const db = useDBContext();
+  const { collection: collectionName, where, optimistic = true } = options;
+  const [data, setData] = useState2(null);
+  const [isLoading, setIsLoading] = useState2(true);
+  const [error, setError] = useState2(void 0);
+  const [isUpdating, setIsUpdating] = useState2(false);
+  const rollbackRef = useRef2(null);
+  const collection = db.collections[collectionName];
+  const fetchData = useCallback2(async () => {
+    if (!collection) {
+      setError(new Error(`Collection '${collectionName}' not found`));
+      setIsLoading(false);
+      return;
+    }
+    try {
+      const result = await collection.findOne(where);
+      setData(result);
+      setError(void 0);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [collection, collectionName, JSON.stringify(where)]);
+  useEffect2(() => {
+    fetchData();
+  }, [fetchData]);
+  useEffect2(() => {
+    if (!collection) return;
+    const unsubscribe = collection.subscribe((allData) => {
+      const found = allData.find(
+        (doc) => Object.entries(where).every(([key, val]) => doc[key] === val)
+      );
+      setData(found ?? null);
+    });
+    return unsubscribe;
+  }, [collection, JSON.stringify(where)]);
+  const update = useCallback2(async (updates) => {
+    if (!collection || !data) {
+      throw new Error("Cannot update: no data or collection");
+    }
+    setIsUpdating(true);
+    if (optimistic) {
+      rollbackRef.current = data;
+      setData((prev) => prev ? { ...prev, ...updates } : null);
+    }
+    try {
+      await collection.update(where, updates);
+    } catch (err) {
+      if (optimistic && rollbackRef.current) {
+        setData(rollbackRef.current);
+      }
+      throw err;
+    } finally {
+      setIsUpdating(false);
+    }
+  }, [collection, data, where, optimistic]);
+  return {
+    data,
+    isLoading,
+    error,
+    refetch: fetchData,
+    update,
+    isUpdating
+  };
+}
+function matchesFilter3(value, filter) {
+  if (filter === null || filter === void 0 || typeof filter !== "object") {
+    return value === filter;
+  }
+  const ops = filter;
+  if ("$eq" in ops && value !== ops.$eq) return false;
+  if ("$ne" in ops && value === ops.$ne) return false;
+  if ("$gt" in ops && !(value > ops.$gt)) return false;
+  if ("$gte" in ops && !(value >= ops.$gte)) return false;
+  if ("$lt" in ops && !(value < ops.$lt)) return false;
+  if ("$lte" in ops && !(value <= ops.$lte)) return false;
+  if ("$in" in ops && !ops.$in.includes(value)) return false;
+  if ("$nin" in ops && ops.$nin.includes(value)) return false;
+  return true;
+}
+function matchesWhere3(doc, where) {
+  if ("$or" in where && where.$or) {
+    const orClauses = where.$or;
+    const matchesOr = orClauses.some((clause) => matchesWhere3(doc, clause));
+    if (!matchesOr) return false;
+    const { $or, ...rest } = where;
+    if (Object.keys(rest).length === 0) return true;
+    return matchesWhere3(doc, rest);
+  }
+  for (const [key, filter] of Object.entries(where)) {
+    if (key === "$or") continue;
+    const value = doc[key];
+    if (!matchesFilter3(value, filter)) {
+      return false;
+    }
+  }
+  return true;
+}
+function sortDocuments3(docs, orderBy) {
+  const orderClauses = Array.isArray(orderBy) ? orderBy : [orderBy];
+  return [...docs].sort((a, b) => {
+    for (const clause of orderClauses) {
+      const [field, direction] = Object.entries(clause)[0];
+      const aVal = a[field];
+      const bVal = b[field];
+      if (aVal === null || aVal === void 0) {
+        if (bVal !== null && bVal !== void 0) return 1;
+        continue;
+      }
+      if (bVal === null || bVal === void 0) return -1;
+      let comparison = 0;
+      if (typeof aVal === "string") {
+        comparison = aVal.localeCompare(bVal);
+      } else if (typeof aVal === "number") {
+        comparison = aVal - bVal;
+      } else if (aVal instanceof Date) {
+        comparison = aVal.getTime() - bVal.getTime();
+      } else {
+        comparison = String(aVal).localeCompare(String(bVal));
+      }
+      if (comparison !== 0) {
+        return direction === "desc" ? -comparison : comparison;
+      }
+    }
+    return 0;
+  });
+}
+
+// src/data/saas-collections.ts
+import { z } from "zod";
+var UserRoleSchema = z.enum(["admin", "user", "viewer"]);
+var UserSchema = z.object({
+  /** Unique user identifier */
+  id: z.string(),
+  /** User's display name */
+  name: z.string(),
+  /** User's email address (validated format) */
+  email: z.string().email(),
+  /** User's role: admin, user, or viewer */
+  role: UserRoleSchema,
+  /** When the user account was created */
+  createdAt: z.date()
+});
+var APIKeySchema = z.object({
+  /** Unique key identifier */
+  id: z.string(),
+  /** The actual API key string (secret) */
+  key: z.string(),
+  /** Human-readable name for the key */
+  name: z.string(),
+  /** Array of permission strings this key grants */
+  permissions: z.array(z.string()),
+  /** When the key expires */
+  expiresAt: z.date()
+});
+var WebhookSchema = z.object({
+  /** Unique webhook identifier */
+  id: z.string(),
+  /** Webhook endpoint URL (validated format) */
+  url: z.string().url(),
+  /** Events this webhook listens to (non-empty array) */
+  events: z.array(z.string()).min(1),
+  /** Webhook signing secret */
+  secret: z.string(),
+  /** Whether the webhook is currently active */
+  active: z.boolean()
+});
+var TeamSchema = z.object({
+  /** Unique team identifier */
+  id: z.string(),
+  /** Team name */
+  name: z.string(),
+  /** Array of user IDs who are members */
+  members: z.array(z.string())
+});
+var UsageSchema = z.object({
+  /** Unique usage record identifier */
+  id: z.string(),
+  /** Name of the metric being tracked */
+  metric: z.string(),
+  /** Numeric value of the metric */
+  value: z.number(),
+  /** When this metric was recorded */
+  timestamp: z.date()
+});
+function UsersCollection() {
+  return createCollection({
+    name: "users",
+    schema: UserSchema,
+    primaryKey: "id",
+    indexes: ["email", "role"]
+  });
+}
+function APIKeysCollection() {
+  return createCollection({
+    name: "apiKeys",
+    schema: APIKeySchema,
+    primaryKey: "id",
+    indexes: ["key", "name"]
+  });
+}
+function WebhooksCollection() {
+  return createCollection({
+    name: "webhooks",
+    schema: WebhookSchema,
+    primaryKey: "id",
+    indexes: ["url", "active"]
+  });
+}
+function TeamsCollection() {
+  return createCollection({
+    name: "teams",
+    schema: TeamSchema,
+    primaryKey: "id",
+    indexes: ["name"]
+  });
+}
+function UsageCollection() {
+  return createCollection({
+    name: "usage",
+    schema: UsageSchema,
+    primaryKey: "id",
+    indexes: ["metric", "timestamp"]
+  });
+}
+
+export {
+  createDB,
+  createCollection,
+  createDOSync,
+  DBProvider,
+  useDBContext,
+  useQuery,
+  useMutation,
+  useReactiveData,
+  useReactiveTable,
+  useReactiveList,
+  useReactiveMetrics,
+  useReactiveCard,
+  UserRoleSchema,
+  UserSchema,
+  APIKeySchema,
+  WebhookSchema,
+  TeamSchema,
+  UsageSchema,
+  UsersCollection,
+  APIKeysCollection,
+  WebhooksCollection,
+  TeamsCollection,
+  UsageCollection
+};