@almadar/shell-web 0.0.0-stage → 0.1.0

package/dist/chunk-A2LR6VQQ.js

@@ -0,0 +1,349 @@
+import { createLogger } from '@almadar/logger';
+import { createContext, useRef, useCallback, useEffect, useContext } from 'react';
+import { componentMapping as componentMapping$1, patternsRegistry } from '@almadar/core/patterns';
+
+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 "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 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 "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");
+}
+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;
+}
+var log5 = createLogger("almadar:ui:pattern-resolver");
+function initializePatterns() {
+  log5.debug("initializePatterns called");
+  log5.debug("componentMappingJson loaded", () => ({ json: JSON.stringify(componentMapping$1) }));
+  log5.debug("registryJson keys", { keys: Object.keys(patternsRegistry) });
+  const componentMappingData = componentMapping$1;
+  const componentMapping2 = componentMappingData.mappings || {};
+  log5.debug("Extracted mappings count", { count: Object.keys(componentMapping2).length });
+  log5.debug("Sample mappings", { samples: Object.keys(componentMapping2).slice(0, 5) });
+  const registryData = patternsRegistry;
+  const patternRegistry2 = registryData.patterns || {};
+  log5.debug("Extracted patterns count", { count: Object.keys(patternRegistry2).length });
+  initializePatternResolver({
+    componentMapping: componentMapping2,
+    patternRegistry: patternRegistry2
+  });
+  log5.info("Initialized", {
+    componentMappings: Object.keys(componentMapping2).length,
+    patternDefinitions: Object.keys(patternRegistry2).length
+  });
+  return Object.keys(componentMapping2).length;
+}
+
+export { ClientEffectConfigContext, ClientEffectConfigProvider, executeClientEffects, getKnownPatterns, getPatternDefinition, getPatternMapping, getPatternsByCategory, getRenderUIEffects, hasEntities, initializePatternResolver, initializePatterns, isKnownPattern, parseClientEffect, parseClientEffects, resolveEntityById, resolveEntityData, resolveEntityDataWithQuery, resolvePattern, setComponentMapping, setPatternRegistry, useClientEffectConfig, useClientEffectConfigOptional, useClientEffects };