@almadar/ui 5.79.0 → 5.79.1

package/dist/renderer/index.js

@@ -1,766 +0,0 @@
-import { createLogger } from '@almadar/logger';
-import { createContext, useRef, useCallback, useEffect, useContext, useState } from 'react';
-export { NavigationProvider, extractRouteParams, findPageByName, findPageByPath, getAllPages, getDefaultPage, matchPath, pathMatches, useActivePage, useInitPayload, useNavigateTo, useNavigation, useNavigationId, useNavigationState } from '@almadar/ui/providers';
-import { componentMapping as componentMapping$1, patternsRegistry } from '@almadar/patterns';
-
-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);
-var log = createLogger("almadar:ui:pattern-resolver");
-var componentMapping = {};
-var patternRegistry = {};
-function initializePatternResolver(config) {
-  componentMapping = config.componentMapping;
-  patternRegistry = config.patternRegistry;
-}
-function setComponentMapping(mapping) {
-  componentMapping = mapping;
-}
-function setPatternRegistry(registry) {
-  patternRegistry = registry;
-}
-function resolvePattern(config) {
-  const { type } = config;
-  const mapping = componentMapping[type];
-  if (!mapping) {
-    if (Object.keys(componentMapping).length === 0) {
-      log.warn("Component mapping not initialized. Call initializePatternResolver() at app startup.");
-    }
-    throw new Error(`Unknown pattern type: ${type}`);
-  }
-  if (mapping.deprecated) {
-    log.warn("Pattern is deprecated", {
-      type,
-      replacedBy: mapping.replacedBy
-    });
-  }
-  const validatedProps = validatePatternProps(config);
-  return {
-    component: mapping.component,
-    importPath: mapping.importPath,
-    category: mapping.category,
-    validatedProps
-  };
-}
-function validatePatternProps(config) {
-  const { type: patternType, ...rest } = config;
-  const definition = patternRegistry[patternType];
-  const definedProps = Object.fromEntries(
-    Object.entries(rest).filter((entry) => {
-      const v = entry[1];
-      if (v === void 0 || typeof v === "function") return false;
-      return true;
-    })
-  );
-  if (!definition || !definition.propsSchema) {
-    return definedProps;
-  }
-  const validated = { ...definedProps };
-  const schema = definition.propsSchema;
-  for (const [propName, propDef] of Object.entries(schema)) {
-    if (propDef.required && !(propName in validated)) {
-      log.warn("Missing required prop", { propName, patternType });
-    }
-  }
-  return validated;
-}
-function isKnownPattern(type) {
-  return type in componentMapping;
-}
-function getKnownPatterns() {
-  return Object.keys(componentMapping);
-}
-function getPatternsByCategory(category) {
-  return Object.entries(componentMapping).filter(([, mapping]) => mapping.category === category).map(([type]) => type);
-}
-function getPatternMapping(type) {
-  return componentMapping[type];
-}
-function getPatternDefinition(type) {
-  return patternRegistry[type];
-}
-var log2 = createLogger("almadar:ui:effects:client");
-function executeClientEffects(effects, config) {
-  if (!effects || effects.length === 0) {
-    return;
-  }
-  for (const effect of effects) {
-    try {
-      executeEffect(effect, config);
-    } catch (error) {
-      log2.error("Error executing effect", () => ({
-        effect: JSON.stringify(effect),
-        error: error instanceof Error ? error : String(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:
-      log2.warn("Unknown effect type", { effectType: String(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) {
-    log2.warn("Invalid effect format", () => ({ raw: JSON.stringify(raw) }));
-    return null;
-  }
-  const [type, ...args] = raw;
-  if (typeof type !== "string") {
-    log2.warn("Effect type must be string", () => ({ raw: JSON.stringify(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:
-      log2.warn("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 getNotifyEffects(effects) {
-  return filterEffectsByType(effects, "notify");
-}
-var log3 = createLogger("almadar:ui:effects:client-hook");
-function useClientEffects(effects, options) {
-  const {
-    enabled = true,
-    debug = false,
-    onComplete,
-    ...config
-  } = options;
-  const executedRef = useRef(/* @__PURE__ */ new Set());
-  const executingRef = useRef(false);
-  const executedCountRef = useRef(0);
-  const getEffectKey = useCallback((effect) => {
-    return JSON.stringify(effect);
-  }, []);
-  const execute = useCallback((effectsToExecute) => {
-    if (executingRef.current || effectsToExecute.length === 0) {
-      return;
-    }
-    executingRef.current = true;
-    const newEffects = effectsToExecute.filter((effect) => {
-      const key = getEffectKey(effect);
-      if (executedRef.current.has(key)) {
-        if (debug) {
-          log3.debug("Skipping duplicate effect", () => ({ effect: JSON.stringify(effect) }));
-        }
-        return false;
-      }
-      return true;
-    });
-    if (newEffects.length === 0) {
-      executingRef.current = false;
-      return;
-    }
-    if (debug) {
-      log3.debug("Executing effects", () => ({ effects: JSON.stringify(newEffects), count: newEffects.length }));
-    }
-    newEffects.forEach((effect) => {
-      executedRef.current.add(getEffectKey(effect));
-    });
-    executeClientEffects(newEffects, {
-      ...config,
-      onComplete: () => {
-        executedCountRef.current = newEffects.length;
-        executingRef.current = false;
-        onComplete?.();
-      }
-    });
-  }, [config, debug, getEffectKey, onComplete]);
-  useEffect(() => {
-    if (!enabled || !effects || effects.length === 0) {
-      return;
-    }
-    execute(effects);
-  }, [effects, enabled, execute]);
-  const prevEffectsRef = useRef(void 0);
-  useEffect(() => {
-    if (effects !== prevEffectsRef.current) {
-      prevEffectsRef.current = effects;
-    }
-  }, [effects]);
-  return {
-    executedCount: executedCountRef.current,
-    executing: executingRef.current,
-    execute
-  };
-}
-var ClientEffectConfigContext = createContext(null);
-var ClientEffectConfigProvider = ClientEffectConfigContext.Provider;
-function useClientEffectConfig() {
-  const context = useContext(ClientEffectConfigContext);
-  if (!context) {
-    throw new Error(
-      "useClientEffectConfig must be used within a ClientEffectConfigProvider. Make sure your component tree is wrapped with OrbitalProvider."
-    );
-  }
-  return context;
-}
-function useClientEffectConfigOptional() {
-  return useContext(ClientEffectConfigContext);
-}
-var log4 = createLogger("almadar:ui:data-resolver");
-function resolveEntityData(entityName, context) {
-  if (context.fetchedData && entityName in context.fetchedData) {
-    const data = context.fetchedData[entityName];
-    return {
-      data: Array.isArray(data) ? data : [],
-      loading: false
-    };
-  }
-  if (context.entityStore) {
-    try {
-      const data = context.entityStore.getRecords(entityName);
-      return {
-        data: Array.isArray(data) ? data : [],
-        loading: false
-      };
-    } catch (error) {
-      log4.warn("Error getting records from entity store", {
-        entityName,
-        error: error instanceof Error ? error : String(error)
-      });
-    }
-  }
-  const hasAnySources = context.fetchedData || context.entityStore;
-  return {
-    data: [],
-    loading: !hasAnySources
-    // Only loading if no sources configured
-  };
-}
-function resolveEntityDataWithQuery(entityName, queryRef, context) {
-  const resolution = resolveEntityData(entityName, context);
-  if (!queryRef || !context.querySingleton) {
-    return resolution;
-  }
-  try {
-    const filters = context.querySingleton.getFilters(queryRef);
-    const filteredData = applyFilters(resolution.data, filters);
-    return {
-      ...resolution,
-      data: filteredData
-    };
-  } catch (error) {
-    log4.warn("Error applying query filters", {
-      queryRef,
-      error: error instanceof Error ? error : String(error)
-    });
-    return resolution;
-  }
-}
-function applyFilters(data, filters) {
-  if (!filters || Object.keys(filters).length === 0) {
-    return data;
-  }
-  return data.filter((item) => {
-    if (typeof item !== "object" || item === null) {
-      return false;
-    }
-    return Object.entries(filters).every(([key, value]) => {
-      if (value === void 0 || value === null) {
-        return true;
-      }
-      const recordValue = item[key];
-      if (Array.isArray(value)) {
-        return value.includes(recordValue ?? null);
-      }
-      if (typeof value === "string" && typeof recordValue === "string") {
-        if (value.startsWith("*") && value.endsWith("*")) {
-          const pattern = value.slice(1, -1);
-          return recordValue.toLowerCase().includes(pattern.toLowerCase());
-        }
-      }
-      return recordValue === value;
-    });
-  });
-}
-function resolveEntityById(entityName, id, context) {
-  const { data } = resolveEntityData(entityName, context);
-  return data.find((item) => item.id === id || item["_id"] === id) ?? null;
-}
-function hasEntities(entityName, context) {
-  const { data } = resolveEntityData(entityName, context);
-  return data.length > 0;
-}
-
-// lib/slot-definitions.ts
-var SLOT_DEFINITIONS = {
-  // -------------------------------------------------------------------------
-  // Inline Slots - Render in place within the component tree
-  // -------------------------------------------------------------------------
-  main: {
-    name: "main",
-    type: "inline"
-  },
-  sidebar: {
-    name: "sidebar",
-    type: "inline"
-  },
-  // -------------------------------------------------------------------------
-  // Portal Slots - Render to document.body via React Portal
-  // -------------------------------------------------------------------------
-  modal: {
-    name: "modal",
-    type: "portal",
-    portalTarget: "body",
-    zIndex: 1e3
-  },
-  drawer: {
-    name: "drawer",
-    type: "portal",
-    portalTarget: "body",
-    zIndex: 900
-  },
-  overlay: {
-    name: "overlay",
-    type: "portal",
-    portalTarget: "body",
-    zIndex: 1100
-  },
-  center: {
-    name: "center",
-    type: "portal",
-    portalTarget: "body",
-    zIndex: 1e3
-  },
-  toast: {
-    name: "toast",
-    type: "portal",
-    portalTarget: "body",
-    zIndex: 1200
-  },
-  // -------------------------------------------------------------------------
-  // Game HUD Slots - Portal for game overlay UI
-  // -------------------------------------------------------------------------
-  "hud-top": {
-    name: "hud-top",
-    type: "portal",
-    portalTarget: "body",
-    zIndex: 500
-  },
-  "hud-bottom": {
-    name: "hud-bottom",
-    type: "portal",
-    portalTarget: "body",
-    zIndex: 500
-  },
-  floating: {
-    name: "floating",
-    type: "portal",
-    portalTarget: "body",
-    zIndex: 800
-  }
-};
-function getSlotDefinition(slot) {
-  return SLOT_DEFINITIONS[slot];
-}
-function isPortalSlot(slot) {
-  return SLOT_DEFINITIONS[slot]?.type === "portal";
-}
-function getSlotsByType(type) {
-  return Object.entries(SLOT_DEFINITIONS).filter(([, def]) => def?.type === type).map(([name]) => name);
-}
-function getInlineSlots() {
-  return getSlotsByType("inline");
-}
-var ALL_SLOTS = Object.keys(SLOT_DEFINITIONS);
-var log5 = createLogger("almadar:ui:effects:offline");
-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);
-    }
-  }
-  /**
-   * Check if we're online (browser API)
-   */
-  checkOnline() {
-    return typeof navigator !== "undefined" ? navigator.onLine : true;
-  }
-  /**
-   * 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);
-      }
-    } catch (error) {
-      log5.warn("Failed to load sync queue", { error: error instanceof Error ? error : String(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) {
-      log5.warn("Failed to save sync queue", { error: error instanceof Error ? error : String(error) });
-    }
-  }
-  /**
-   * 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();
-    }
-    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;
-  }
-  /**
-   * 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:
-            log5.warn("Unknown effect type", { type });
-        }
-      }
-    }
-    if (clientEffects.length > 0) {
-      this.executeClientEffects(clientEffects);
-    }
-    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"
-    };
-    if (authToken) {
-      headers["Authorization"] = `Bearer ${authToken}`;
-    }
-    for (const effect of this.state.syncQueue) {
-      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);
-        }
-      }
-    }
-    this.state.syncQueue = failedEffects;
-    this.state.effectsSynced += syncedCount;
-    if (syncedCount > 0) {
-      this.state.lastSuccessfulSync = Date.now();
-    }
-    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);
-    }
-  }
-};
-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);
-      }
-    });
-    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());
-      }
-    };
-    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());
-    }
-  }, []);
-  return {
-    state,
-    isOffline: state.isOffline,
-    pendingCount: state.syncQueue.length,
-    executeClientEffects: executeEffects,
-    processEventOffline,
-    sync,
-    clearQueue
-  };
-}
-var log6 = createLogger("almadar:ui:pattern-resolver");
-function initializePatterns() {
-  log6.debug("initializePatterns called");
-  log6.debug("componentMappingJson loaded", () => ({ json: JSON.stringify(componentMapping$1) }));
-  log6.debug("registryJson keys", { keys: Object.keys(patternsRegistry) });
-  const componentMappingData = componentMapping$1;
-  const componentMapping2 = componentMappingData.mappings || {};
-  log6.debug("Extracted mappings count", { count: Object.keys(componentMapping2).length });
-  log6.debug("Sample mappings", { samples: Object.keys(componentMapping2).slice(0, 5) });
-  const registryData = patternsRegistry;
-  const patternRegistry2 = registryData.patterns || {};
-  log6.debug("Extracted patterns count", { count: Object.keys(patternRegistry2).length });
-  initializePatternResolver({
-    componentMapping: componentMapping2,
-    patternRegistry: patternRegistry2
-  });
-  log6.info("Initialized", {
-    componentMappings: Object.keys(componentMapping2).length,
-    patternDefinitions: Object.keys(patternRegistry2).length
-  });
-  return Object.keys(componentMapping2).length;
-}
-
-export { ALL_SLOTS, ClientEffectConfigContext, ClientEffectConfigProvider, OfflineExecutor, SLOT_DEFINITIONS, createOfflineExecutor, executeClientEffects, getInlineSlots, getKnownPatterns, getNotifyEffects, getPatternDefinition, getPatternMapping, getPatternsByCategory, getRenderUIEffects, getSlotDefinition, hasEntities, initializePatternResolver, initializePatterns, isKnownPattern, isPortalSlot, parseClientEffect, parseClientEffects, resolveEntityById, resolveEntityData, resolveEntityDataWithQuery, resolvePattern, setComponentMapping, setPatternRegistry, useClientEffectConfig, useClientEffectConfigOptional, useClientEffects, useOfflineExecutor };