@mdxui/do 2.1.1 → 4.0.0

package/dist/chunk-NA652ART.js

@@ -0,0 +1,596 @@
+import { thingsKeys } from './chunk-4KXVN3EQ.js';
+import { useDO } from './chunk-WMNT4OIE.js';
+import { useQuery, useQueryClient } from '@tanstack/react-query';
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { useRouterState } from '@tanstack/react-router';
+
+var schemaKeys = {
+  all: ["schema"],
+  discovery: (ns) => [...schemaKeys.all, "discovery", ns ?? "all"],
+  definition: (ns, type) => [...schemaKeys.all, "definition", ns, type]
+};
+function useSchema(options = {}) {
+  const { ns, type, includeSystem = false, enabled = true } = options;
+  const { client } = useDO();
+  const query = useQuery({
+    queryKey: schemaKeys.discovery(ns),
+    queryFn: async () => {
+      try {
+        const result = await client.Schema.discover({
+          ns,
+          type,
+          includeSystem
+        });
+        return {
+          schemas: result.schemas ?? [],
+          namespaces: result.namespaces ?? [],
+          typesByNamespace: result.typesByNamespace ?? {},
+          serverInfo: result.serverInfo
+        };
+      } catch (error) {
+        try {
+          const typesResult = await client.Thing.types({ ns });
+          const namespaces = typesResult.namespaces ?? [ns ?? "default"];
+          const types = typesResult.types ?? [];
+          return {
+            schemas: types.map((t) => ({
+              name: t,
+              ns: ns ?? "default",
+              properties: []
+            })),
+            namespaces,
+            typesByNamespace: {
+              [ns ?? "default"]: types
+            }
+          };
+        } catch {
+          return {
+            schemas: [],
+            namespaces: [],
+            typesByNamespace: {}
+          };
+        }
+      }
+    },
+    enabled
+  });
+  return {
+    data: query.data ?? null,
+    isLoading: query.isLoading,
+    error: query.error,
+    refetch: query.refetch,
+    isRefetching: query.isRefetching
+  };
+}
+function useSchemaDefinition(ns, type, options = {}) {
+  const { enabled = true } = options;
+  const { client } = useDO();
+  const query = useQuery({
+    queryKey: schemaKeys.definition(ns, type),
+    queryFn: async () => {
+      try {
+        const result = await client.Schema.get({ ns, type });
+        return result;
+      } catch {
+        return {
+          name: type,
+          ns,
+          properties: []
+        };
+      }
+    },
+    enabled: enabled && Boolean(ns && type)
+  });
+  return {
+    data: query.data ?? null,
+    isLoading: query.isLoading,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+var namespacesKeys = {
+  all: ["namespaces"],
+  list: (includeSystem) => [...namespacesKeys.all, "list", includeSystem ?? false]
+};
+function useNamespaces(options = {}) {
+  const { includeSystem = false, enabled = true } = options;
+  const { client } = useDO();
+  const query = useQuery({
+    queryKey: namespacesKeys.list(includeSystem),
+    queryFn: async () => {
+      let primaryError = null;
+      try {
+        const result = await client.Namespace.list({ includeSystem });
+        if (Array.isArray(result)) {
+          return result.map(normalizeNamespace);
+        }
+        if (result.namespaces && Array.isArray(result.namespaces)) {
+          return result.namespaces.map(normalizeNamespace);
+        }
+        if (result.data && Array.isArray(result.data)) {
+          return result.data.map(normalizeNamespace);
+        }
+        return [];
+      } catch (err) {
+        primaryError = err instanceof Error ? err : new Error(String(err));
+        try {
+          const schemaResult = await client.Schema.discover({});
+          const namespaceNames = schemaResult.namespaces ?? ["default"];
+          return namespaceNames.map((name) => ({
+            id: name,
+            name,
+            types: [],
+            thingCount: 0,
+            createdAt: /* @__PURE__ */ new Date()
+          }));
+        } catch (fallbackErr) {
+          throw new Error(
+            `Failed to fetch namespaces: ${primaryError.message}. Fallback also failed: ${fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr)}`
+          );
+        }
+      }
+    },
+    enabled
+  });
+  return {
+    data: query.data ?? null,
+    isLoading: query.isLoading,
+    error: query.error,
+    refetch: query.refetch,
+    isRefetching: query.isRefetching,
+    status: query.status
+  };
+}
+function normalizeNamespace(ns) {
+  if (typeof ns === "string") {
+    return {
+      id: ns,
+      name: ns,
+      types: [],
+      thingCount: 0,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+  }
+  const nsObj = ns;
+  return {
+    id: nsObj.id ?? nsObj.name ?? "unknown",
+    name: nsObj.name ?? nsObj.id ?? "unknown",
+    description: nsObj.description,
+    baseUrl: nsObj.baseUrl,
+    types: nsObj.types ?? [],
+    thingCount: nsObj.thingCount ?? 0,
+    createdAt: nsObj.createdAt ? new Date(nsObj.createdAt) : /* @__PURE__ */ new Date()
+  };
+}
+var typesKeys = {
+  all: ["types"],
+  list: (ns, includeSystem) => [...typesKeys.all, "list", ns, includeSystem ?? false]
+};
+function useTypes(options = {}) {
+  const { includeSystem = false, enabled = true } = options;
+  const { namespace, client } = useDO();
+  const ns = options.ns ?? namespace;
+  const query = useQuery({
+    queryKey: typesKeys.list(ns, includeSystem),
+    queryFn: async () => {
+      let primaryError = null;
+      try {
+        const result = await client.Thing.types({ ns, includeSystem });
+        if (Array.isArray(result)) {
+          return result.map((t) => normalizeType(t, ns));
+        }
+        if (result.types && Array.isArray(result.types)) {
+          return result.types.map((t) => normalizeType(t, ns));
+        }
+        if (result.data && Array.isArray(result.data)) {
+          return result.data.map((t) => normalizeType(t, ns));
+        }
+        return [];
+      } catch (err) {
+        primaryError = err instanceof Error ? err : new Error(String(err));
+        try {
+          const schemaResult = await client.Schema.discover({ ns });
+          const typeNames = schemaResult.typesByNamespace?.[ns] ?? [];
+          return typeNames.map((name) => normalizeType(name, ns));
+        } catch (fallbackErr) {
+          throw new Error(
+            `Failed to fetch types: ${primaryError.message}. Fallback also failed: ${fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr)}`
+          );
+        }
+      }
+    },
+    enabled: enabled && Boolean(ns)
+  });
+  return {
+    data: query.data ?? null,
+    isLoading: query.isLoading,
+    error: query.error,
+    refetch: query.refetch,
+    isRefetching: query.isRefetching,
+    status: query.status
+  };
+}
+function normalizeType(type, defaultNs) {
+  if (typeof type === "string") {
+    return {
+      namespace: defaultNs,
+      name: type,
+      id: `${defaultNs}/${type}`,
+      label: type,
+      parentTypes: [],
+      properties: [],
+      subtypes: []
+    };
+  }
+  const typeObj = type;
+  const name = typeObj.name ?? typeObj.type ?? "unknown";
+  const namespace = typeObj.namespace ?? typeObj.ns ?? defaultNs;
+  return {
+    namespace,
+    name,
+    id: typeObj.id ?? `${namespace}/${name}`,
+    label: typeObj.label ?? typeObj.displayName ?? name,
+    description: typeObj.description,
+    parentTypes: typeObj.parentTypes ?? [],
+    properties: typeObj.properties ?? [],
+    subtypes: typeObj.subtypes ?? [],
+    examples: typeObj.examples
+  };
+}
+function useThingSubscription(options = {}) {
+  const {
+    type,
+    id,
+    filter,
+    onCreated,
+    onUpdated,
+    onDeleted,
+    onEvent,
+    onStateChange,
+    enabled = true,
+    invalidateOnUpdate = true
+  } = options;
+  const { client, namespace } = useDO();
+  const ns = options.ns ?? namespace;
+  const queryClient = useQueryClient();
+  const [state, setState] = useState("disconnected");
+  const [events, setEvents] = useState([]);
+  const [error, setError] = useState(null);
+  const subscriptionRef = useRef(null);
+  const reconnectTimeoutRef = useRef(null);
+  const MAX_EVENTS = 100;
+  const addEvent = useCallback((event) => {
+    setEvents((prev) => {
+      const newEvents = [event, ...prev];
+      return newEvents.slice(0, MAX_EVENTS);
+    });
+    onEvent?.(event);
+  }, [onEvent]);
+  const handleCreated = useCallback((thing) => {
+    addEvent({ type: "created", thing, timestamp: /* @__PURE__ */ new Date() });
+    onCreated?.(thing);
+    if (invalidateOnUpdate) {
+      queryClient.invalidateQueries({ queryKey: thingsKeys.lists() });
+    }
+  }, [addEvent, onCreated, invalidateOnUpdate, queryClient]);
+  const handleUpdated = useCallback((thing) => {
+    addEvent({ type: "updated", thing, timestamp: /* @__PURE__ */ new Date() });
+    onUpdated?.(thing);
+    if (invalidateOnUpdate) {
+      queryClient.setQueryData(
+        thingsKeys.detail(thing.ns, thing.type, thing.id),
+        thing
+      );
+      queryClient.invalidateQueries({ queryKey: thingsKeys.lists() });
+    }
+  }, [addEvent, onUpdated, invalidateOnUpdate, queryClient]);
+  const handleDeleted = useCallback((thingId) => {
+    addEvent({ type: "deleted", thingId, timestamp: /* @__PURE__ */ new Date() });
+    onDeleted?.(thingId);
+    if (invalidateOnUpdate) {
+      queryClient.invalidateQueries({ queryKey: thingsKeys.lists() });
+    }
+  }, [addEvent, onDeleted, invalidateOnUpdate, queryClient]);
+  const updateState = useCallback((newState) => {
+    setState(newState);
+    onStateChange?.(newState);
+    if (newState === "connected") {
+      addEvent({ type: "connected", timestamp: /* @__PURE__ */ new Date() });
+    } else if (newState === "disconnected") {
+      addEvent({ type: "disconnected", timestamp: /* @__PURE__ */ new Date() });
+    }
+  }, [onStateChange, addEvent]);
+  const connect = useCallback(async () => {
+    if (!enabled) return;
+    try {
+      updateState("connecting");
+      setError(null);
+      const subscriptionParams = {
+        ns,
+        type,
+        id,
+        filter
+      };
+      const subscription = await client.Thing.subscribe?.(subscriptionParams, {
+        onCreated: handleCreated,
+        onUpdated: handleUpdated,
+        onDeleted: handleDeleted,
+        onError: (err) => {
+          setError(err);
+          addEvent({ type: "error", error: err.message, timestamp: /* @__PURE__ */ new Date() });
+          updateState("error");
+        },
+        onConnected: () => updateState("connected"),
+        onDisconnected: () => updateState("disconnected")
+      });
+      if (subscription) {
+        subscriptionRef.current = subscription;
+        updateState("connected");
+      } else {
+        updateState("disconnected");
+      }
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Subscription failed");
+      setError(error2);
+      addEvent({ type: "error", error: error2.message, timestamp: /* @__PURE__ */ new Date() });
+      updateState("error");
+    }
+  }, [
+    enabled,
+    ns,
+    type,
+    id,
+    filter,
+    client,
+    handleCreated,
+    handleUpdated,
+    handleDeleted,
+    updateState,
+    addEvent
+  ]);
+  const disconnect = useCallback(() => {
+    if (subscriptionRef.current?.unsubscribe) {
+      subscriptionRef.current.unsubscribe();
+    }
+    subscriptionRef.current = null;
+    updateState("disconnected");
+  }, [updateState]);
+  const reconnect = useCallback(() => {
+    disconnect();
+    reconnectTimeoutRef.current = setTimeout(connect, 100);
+  }, [disconnect, connect]);
+  useEffect(() => {
+    if (enabled) {
+      connect();
+    }
+    return () => {
+      disconnect();
+      if (reconnectTimeoutRef.current) {
+        clearTimeout(reconnectTimeoutRef.current);
+      }
+    };
+  }, [enabled, connect, disconnect]);
+  return {
+    state,
+    events,
+    isConnected: state === "connected",
+    error,
+    reconnect,
+    disconnect
+  };
+}
+function useSingleThingSubscription(options) {
+  const [lastUpdate, setLastUpdate] = useState(null);
+  const { isConnected, error } = useThingSubscription({
+    ns: options.ns,
+    type: options.type,
+    id: options.id,
+    enabled: options.enabled,
+    onUpdated: (thing) => {
+      setLastUpdate(/* @__PURE__ */ new Date());
+      options.onUpdated?.(thing);
+    },
+    onDeleted: () => {
+      options.onDeleted?.();
+    }
+  });
+  return {
+    isConnected,
+    lastUpdate,
+    error
+  };
+}
+function useEditHistory(options = {}) {
+  const { maxHistory = 50, onUndo, onRedo } = options;
+  const [undoStack, setUndoStack] = useState([]);
+  const [redoStack, setRedoStack] = useState([]);
+  const isUndoingRef = useRef(false);
+  const pushOperation = useCallback(
+    (operation) => {
+      if (isUndoingRef.current) return;
+      const fullOperation = {
+        ...operation,
+        timestamp: Date.now()
+      };
+      setUndoStack((prev) => {
+        const newStack = [...prev, fullOperation];
+        if (newStack.length > maxHistory) {
+          return newStack.slice(-maxHistory);
+        }
+        return newStack;
+      });
+      setRedoStack([]);
+    },
+    [maxHistory]
+  );
+  const undo = useCallback(() => {
+    if (undoStack.length === 0) return null;
+    const operation = undoStack[undoStack.length - 1];
+    isUndoingRef.current = true;
+    try {
+      setUndoStack((prev) => prev.slice(0, -1));
+      setRedoStack((prev) => [...prev, operation]);
+      onUndo?.(operation);
+    } finally {
+      isUndoingRef.current = false;
+    }
+    return operation;
+  }, [undoStack, onUndo]);
+  const redo = useCallback(() => {
+    if (redoStack.length === 0) return null;
+    const operation = redoStack[redoStack.length - 1];
+    isUndoingRef.current = true;
+    try {
+      setRedoStack((prev) => prev.slice(0, -1));
+      setUndoStack((prev) => [...prev, operation]);
+      onRedo?.(operation);
+    } finally {
+      isUndoingRef.current = false;
+    }
+    return operation;
+  }, [redoStack, onRedo]);
+  const clearHistory = useCallback(() => {
+    setUndoStack([]);
+    setRedoStack([]);
+  }, []);
+  return {
+    pushOperation,
+    undo,
+    redo,
+    canUndo: undoStack.length > 0,
+    canRedo: redoStack.length > 0,
+    undoCount: undoStack.length,
+    redoCount: redoStack.length,
+    clearHistory
+  };
+}
+function isEditableTarget(target) {
+  if (!target || !(target instanceof HTMLElement)) return false;
+  const tagName = target.tagName;
+  if (tagName === "INPUT" || tagName === "TEXTAREA") {
+    return true;
+  }
+  if (target.isContentEditable || target.getAttribute("contenteditable") === "true") {
+    return true;
+  }
+  return false;
+}
+function matchesShortcut(event, config) {
+  if (event.key.toLowerCase() !== config.key.toLowerCase()) {
+    return false;
+  }
+  const isModifierPressed = config.ctrl || config.meta;
+  if (isModifierPressed) {
+    if (!event.ctrlKey && !event.metaKey) {
+      return false;
+    }
+  }
+  if (config.shift && !event.shiftKey) {
+    return false;
+  }
+  if (!config.shift && event.shiftKey) {
+    return false;
+  }
+  return true;
+}
+function useKeyboardShortcuts(shortcuts, options = {}) {
+  const { enabled = true, preventDefault = true, stopPropagation = false } = options;
+  const shortcutsRef = useRef(shortcuts);
+  shortcutsRef.current = shortcuts;
+  const optionsRef = useRef({ preventDefault, stopPropagation });
+  optionsRef.current = { preventDefault, stopPropagation };
+  const handleKeyDown = useCallback((event) => {
+    if (isEditableTarget(event.target)) {
+      return;
+    }
+    const currentShortcuts = shortcutsRef.current;
+    const currentOptions = optionsRef.current;
+    for (const config of currentShortcuts) {
+      if (config.disabled) {
+        continue;
+      }
+      if (matchesShortcut(event, config)) {
+        if (currentOptions.preventDefault) {
+          event.preventDefault();
+        }
+        if (currentOptions.stopPropagation) {
+          event.stopPropagation();
+        }
+        config.handler();
+        return;
+      }
+    }
+  }, []);
+  useEffect(() => {
+    if (!enabled) {
+      return;
+    }
+    document.addEventListener("keydown", handleKeyDown);
+    return () => {
+      document.removeEventListener("keydown", handleKeyDown);
+    };
+  }, [enabled, handleKeyDown]);
+}
+var ROUTE_LABELS = {
+  // Main
+  "/": "Overview",
+  // Development
+  "/agents": "Agents",
+  "/functions": "Functions",
+  "/workflows": "Workflows",
+  "/databases": "Databases",
+  // Data Model
+  "/things": "Things",
+  "/nouns": "Nouns",
+  "/verbs": "Verbs",
+  "/actions": "Actions",
+  "/relationships": "Relationships",
+  "/events": "Events",
+  // SaaS
+  "/customers": "Customers",
+  "/subscriptions": "Subscriptions",
+  "/integrations": "Integrations",
+  // Admin
+  "/orgs": "Organizations",
+  "/roles": "Roles",
+  "/users": "Users",
+  "/api-keys": "API Keys",
+  "/settings": "Settings"
+};
+function segmentToLabel(segment) {
+  const knownLabel = ROUTE_LABELS[`/${segment}`];
+  if (knownLabel) return knownLabel;
+  return segment.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function useBreadcrumbs(options) {
+  const { rootLabel = "Admin", includeRoot = true } = options ?? {};
+  const routerState = useRouterState();
+  const pathname = routerState.location.pathname;
+  const breadcrumbs = [];
+  if (pathname === "/" || pathname === "") {
+    if (includeRoot) {
+      breadcrumbs.push({ label: rootLabel });
+    }
+    return breadcrumbs;
+  }
+  if (includeRoot) {
+    breadcrumbs.push({ label: rootLabel, href: "/" });
+  }
+  const segments = pathname.split("/").filter(Boolean);
+  let currentPath = "";
+  segments.forEach((segment, index) => {
+    currentPath += `/${segment}`;
+    const isLast = index === segments.length - 1;
+    const label = ROUTE_LABELS[currentPath] || segmentToLabel(segment);
+    breadcrumbs.push({
+      label,
+      // Last item doesn't get a href (it's the current page)
+      href: isLast ? void 0 : currentPath
+    });
+  });
+  return breadcrumbs;
+}
+
+export { namespacesKeys, schemaKeys, typesKeys, useBreadcrumbs, useEditHistory, useKeyboardShortcuts, useNamespaces, useSchema, useSchemaDefinition, useSingleThingSubscription, useThingSubscription, useTypes };
+//# sourceMappingURL=chunk-NA652ART.js.map
+//# sourceMappingURL=chunk-NA652ART.js.map