@almadar/ui 1.0.0 → 1.0.10

package/dist/renderer/index.js

@@ -1,11 +1,11 @@
-import { createContext, useRef, useCallback, useEffect, useContext, useState } from 'react';
+import { executeClientEffects } from '../chunk-AQREMI4N.js';
+export { OfflineExecutor, createOfflineExecutor, executeClientEffects, filterEffectsByType, getEmitEffects, getNavigateEffects, getNotifyEffects, getRenderUIEffects, parseClientEffect, parseClientEffects, useOfflineExecutor } from '../chunk-AQREMI4N.js';
+import '../chunk-S7EYY36U.js';
+import { createContext, useRef, useCallback, useEffect, useContext, useMemo, useState } from 'react';
+import { jsx } from 'react/jsx-runtime';
 import componentMappingJson from '@almadar/patterns/component-mapping.json';
 import registryJson from '@almadar/patterns/registry.json';
 
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
 // renderer/pattern-resolver.ts
 var componentMapping = {};
 var patternRegistry = {};
@@ -74,111 +74,6 @@ function getPatternMapping(type) {
 function getPatternDefinition(type) {
   return patternRegistry[type];
 }
-
-// renderer/client-effect-executor.ts
-function executeClientEffects(effects, config) {
-  if (!effects || effects.length === 0) {
-    return;
-  }
-  for (const effect of effects) {
-    try {
-      executeEffect(effect, config);
-    } catch (error) {
-      console.error(
-        `[ClientEffectExecutor] Error executing effect:`,
-        effect,
-        error
-      );
-    }
-  }
-  config.onComplete?.();
-}
-function executeEffect(effect, config) {
-  const [effectType, ...args] = effect;
-  switch (effectType) {
-    case "render-ui": {
-      const [slot, patternConfig] = args;
-      executeRenderUI(slot, patternConfig, config);
-      break;
-    }
-    case "navigate": {
-      const [path, params] = args;
-      executeNavigate(path, params, config);
-      break;
-    }
-    case "notify": {
-      const [message, options] = args;
-      executeNotify(message, options, config);
-      break;
-    }
-    case "emit": {
-      const [event, payload] = args;
-      executeEmit(event, payload, config);
-      break;
-    }
-    default:
-      console.warn(`[ClientEffectExecutor] Unknown effect type: ${effectType}`);
-  }
-}
-function executeRenderUI(slot, patternConfig, config) {
-  config.renderToSlot(slot, patternConfig);
-}
-function executeNavigate(path, params, config) {
-  config.navigate(path, params);
-}
-function executeNotify(message, options, config) {
-  config.notify(message, options);
-}
-function executeEmit(event, payload, config) {
-  config.eventBus.emit(event, payload);
-}
-function parseClientEffect(raw) {
-  if (!Array.isArray(raw) || raw.length < 1) {
-    console.warn("[ClientEffectExecutor] Invalid effect format:", raw);
-    return null;
-  }
-  const [type, ...args] = raw;
-  if (typeof type !== "string") {
-    console.warn("[ClientEffectExecutor] Effect type must be string:", raw);
-    return null;
-  }
-  switch (type) {
-    case "render-ui":
-      return ["render-ui", args[0], args[1]];
-    case "navigate":
-      return ["navigate", args[0], args[1]];
-    case "notify":
-      return ["notify", args[0], args[1]];
-    case "emit":
-      return ["emit", args[0], args[1]];
-    default:
-      console.warn(`[ClientEffectExecutor] Unknown effect type: ${type}`);
-      return null;
-  }
-}
-function parseClientEffects(raw) {
-  if (!raw || !Array.isArray(raw)) {
-    return [];
-  }
-  return raw.map((effect) => parseClientEffect(effect)).filter((effect) => effect !== null);
-}
-function filterEffectsByType(effects, type) {
-  return effects.filter(
-    (effect) => effect[0] === type
-  );
-}
-function getRenderUIEffects(effects) {
-  return filterEffectsByType(effects, "render-ui");
-}
-function getNavigateEffects(effects) {
-  return filterEffectsByType(effects, "navigate");
-}
-function getNotifyEffects(effects) {
-  return filterEffectsByType(effects, "notify");
-}
-function getEmitEffects(effects) {
-  return filterEffectsByType(effects, "emit");
-}
 function useClientEffects(effects, options) {
   const {
     enabled = true,
@@ -466,322 +361,236 @@ function getPortalSlots() {
   return getSlotsByType("portal");
 }
 var ALL_SLOTS = Object.keys(SLOT_DEFINITIONS);
-var effectIdCounter = 0;
-function generateEffectId() {
-  return `offline-effect-${++effectIdCounter}-${Date.now()}`;
-}
-var OfflineExecutor = class {
-  constructor(config) {
-    __publicField(this, "config");
-    __publicField(this, "state");
-    __publicField(this, "storage");
-    /**
-     * Handle going online
-     */
-    __publicField(this, "handleOnline", () => {
-      this.state.isOffline = false;
-    });
-    /**
-     * Handle going offline
-     */
-    __publicField(this, "handleOffline", () => {
-      this.state.isOffline = true;
-    });
-    this.config = {
-      enableSyncQueue: true,
-      maxQueueSize: 100,
-      ...config
-    };
-    this.state = {
-      isOffline: !this.checkOnline(),
-      syncQueue: [],
-      localEffectsProcessed: 0,
-      effectsSynced: 0
-    };
-    this.storage = typeof localStorage !== "undefined" ? localStorage : null;
-    this.loadSyncQueue();
-    if (typeof window !== "undefined") {
-      window.addEventListener("online", this.handleOnline);
-      window.addEventListener("offline", this.handleOffline);
+function matchPath(pattern, path) {
+  const normalizeSegment = (p) => {
+    let normalized = p.trim();
+    if (!normalized.startsWith("/")) normalized = "/" + normalized;
+    if (normalized.length > 1 && normalized.endsWith("/")) {
+      normalized = normalized.slice(0, -1);
     }
+    return normalized;
+  };
+  const normalizedPattern = normalizeSegment(pattern);
+  const normalizedPath = normalizeSegment(path);
+  const patternParts = normalizedPattern.split("/").filter(Boolean);
+  const pathParts = normalizedPath.split("/").filter(Boolean);
+  if (patternParts.length !== pathParts.length) {
+    return null;
   }
-  /**
-   * Check if we're online (browser API)
-   */
-  checkOnline() {
-    return typeof navigator !== "undefined" ? navigator.onLine : true;
+  const params = {};
+  for (let i = 0; i < patternParts.length; i++) {
+    const patternPart = patternParts[i];
+    const pathPart = pathParts[i];
+    if (patternPart.startsWith(":")) {
+      const paramName = patternPart.slice(1);
+      params[paramName] = decodeURIComponent(pathPart);
+    } else if (patternPart !== pathPart) {
+      return null;
+    }
   }
-  /**
-   * Load sync queue from localStorage
-   */
-  loadSyncQueue() {
-    if (!this.storage) return;
-    try {
-      const stored = this.storage.getItem("orbital-offline-queue");
-      if (stored) {
-        this.state.syncQueue = JSON.parse(stored);
+  return params;
+}
+function extractRouteParams(pattern, path) {
+  return matchPath(pattern, path) || {};
+}
+function pathMatches(pattern, path) {
+  return matchPath(pattern, path) !== null;
+}
+function isInlineOrbital(orbital) {
+  return "name" in orbital && typeof orbital.name === "string";
+}
+function isInlinePage(page) {
+  return typeof page === "object" && page !== null && "name" in page && typeof page.name === "string";
+}
+function findPageByPath(schema, path) {
+  if (!schema.orbitals) return null;
+  for (const orbital of schema.orbitals) {
+    if (!isInlineOrbital(orbital)) continue;
+    if (!orbital.pages) continue;
+    for (const pageRef of orbital.pages) {
+      if (!isInlinePage(pageRef)) continue;
+      const page = pageRef;
+      const pagePath = page.path;
+      if (!pagePath) continue;
+      const params = matchPath(pagePath, path);
+      if (params !== null) {
+        return { page, params, orbitalName: orbital.name };
       }
-    } catch (error) {
-      console.warn("[OfflineExecutor] Failed to load sync queue:", error);
     }
   }
-  /**
-   * Save sync queue to localStorage
-   */
-  saveSyncQueue() {
-    if (!this.storage) return;
-    try {
-      this.storage.setItem("orbital-offline-queue", JSON.stringify(this.state.syncQueue));
-    } catch (error) {
-      console.warn("[OfflineExecutor] Failed to save sync queue:", error);
+  return null;
+}
+function findPageByName(schema, pageName) {
+  if (!schema.orbitals) return null;
+  for (const orbital of schema.orbitals) {
+    if (!isInlineOrbital(orbital)) continue;
+    if (!orbital.pages) continue;
+    for (const pageRef of orbital.pages) {
+      if (!isInlinePage(pageRef)) continue;
+      const page = pageRef;
+      if (page.name === pageName) {
+        return { page, orbitalName: orbital.name };
+      }
     }
   }
-  /**
-   * Add an effect to the sync queue
-   */
-  queueForSync(type, payload) {
-    if (!this.config.enableSyncQueue) return;
-    const effect = {
-      id: generateEffectId(),
-      timestamp: Date.now(),
-      type,
-      payload,
-      retries: 0,
-      maxRetries: 3
-    };
-    this.state.syncQueue.push(effect);
-    if (this.state.syncQueue.length > (this.config.maxQueueSize ?? 100)) {
-      this.state.syncQueue.shift();
+  return null;
+}
+function getDefaultPage(schema) {
+  if (!schema.orbitals) return null;
+  for (const orbital of schema.orbitals) {
+    if (!isInlineOrbital(orbital)) continue;
+    if (!orbital.pages) continue;
+    for (const pageRef of orbital.pages) {
+      if (isInlinePage(pageRef)) {
+        return { page: pageRef, orbitalName: orbital.name };
+      }
     }
-    this.saveSyncQueue();
-    this.config.onEffectQueued?.(effect);
-    this.config.onQueueChange?.(this.state.syncQueue);
   }
-  /**
-   * Execute client effects immediately.
-   */
-  executeClientEffects(effects) {
-    if (effects.length === 0) return;
-    executeClientEffects(effects, this.config);
-    this.state.localEffectsProcessed += effects.length;
+  return null;
+}
+function getAllPages(schema) {
+  const pages = [];
+  if (!schema.orbitals) return pages;
+  for (const orbital of schema.orbitals) {
+    if (!isInlineOrbital(orbital)) continue;
+    if (!orbital.pages) continue;
+    for (const pageRef of orbital.pages) {
+      if (isInlinePage(pageRef)) {
+        pages.push({ page: pageRef, orbitalName: orbital.name });
+      }
+    }
   }
-  /**
-   * Process an event in offline mode.
-   *
-   * Returns a simulated EventResponse with mock data.
-   * Client effects are executed immediately.
-   * Server effects are queued for sync.
-   */
-  processEventOffline(event, payload, effects) {
-    const clientEffects = [];
-    const fetchedData = {};
-    if (effects) {
-      for (const effect of effects) {
-        if (!Array.isArray(effect) || effect.length < 1) continue;
-        const [type, ...args] = effect;
-        switch (type) {
-          // Client effects - execute immediately
-          case "render-ui":
-          case "navigate":
-          case "notify":
-          case "emit":
-            clientEffects.push(effect);
-            break;
-          // Fetch effect - use mock data
-          case "fetch": {
-            const [entityName, _query] = args;
-            if (typeof entityName === "string" && this.config.mockDataProvider) {
-              fetchedData[entityName] = this.config.mockDataProvider(entityName);
-            }
-            break;
-          }
-          // Server effects - queue for sync
-          case "persist":
-          case "call-service":
-          case "spawn":
-          case "despawn":
-            this.queueForSync(type, { args, event, payload });
-            break;
-          default:
-            console.warn(`[OfflineExecutor] Unknown effect type: ${type}`);
-        }
+  return pages;
+}
+var NavigationContext = createContext(null);
+function NavigationProvider({
+  schema,
+  initialPage,
+  updateUrl = true,
+  onNavigate,
+  children
+}) {
+  const initialState = useMemo(() => {
+    let page = null;
+    let path = "/";
+    if (initialPage) {
+      const found = findPageByName(schema, initialPage);
+      if (found) {
+        page = found.page;
+        path = page.path || "/";
       }
     }
-    if (clientEffects.length > 0) {
-      this.executeClientEffects(clientEffects);
+    if (!page) {
+      const defaultPage = getDefaultPage(schema);
+      if (defaultPage) {
+        page = defaultPage.page;
+        path = page.path || "/";
+      }
     }
     return {
-      success: true,
-      data: Object.keys(fetchedData).length > 0 ? fetchedData : void 0,
-      clientEffects: clientEffects.length > 0 ? clientEffects : void 0
-    };
-  }
-  /**
-   * Sync pending effects to server.
-   *
-   * @param serverUrl - Base URL for the orbital server
-   * @param authToken - Optional auth token for requests
-   * @returns Number of successfully synced effects
-   */
-  async syncPendingEffects(serverUrl, authToken) {
-    if (this.state.syncQueue.length === 0) {
-      return 0;
-    }
-    this.state.lastSyncAttempt = Date.now();
-    let syncedCount = 0;
-    const failedEffects = [];
-    const headers = {
-      "Content-Type": "application/json"
+      activePage: page?.name || "",
+      currentPath: path,
+      initPayload: {},
+      navigationId: 0
     };
-    if (authToken) {
-      headers["Authorization"] = `Bearer ${authToken}`;
+  }, [schema, initialPage]);
+  const [state, setState] = useState(initialState);
+  const navigateTo = useCallback((path, payload) => {
+    const result = findPageByPath(schema, path);
+    if (!result) {
+      console.error(`[Navigation] No page found for path: ${path}`);
+      return;
     }
-    for (const effect of this.state.syncQueue) {
+    const { page, params } = result;
+    const finalPayload = { ...params, ...payload };
+    console.log("[Navigation] Navigating to:", {
+      path,
+      page: page.name,
+      params,
+      payload,
+      finalPayload
+    });
+    setState((prev) => ({
+      activePage: page.name,
+      currentPath: path,
+      initPayload: finalPayload,
+      navigationId: prev.navigationId + 1
+    }));
+    if (updateUrl && typeof window !== "undefined") {
       try {
-        const response = await fetch(`${serverUrl}/sync-effect`, {
-          method: "POST",
-          headers,
-          body: JSON.stringify({
-            type: effect.type,
-            payload: effect.payload,
-            offlineId: effect.id,
-            offlineTimestamp: effect.timestamp
-          })
-        });
-        if (response.ok) {
-          syncedCount++;
-        } else {
-          effect.retries++;
-          if (effect.retries < effect.maxRetries) {
-            failedEffects.push(effect);
-          }
-        }
-      } catch (error) {
-        effect.retries++;
-        if (effect.retries < effect.maxRetries) {
-          failedEffects.push(effect);
-        }
+        window.history.pushState(finalPayload, "", path);
+      } catch (e) {
+        console.warn("[Navigation] Could not update URL:", e);
       }
     }
-    this.state.syncQueue = failedEffects;
-    this.state.effectsSynced += syncedCount;
-    if (syncedCount > 0) {
-      this.state.lastSuccessfulSync = Date.now();
+    if (onNavigate) {
+      onNavigate(page.name, path, finalPayload);
     }
-    this.saveSyncQueue();
-    this.config.onQueueChange?.(this.state.syncQueue);
-    return syncedCount;
-  }
-  /**
-   * Get current executor state
-   */
-  getState() {
-    return { ...this.state };
-  }
-  /**
-   * Get number of pending effects
-   */
-  getPendingCount() {
-    return this.state.syncQueue.length;
-  }
-  /**
-   * Clear the sync queue
-   */
-  clearQueue() {
-    this.state.syncQueue = [];
-    this.saveSyncQueue();
-    this.config.onQueueChange?.(this.state.syncQueue);
-  }
-  /**
-   * Dispose the executor and clean up listeners
-   */
-  dispose() {
-    if (typeof window !== "undefined") {
-      window.removeEventListener("online", this.handleOnline);
-      window.removeEventListener("offline", this.handleOffline);
+  }, [schema, updateUrl, onNavigate]);
+  const navigateToPage = useCallback((pageName, payload) => {
+    const result = findPageByName(schema, pageName);
+    if (!result) {
+      console.error(`[Navigation] No page found with name: ${pageName}`);
+      return;
     }
-  }
-};
-function createOfflineExecutor(config) {
-  return new OfflineExecutor(config);
-}
-function useOfflineExecutor(options) {
-  const executorRef = useRef(null);
-  const [state, setState] = useState({
-    isOffline: false,
-    syncQueue: [],
-    localEffectsProcessed: 0,
-    effectsSynced: 0
-  });
-  useEffect(() => {
-    const executor = new OfflineExecutor({
-      ...options,
-      onQueueChange: (queue) => {
-        setState(executor.getState());
-        options.onQueueChange?.(queue);
-      }
+    const { page } = result;
+    const path = page.path || `/${pageName.toLowerCase()}`;
+    console.log("[Navigation] Navigating to page:", {
+      pageName,
+      path,
+      payload
     });
-    executorRef.current = executor;
-    setState(executor.getState());
-    return () => {
-      executor.dispose();
-      executorRef.current = null;
-    };
-  }, []);
-  useEffect(() => {
-    if (!options.autoSync || !options.serverUrl) return;
-    const handleOnline = async () => {
-      if (executorRef.current) {
-        await executorRef.current.syncPendingEffects(
-          options.serverUrl,
-          options.authToken
-        );
-        setState(executorRef.current.getState());
+    setState((prev) => ({
+      activePage: page.name,
+      currentPath: path,
+      initPayload: payload || {},
+      navigationId: prev.navigationId + 1
+    }));
+    if (updateUrl && typeof window !== "undefined") {
+      try {
+        window.history.pushState(payload || {}, "", path);
+      } catch (e) {
+        console.warn("[Navigation] Could not update URL:", e);
       }
-    };
-    window.addEventListener("online", handleOnline);
-    return () => window.removeEventListener("online", handleOnline);
-  }, [options.autoSync, options.serverUrl, options.authToken]);
-  const executeEffects = useCallback((effects) => {
-    executorRef.current?.executeClientEffects(effects);
-    if (executorRef.current) {
-      setState(executorRef.current.getState());
     }
-  }, []);
-  const processEventOffline = useCallback(
-    (event, payload, effects) => {
-      const result = executorRef.current?.processEventOffline(event, payload, effects);
-      if (executorRef.current) {
-        setState(executorRef.current.getState());
-      }
-      return result ?? { success: false, error: "Executor not initialized" };
-    },
-    []
-  );
-  const sync = useCallback(async () => {
-    if (!executorRef.current || !options.serverUrl) return 0;
-    const count = await executorRef.current.syncPendingEffects(
-      options.serverUrl,
-      options.authToken
-    );
-    setState(executorRef.current.getState());
-    return count;
-  }, [options.serverUrl, options.authToken]);
-  const clearQueue = useCallback(() => {
-    executorRef.current?.clearQueue();
-    if (executorRef.current) {
-      setState(executorRef.current.getState());
+    if (onNavigate) {
+      onNavigate(page.name, path, payload || {});
     }
-  }, []);
-  return {
+  }, [schema, updateUrl, onNavigate]);
+  const contextValue = useMemo(() => ({
     state,
-    isOffline: state.isOffline,
-    pendingCount: state.syncQueue.length,
-    executeClientEffects: executeEffects,
-    processEventOffline,
-    sync,
-    clearQueue
-  };
+    navigateTo,
+    navigateToPage,
+    schema,
+    isReady: !!state.activePage
+  }), [state, navigateTo, navigateToPage, schema]);
+  return /* @__PURE__ */ jsx(NavigationContext.Provider, { value: contextValue, children });
+}
+function useNavigation() {
+  return useContext(NavigationContext);
+}
+function useNavigateTo() {
+  const context = useContext(NavigationContext);
+  const noOp = useCallback((path, _payload) => {
+    console.warn(`[Navigation] navigateTo called outside NavigationProvider. Path: ${path}`);
+  }, []);
+  return context?.navigateTo || noOp;
+}
+function useNavigationState() {
+  const context = useContext(NavigationContext);
+  return context?.state || null;
+}
+function useInitPayload() {
+  const context = useContext(NavigationContext);
+  return context?.state.initPayload || {};
+}
+function useActivePage() {
+  const context = useContext(NavigationContext);
+  return context?.state.activePage || null;
+}
+function useNavigationId() {
+  const context = useContext(NavigationContext);
+  return context?.state.navigationId || 0;
 }
 function initializePatterns() {
   console.log("[PatternResolver] initializePatterns called");
@@ -803,6 +612,4 @@ function initializePatterns() {
   return Object.keys(componentMapping2).length;
 }
 
-export { ALL_SLOTS, ClientEffectConfigContext, ClientEffectConfigProvider, OfflineExecutor, SLOT_DEFINITIONS, createFetchedDataContext, createOfflineExecutor, executeClientEffects, filterEffectsByType, getEmitEffects, getInlineSlots, getKnownPatterns, getNavigateEffects, getNotifyEffects, getPatternDefinition, getPatternMapping, getPatternsByCategory, getPortalSlots, getRenderUIEffects, getSlotDefinition, getSlotsByType, hasEntities, initializePatternResolver, initializePatterns, isInlineSlot, isKnownPattern, isPortalSlot, mergeDataContexts, parseClientEffect, parseClientEffects, resolveEntityById, resolveEntityCount, resolveEntityData, resolveEntityDataWithQuery, resolvePattern, setComponentMapping, setPatternRegistry, useClientEffectConfig, useClientEffectConfigOptional, useClientEffects, useOfflineExecutor };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+export { ALL_SLOTS, ClientEffectConfigContext, ClientEffectConfigProvider, NavigationProvider, SLOT_DEFINITIONS, createFetchedDataContext, extractRouteParams, findPageByName, findPageByPath, getAllPages, getDefaultPage, getInlineSlots, getKnownPatterns, getPatternDefinition, getPatternMapping, getPatternsByCategory, getPortalSlots, getSlotDefinition, getSlotsByType, hasEntities, initializePatternResolver, initializePatterns, isInlineSlot, isKnownPattern, isPortalSlot, matchPath, mergeDataContexts, pathMatches, resolveEntityById, resolveEntityCount, resolveEntityData, resolveEntityDataWithQuery, resolvePattern, setComponentMapping, setPatternRegistry, useActivePage, useClientEffectConfig, useClientEffectConfigOptional, useClientEffects, useInitPayload, useNavigateTo, useNavigation, useNavigationId, useNavigationState };