@fgv/ts-res-ui-components 5.0.0-21 → 5.0.0-23

package/lib/hooks/useResourceData.d.ts

@@ -1,6 +1,7 @@
 import { Result } from '@fgv/ts-utils';
 import { ResourceManagerState, ProcessedResources, ImportedDirectory, ImportedFile, JsonValue } from '../types';
 import { Config, Bundle, QualifierTypes, ResourceTypes } from '@fgv/ts-res';
+import * as ObservabilityTools from '../utils/observability';
 /**
  * Parameters for the useResourceData hook.
  * Allows customization of type factories for extended functionality.
@@ -12,6 +13,8 @@ export interface UseResourceDataParams {
     qualifierTypeFactory?: Config.IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, QualifierTypes.QualifierType>;
     /** Optional resource type factory for creating custom resource types */
     resourceTypeFactory?: Config.IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceTypes.ResourceType>;
+    /** Optional observability context for logging */
+    o11y?: ObservabilityTools.IObservabilityContext;
 }
 /**
  * Return type for the useResourceData hook.
@@ -25,11 +28,11 @@ export interface UseResourceDataReturn {
     /** Available actions for processing and managing resources */
     actions: {
         /** Process an imported directory structure into a resource system */
-        processDirectory: (directory: ImportedDirectory) => Promise<void>;
+        processDirectory: (directory: ImportedDirectory) => Promise<Result<void>>;
         /** Process a directory with an explicit configuration */
-        processDirectoryWithConfig: (directory: ImportedDirectory, config: Config.Model.ISystemConfiguration) => Promise<void>;
+        processDirectoryWithConfig: (directory: ImportedDirectory, config: Config.Model.ISystemConfiguration) => Promise<Result<void>>;
         /** Process an array of imported files into a resource system */
-        processFiles: (files: ImportedFile[]) => Promise<void>;
+        processFiles: (files: ImportedFile[]) => Promise<Result<void>>;
         /** Process a pre-compiled bundle file */
         processBundleFile: (bundle: Bundle.IBundle) => Promise<void>;
         /** Clear any current error state */
@@ -37,7 +40,7 @@ export interface UseResourceDataReturn {
         /** Reset the entire resource management state */
         reset: () => void;
         /** Resolve a specific resource with optional context */
-        resolveResource: (resourceId: string, context?: Record<string, string>) => Promise<Result<JsonValue>>;
+        resolveResource: (resourceId: string, context?: Record<string, string>) => Result<JsonValue>;
         /** Apply a new configuration to the current system */
         applyConfiguration: (config: Config.Model.ISystemConfiguration) => void;
         /** Update the processed resources state directly */

package/lib/hooks/useResourceData.js

@@ -1,7 +1,9 @@
 import { useState, useCallback } from 'react';
-import { succeed, fail } from '@fgv/ts-utils';
-import { Bundle, Runtime, Resources, Import } from '@fgv/ts-res';
+import { succeed, fail, mapResults } from '@fgv/ts-utils';
+import { Bundle, Runtime, Resources, Import, QualifierTypes } from '@fgv/ts-res';
 import { processImportedFiles, processImportedDirectory } from '../utils/tsResIntegration';
+import { createResolverWithContext, resolveResourceDetailed } from '../utils/resolutionUtils';
+import * as ObservabilityTools from '../utils/observability';
 const initialState = {
     isProcessing: false,
     processedResources: null,
@@ -50,119 +52,152 @@ const initialState = {
  */
 export function useResourceData(params) {
     const [state, setState] = useState(initialState);
+    const o11y = params?.o11y ?? ObservabilityTools.DefaultObservabilityContext;
     const processDirectory = useCallback(async (directory) => {
         setState((prev) => ({ ...prev, isProcessing: true, error: null }));
         try {
-            const result = processImportedDirectory(directory, state.activeConfiguration || undefined, params?.qualifierTypeFactory, params?.resourceTypeFactory);
-            if (result.isSuccess()) {
+            return processImportedDirectory(directory, state.activeConfiguration || undefined, params?.qualifierTypeFactory, params?.resourceTypeFactory, o11y)
+                .onSuccess((value) => {
+                o11y.diag.info(`[useResourceData] Directory processing succeeded, resources found: ${value.summary?.totalResources || 0}`);
+                o11y.diag.info(`[useResourceData] Resource IDs: ${JSON.stringify(value.summary?.resourceIds || [])}`);
                 setState((prev) => ({
                     ...prev,
                     isProcessing: false,
-                    processedResources: result.value,
+                    processedResources: value,
                     hasProcessedData: true,
                     isLoadedFromBundle: false,
                     bundleMetadata: null
                 }));
-            }
-            else {
-                throw new Error(result.message);
-            }
+                o11y.diag.info(`[useResourceData] State updated with ${value.summary?.totalResources || 0} resources`);
+                return succeed(undefined);
+            })
+                .onFailure((errorMessage) => {
+                o11y.diag.error(`[useResourceData] Directory processing failed: ${errorMessage}`);
+                o11y.user.error(`Directory import failed: ${errorMessage}`);
+                setState((prev) => ({
+                    ...prev,
+                    isProcessing: false,
+                    error: errorMessage
+                }));
+                return fail(errorMessage);
+            });
         }
         catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            o11y.diag.error(`[useResourceData] Exception during directory processing: ${errorMessage}`);
+            o11y.user.error(`Directory import failed: ${errorMessage}`);
             setState((prev) => ({
                 ...prev,
                 isProcessing: false,
-                error: error instanceof Error ? error.message : String(error)
+                error: errorMessage
             }));
+            return fail(errorMessage);
         }
-    }, [state.activeConfiguration, params?.qualifierTypeFactory, params?.resourceTypeFactory]);
+    }, [state.activeConfiguration, params?.qualifierTypeFactory, params?.resourceTypeFactory, o11y]);
     const processDirectoryWithConfig = useCallback(async (directory, config) => {
         setState((prev) => ({ ...prev, isProcessing: true, error: null, activeConfiguration: config }));
         try {
-            const processedResources = processImportedDirectory(directory, config, params?.qualifierTypeFactory, params?.resourceTypeFactory).orThrow();
-            setState((prev) => ({
-                ...prev,
-                isProcessing: false,
-                processedResources,
-                hasProcessedData: true,
-                isLoadedFromBundle: false,
-                bundleMetadata: null,
-                activeConfiguration: config
-            }));
+            return processImportedDirectory(directory, config, params?.qualifierTypeFactory, params?.resourceTypeFactory, o11y)
+                .onSuccess((value) => {
+                setState((prev) => ({
+                    ...prev,
+                    isProcessing: false,
+                    processedResources: value,
+                    hasProcessedData: true,
+                    isLoadedFromBundle: false,
+                    bundleMetadata: null,
+                    activeConfiguration: config
+                }));
+                return succeed(undefined);
+            })
+                .onFailure((errorMessage) => {
+                o11y.user.error(`Directory import with config failed: ${errorMessage}`);
+                setState((prev) => ({
+                    ...prev,
+                    isProcessing: false,
+                    error: errorMessage
+                }));
+                return fail(errorMessage);
+            });
         }
         catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            o11y.user.error(`Directory import with config failed: ${errorMessage}`);
             setState((prev) => ({
                 ...prev,
                 isProcessing: false,
-                error: error instanceof Error ? error.message : String(error)
+                error: errorMessage
             }));
+            return fail(errorMessage);
         }
-    }, [params?.qualifierTypeFactory, params?.resourceTypeFactory]);
+    }, [params?.qualifierTypeFactory, params?.resourceTypeFactory, o11y]);
     const processFiles = useCallback(async (files) => {
         setState((prev) => ({ ...prev, isProcessing: true, error: null }));
         try {
-            const processedResources = processImportedFiles(files, state.activeConfiguration || undefined, params?.qualifierTypeFactory, params?.resourceTypeFactory).orThrow();
-            setState((prev) => ({
-                ...prev,
-                isProcessing: false,
-                processedResources,
-                hasProcessedData: true,
-                isLoadedFromBundle: false,
-                bundleMetadata: null
-            }));
+            return processImportedFiles(files, state.activeConfiguration || undefined, params?.qualifierTypeFactory, params?.resourceTypeFactory, o11y)
+                .onSuccess((value) => {
+                setState((prev) => ({
+                    ...prev,
+                    isProcessing: false,
+                    processedResources: value,
+                    hasProcessedData: true,
+                    isLoadedFromBundle: false,
+                    bundleMetadata: null
+                }));
+                return succeed(undefined);
+            })
+                .onFailure((errorMessage) => {
+                o11y.user.error(`Files import failed: ${errorMessage}`);
+                setState((prev) => ({
+                    ...prev,
+                    isProcessing: false,
+                    error: errorMessage
+                }));
+                return fail(errorMessage);
+            });
         }
         catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            o11y.user.error(`Files import failed: ${errorMessage}`);
             setState((prev) => ({
                 ...prev,
                 isProcessing: false,
-                error: error instanceof Error ? error.message : String(error)
+                error: errorMessage
             }));
+            return fail(errorMessage);
         }
-    }, [state.activeConfiguration, params?.qualifierTypeFactory, params?.resourceTypeFactory]);
+    }, [state.activeConfiguration, params?.qualifierTypeFactory, params?.resourceTypeFactory, o11y]);
     const processBundleFile = useCallback(async (bundle) => {
-        console.log('[Bundle Processing] Starting bundle processing...', bundle);
+        o11y.diag.info('[Bundle Processing] Starting bundle processing...', bundle);
         setState((prev) => ({ ...prev, isProcessing: true, error: null }));
         try {
-            console.log('[Bundle Processing] Attempting to extract bundle components...');
+            o11y.diag.info('[Bundle Processing] Attempting to extract bundle components...');
             // Extract bundle components (configuration and compiled collection)
-            const componentsResult = Bundle.BundleUtils.extractBundleComponents(bundle);
-            console.log('[Bundle Processing] Component extraction result:', componentsResult.isSuccess() ? 'SUCCESS' : `FAILED: ${componentsResult.message}`);
-            if (componentsResult.isFailure()) {
-                throw new Error(`Failed to extract bundle components: ${componentsResult.message}`);
-            }
-            const { systemConfiguration, compiledCollection, metadata } = componentsResult.value;
-            console.log('[Bundle Processing] Extracted components:', {
+            const { systemConfiguration, compiledCollection, metadata } = Bundle.BundleUtils.extractBundleComponents(bundle).orThrow((msg) => `Failed to extract bundle components: ${msg}`);
+            o11y.diag.info('[Bundle Processing] Extracted components:', {
                 hasSystemConfiguration: !!systemConfiguration,
                 hasCompiledCollection: !!compiledCollection,
                 hasMetadata: !!metadata,
                 systemConfiguration: systemConfiguration
             });
             // Use BundleLoader to create a fully functional resource manager from the bundle
-            console.log('[Bundle Processing] Using BundleLoader to create resource manager from bundle');
-            const bundleManagerResult = Bundle.BundleLoader.createManagerFromBundle({
-                bundle: bundle,
-                skipChecksumVerification: true // Skip for now since we're in a browser environment
-            });
-            if (bundleManagerResult.isFailure()) {
-                throw new Error(`Failed to create resource manager from bundle: ${bundleManagerResult.message}`);
-            }
+            o11y.diag.info('[Bundle Processing] Using BundleLoader to create resource manager from bundle');
             // The bundle's IResourceManager contains all the resources and candidates
             // We'll use it directly for both UI and resolution
-            const bundleResourceManager = bundleManagerResult.value;
+            const bundleResourceManager = Bundle.BundleLoader.createManagerFromBundle({
+                bundle: bundle,
+                skipChecksumVerification: true // Skip for now since we're in a browser environment
+            }).orThrow((msg) => `Failed to create resource manager from bundle: ${msg}`);
             // Debug: Check what resources are in the original bundle manager
-            console.log('[Bundle Processing] Original bundle manager resources:', {
+            o11y.diag.info('[Bundle Processing] Original bundle manager resources:', {
                 numResources: bundleResourceManager.numResources,
                 numCandidates: bundleResourceManager.numCandidates,
                 resourceIds: Array.from(bundleResourceManager.builtResources.keys())
             });
             // Convert the compiled collection to an editable ResourceManagerBuilder
             // using createFromCompiledResourceCollection for exact reconstruction
-            const reconstructedBuilderResult = Resources.ResourceManagerBuilder.createFromCompiledResourceCollection(compiledCollection, systemConfiguration);
-            if (reconstructedBuilderResult.isFailure()) {
-                throw new Error(`Failed to reconstruct builder from compiled collection: ${reconstructedBuilderResult.message}`);
-            }
-            const editableResourceManager = reconstructedBuilderResult.value;
-            console.log('[Bundle Processing] Normalized builder resources:', {
+            const editableResourceManager = Resources.ResourceManagerBuilder.createFromCompiledResourceCollection(compiledCollection, systemConfiguration).orThrow((msg) => `Failed to reconstruct builder from compiled collection: ${msg}`);
+            o11y.diag.info('[Bundle Processing] Normalized builder resources:', {
                 numResources: editableResourceManager.resources.size,
                 numCandidates: Array.from(editableResourceManager.getAllCandidates()).length,
                 resourceIds: Array.from(editableResourceManager.resources.keys())
@@ -183,89 +218,43 @@ export function useResourceData(params) {
                     qualifiers: systemConfiguration.qualifiers
                 }).orThrow()
             };
-            // Extract configuration for UI display using the collector API
-            // Note: The collectors contain instantiated objects, not raw config
+            // Extract configuration for UI display using the new getConfigurationJson method
+            const allQualifierTypes = mapResults(Array.from(system.qualifierTypes.values()).map((qt) => qt
+                .getConfigurationJson()
+                .onSuccess((jsonConfig) => QualifierTypes.Config.Convert.anyQualifierTypeConfig.convert(jsonConfig)))).orThrow((msg) => `Failed to extract qualifier type configurations: ${msg}`);
+            const systemQualifierTypes = allQualifierTypes.filter(QualifierTypes.Config.isSystemQualifierTypeConfig);
             const configForStorage = {
                 name: 'Bundle Configuration',
                 description: metadata?.description || 'Configuration extracted from bundle',
-                qualifierTypes: Array.from(system.qualifierTypes.values()).map((qt) => {
-                    console.log('[Bundle Processing] Extracting qualifier type:', qt);
-                    // Determine the system type based on the class name
-                    let systemType = 'literal';
-                    if (qt.constructor?.name === 'LanguageQualifierType') {
-                        systemType = 'language';
-                    }
-                    else if (qt.constructor?.name === 'TerritoryQualifierType') {
-                        systemType = 'territory';
-                    }
-                    else if (qt.constructor?.name === 'LiteralQualifierType') {
-                        systemType = 'literal';
-                    }
-                    // Extract configuration properties based on type
-                    const configuration = {};
-                    // Common properties
-                    if (qt.allowContextList !== undefined) {
-                        configuration.allowContextList = qt.allowContextList;
-                    }
-                    // LiteralQualifierType specific
-                    if (systemType === 'literal') {
-                        const qtAny = qt;
-                        if (qtAny.caseSensitive !== undefined) {
-                            configuration.caseSensitive = qtAny.caseSensitive;
-                        }
-                        if (qtAny.enumeratedValues) {
-                            configuration.enumeratedValues = qtAny.enumeratedValues;
-                        }
-                        if (qtAny.hierarchy) {
-                            configuration.hierarchy = qtAny.hierarchy;
-                        }
-                    }
-                    // TerritoryQualifierType specific
-                    if (systemType === 'territory') {
-                        const qtAny = qt;
-                        if (qtAny.acceptLowercase !== undefined) {
-                            configuration.acceptLowercase = qtAny.acceptLowercase;
-                        }
-                        if (qtAny.allowedTerritories) {
-                            configuration.allowedTerritories = qtAny.allowedTerritories;
-                        }
-                    }
-                    return {
-                        name: qt.name,
-                        systemType: systemType,
-                        configuration: configuration
-                    };
-                }),
+                qualifierTypes: systemQualifierTypes,
                 qualifiers: Array.from(system.qualifiers.values()).map((q) => {
-                    console.log('[Bundle Processing] Extracting qualifier:', q);
+                    o11y.diag.info('[Bundle Processing] Extracting qualifier:', q);
                     // Instantiated Qualifier objects have .type property which is a QualifierType object
-                    const qAny = q;
-                    const typeName = q.type?.name || qAny.typeName;
+                    const typeName = q.type.name;
                     if (!typeName) {
-                        console.error('[Bundle Processing] Missing typeName for qualifier:', q);
+                        o11y.diag.error('[Bundle Processing] Missing typeName for qualifier:', q);
                     }
                     return {
                         name: q.name,
-                        typeName: (typeName || 'unknown'),
+                        typeName,
                         token: q.token,
-                        defaultPriority: q.defaultPriority || 500,
-                        defaultValue: q.defaultValue,
-                        tokenIsOptional: q.tokenIsOptional || false
+                        defaultPriority: q.defaultPriority,
+                        tokenIsOptional: q.tokenIsOptional,
+                        ...(q.defaultValue !== undefined ? { defaultValue: q.defaultValue } : {})
                     };
                 }),
                 resourceTypes: Array.from(system.resourceTypes.values()).map((rt, index) => {
-                    console.log('[Bundle Processing] Extracting resource type:', rt);
+                    o11y.diag.info('[Bundle Processing] Extracting resource type:', rt);
                     // ResourceTypes in bundles might not have a name property
                     // Default to 'json' for JsonResourceType
-                    const rtAny = rt;
-                    const typeName = rt.constructor?.name === 'JsonResourceType' ? 'json' : rtAny.typeName || 'json';
+                    const typeName = rt.systemTypeName;
                     return {
-                        name: (rtAny.name || `resourceType${index}`), // Provide a default name if missing
-                        typeName: typeName
+                        name: rt.key,
+                        typeName: rt.systemTypeName
                     };
                 })
             };
-            console.log('[Bundle Processing] Extracted configuration for UI:', configForStorage);
+            o11y.diag.info('[Bundle Processing] Extracted configuration for UI:', configForStorage);
             // Extract resource IDs from the loaded resource manager
             const resourceIds = [];
             let resourceCount = 0;
@@ -278,16 +267,13 @@ export function useResourceData(params) {
                     resourceCount++;
                 }
             }
-            console.log(`Bundle loaded with ${resourceCount} resources (with candidates):`, resourceIds);
+            o11y.diag.info(`Bundle loaded with ${resourceCount} resources (with candidates):`, resourceIds);
             // Create a resolver using the bundle's resource manager
-            const resolverResult = Runtime.ResourceResolver.create({
+            const resolver = Runtime.ResourceResolver.create({
                 resourceManager: system.resourceManager,
                 qualifierTypes: system.qualifierTypes,
                 contextQualifierProvider: system.contextQualifierProvider
-            });
-            if (resolverResult.isFailure()) {
-                throw new Error(`Failed to create resolver: ${resolverResult.message}`);
-            }
+            }).orThrow((msg) => `Failed to create resolver: ${msg}`);
             // No longer create a separate CompiledResourceCollection manager
             // We'll derive the compiled collection from ResourceManagerBuilder when needed
             // Create the processed resources structure with bundle data
@@ -301,7 +287,7 @@ export function useResourceData(params) {
                     contextQualifierProvider: system.contextQualifierProvider
                 },
                 compiledCollection,
-                resolver: resolverResult.value,
+                resolver,
                 resourceCount,
                 summary: {
                     totalResources: resourceCount,
@@ -310,7 +296,7 @@ export function useResourceData(params) {
                     warnings: [`Bundle loaded with ${resourceCount} resources from compiled collection`]
                 }
             };
-            console.log('[Bundle Processing] Setting final state...', {
+            o11y.diag.info('[Bundle Processing] Setting final state...', {
                 resourceCount,
                 resourceIds,
                 configForStorage,
@@ -326,7 +312,7 @@ export function useResourceData(params) {
                 isLoadedFromBundle: true,
                 bundleMetadata: metadata
             }));
-            console.log('[Bundle Processing] Bundle processing completed successfully!');
+            o11y.diag.info('[Bundle Processing] Bundle processing completed successfully!');
         }
         catch (error) {
             setState((prev) => ({
@@ -335,67 +321,56 @@ export function useResourceData(params) {
                 error: error instanceof Error ? error.message : String(error)
             }));
         }
-    }, []);
+    }, [o11y]);
     const clearError = useCallback(() => {
         setState((prev) => ({ ...prev, error: null }));
     }, []);
     const reset = useCallback(() => {
         setState(initialState);
     }, []);
-    const resolveResource = useCallback(async (resourceId, context) => {
+    const resolveResource = useCallback((resourceId, context) => {
         if (!state.processedResources?.system?.resourceManager) {
             return fail('No resources loaded');
         }
         try {
-            // Get the resource from the resource manager
-            const resourceResult = state.processedResources.system.resourceManager.getBuiltResource(resourceId);
-            if (resourceResult.isFailure()) {
-                return fail(`Resource not found: ${resourceId}`);
-            }
-            // Get the resource and convert to JSON
-            const resource = resourceResult.value;
-            // Import resolution utilities for detailed resolution
-            const { createResolverWithContext, resolveResourceDetailed } = await import('../utils/resolutionUtils');
             // Use provided context or empty context
             const contextValues = context || {};
-            // Create resolver with context
-            const resolverResult = createResolverWithContext(state.processedResources, contextValues, {
+            return state.processedResources.system.resourceManager
+                .getBuiltResource(resourceId)
+                .onFailure(() => fail(`Resource not found: ${resourceId}`))
+                .onSuccess(() => createResolverWithContext(state.processedResources, contextValues, {
                 enableDebugLogging: false
+            }).withErrorFormat((msg) => `Failed to create resolver: ${msg}`))
+                .onSuccess((resolver) => resolveResourceDetailed(resolver, resourceId, state.processedResources, {
+                enableDebugLogging: false
+            }).withErrorFormat((msg) => `Failed to resolve resource details: ${msg}`))
+                .onSuccess((resolutionResult) => {
+                // Return the detailed resolution result as JsonValue
+                const detailedJson = {
+                    success: resolutionResult.success,
+                    resourceId: resolutionResult.resourceId,
+                    resource: resolutionResult.resource
+                        ? {
+                            id: resolutionResult.resource.id,
+                            resourceType: resolutionResult.resource.resourceType?.key || 'unknown',
+                            candidateCount: resolutionResult.resource.candidates.length
+                        }
+                        : null,
+                    bestCandidate: resolutionResult.bestCandidate?.json,
+                    allCandidates: resolutionResult.allCandidates?.map((c) => c.json),
+                    candidateDetails: resolutionResult.candidateDetails?.map((cd) => ({
+                        candidateIndex: cd.candidateIndex,
+                        matched: cd.matched,
+                        matchType: cd.matchType,
+                        isDefaultMatch: cd.isDefaultMatch,
+                        conditionEvaluations: cd.conditionEvaluations,
+                        candidateJson: cd.candidate?.json
+                    })),
+                    composedValue: resolutionResult.composedValue,
+                    error: resolutionResult.error
+                };
+                return succeed(detailedJson);
             });
-            if (resolverResult.isFailure()) {
-                return fail(`Failed to create resolver: ${resolverResult.message}`);
-            }
-            // Resolve resource with detailed information
-            const detailedResult = resolveResourceDetailed(resolverResult.value, resourceId, state.processedResources, { enableDebugLogging: false });
-            if (detailedResult.isFailure()) {
-                return fail(`Failed to resolve resource details: ${detailedResult.message}`);
-            }
-            const resolutionResult = detailedResult.value;
-            // Return the detailed resolution result as JsonValue
-            const detailedJson = {
-                success: resolutionResult.success,
-                resourceId: resolutionResult.resourceId,
-                resource: resolutionResult.resource
-                    ? {
-                        id: resolutionResult.resource.id,
-                        resourceType: resolutionResult.resource.resourceType?.key || 'unknown',
-                        candidateCount: resolutionResult.resource.candidates.length
-                    }
-                    : null,
-                bestCandidate: resolutionResult.bestCandidate?.json,
-                allCandidates: resolutionResult.allCandidates?.map((c) => c.json),
-                candidateDetails: resolutionResult.candidateDetails?.map((cd) => ({
-                    candidateIndex: cd.candidateIndex,
-                    matched: cd.matched,
-                    matchType: cd.matchType,
-                    isDefaultMatch: cd.isDefaultMatch,
-                    conditionEvaluations: cd.conditionEvaluations,
-                    candidateJson: cd.candidate?.json
-                })),
-                composedValue: resolutionResult.composedValue,
-                error: resolutionResult.error
-            };
-            return succeed(detailedJson);
         }
         catch (error) {
             return fail(`Failed to resolve resource: ${error instanceof Error ? error.message : String(error)}`);
@@ -405,11 +380,37 @@ export function useResourceData(params) {
         setState((prev) => ({ ...prev, activeConfiguration: config }));
     }, []);
     const updateProcessedResources = useCallback((processedResources) => {
-        setState((prev) => ({
-            ...prev,
-            processedResources,
-            hasProcessedData: true
-        }));
+        setState((prev) => {
+            const incomingExtended = processedResources;
+            const existingExtended = prev.processedResources;
+            // Build the extended properties object, only including defined values
+            const extendedProps = {};
+            // Handle activeConfiguration - prefer incoming, then existing, then leave undefined
+            const activeConfig = incomingExtended.activeConfiguration ?? existingExtended?.activeConfiguration;
+            if (activeConfig !== undefined) {
+                extendedProps.activeConfiguration = activeConfig;
+            }
+            // Handle isLoadedFromBundle - prefer incoming, then existing, then leave undefined
+            const isLoaded = incomingExtended.isLoadedFromBundle ?? existingExtended?.isLoadedFromBundle;
+            if (isLoaded !== undefined) {
+                extendedProps.isLoadedFromBundle = isLoaded;
+            }
+            // Handle bundleMetadata - prefer incoming, then existing, then leave undefined
+            const bundleMeta = incomingExtended.bundleMetadata ?? existingExtended?.bundleMetadata;
+            if (bundleMeta !== undefined) {
+                extendedProps.bundleMetadata = bundleMeta;
+            }
+            return {
+                ...prev,
+                processedResources: {
+                    // Start with the new processedResources (core data)
+                    ...processedResources,
+                    // Then add any extended properties that have values
+                    ...extendedProps
+                },
+                hasProcessedData: true
+            };
+        });
     }, []);
     return {
         state,

package/lib/index.d.ts

@@ -8,10 +8,14 @@ export { CompiledView } from './components/views/CompiledView';
 export { ResolutionView } from './components/views/ResolutionView';
 export { ConfigurationView } from './components/views/ConfigurationView';
 export { MessagesWindow } from './components/views/MessagesWindow';
+export { GridView } from './components/views/GridView';
+export { MultiGridView } from './components/views/GridView/MultiGridView';
 export { ResourceOrchestrator } from './components/orchestrator/ResourceOrchestrator';
+export { DownloadUtils } from './utils/downloadHelper';
+export { ObservabilityProvider, useObservability, type ObservabilityProviderProps } from './contexts';
 export { ResourceTreeView } from './components/common/ResourceTreeView';
 export { ResourceListView } from './components/common/ResourceListView';
 export { SourceResourceDetail } from './components/common/SourceResourceDetail';
 export { ResolutionResults } from './components/common/ResolutionResults';
-export { FilterTools, ResolutionTools, ConfigurationTools, ResourceTools, ImportTools, TsResTools, ZipTools, ViewStateTools, PickerTools } from './namespaces';
+export { FilterTools, ResolutionTools, ConfigurationTools, ResourceTools, ImportTools, TsResTools, ZipTools, ViewStateTools, PickerTools, GridTools, ObservabilityTools } from './namespaces';
 //# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -7,6 +7,7 @@
 // - TsResTools: SourceViewProps, CompiledViewProps
 // - ZipTools: ImportViewProps and ZIP utilities
 // - ConfigurationTools: ConfigurationViewProps
+// - GridTools: GridViewProps, MultiGridViewProps, GridColumnDefinition, GridResourceSelector, GridDropdownOption, GridCellValidation
 // - ImportTools: ImportedFile, ImportedDirectory
 // Export views
 export { ImportView } from './components/views/ImportView';
@@ -16,8 +17,14 @@ export { CompiledView } from './components/views/CompiledView';
 export { ResolutionView } from './components/views/ResolutionView';
 export { ConfigurationView } from './components/views/ConfigurationView';
 export { MessagesWindow } from './components/views/MessagesWindow';
+export { GridView } from './components/views/GridView';
+export { MultiGridView } from './components/views/GridView/MultiGridView';
 // Export orchestrator
 export { ResourceOrchestrator } from './components/orchestrator/ResourceOrchestrator';
+// Export utilities
+export { DownloadUtils } from './utils/downloadHelper';
+// Export contexts and hooks
+export { ObservabilityProvider, useObservability } from './contexts';
 // Export common components (likely to be used by consumers)
 export { ResourceTreeView } from './components/common/ResourceTreeView';
 export { ResourceListView } from './components/common/ResourceListView';
@@ -40,5 +47,5 @@ export { ResolutionResults } from './components/common/ResolutionResults';
 // - useResolutionState: ResolutionTools.useResolutionState (resource resolution)
 // - useConfigurationState: ConfigurationTools.useConfigurationState (system configuration)
 // Export organized tool namespaces
-export { FilterTools, ResolutionTools, ConfigurationTools, ResourceTools, ImportTools, TsResTools, ZipTools, ViewStateTools, PickerTools } from './namespaces';
+export { FilterTools, ResolutionTools, ConfigurationTools, ResourceTools, ImportTools, TsResTools, ZipTools, ViewStateTools, PickerTools, GridTools, ObservabilityTools } from './namespaces';
 //# sourceMappingURL=index.js.map