@fgv/ts-res-ui-components 5.0.0-10

package/src/utils/filterResources.ts

@@ -0,0 +1,206 @@
+import { Result, succeed, fail } from '@fgv/ts-utils';
+import { Runtime, Import, Resources } from '@fgv/ts-res';
+import { ProcessedResources } from '../types';
+
+export interface FilterOptions {
+  partialContextMatch?: boolean;
+  enableDebugLogging?: boolean;
+  reduceQualifiers?: boolean;
+}
+
+export interface FilteredResource {
+  id: string;
+  originalCandidateCount: number;
+  filteredCandidateCount: number;
+  hasWarning: boolean;
+}
+
+export interface FilterResult {
+  success: boolean;
+  filteredResources: FilteredResource[];
+  processedResources?: ProcessedResources;
+  error?: string;
+  warnings: string[];
+}
+
+// Helper function for conditional debug logging
+const debugLog = (enableDebug: boolean, ...args: unknown[]) => {
+  if (enableDebug) {
+    console.log(...args);
+  }
+};
+
+/**
+ * Check if filter values object has any meaningful values
+ */
+export function hasFilterValues(values: Record<string, string | undefined>): boolean {
+  return Object.values(values).some((value) => value !== undefined && value !== '');
+}
+
+/**
+ * Get a summary string of active filter values
+ */
+export function getFilterSummary(values: Record<string, string | undefined>): string {
+  const activeFilters = Object.entries(values)
+    .filter(([, value]) => value !== undefined && value !== '')
+    .map(([key, value]) => `${key}=${value}`);
+  return activeFilters.length > 0 ? activeFilters.join(', ') : 'No filters';
+}
+
+/**
+ * Creates a filtered resource manager using the ResourceManagerBuilder.clone() method.
+ * This is a simplified implementation that leverages the built-in filtering functionality.
+ */
+export const createFilteredResourceManagerSimple = async (
+  originalSystem: ProcessedResources['system'],
+  partialContext: Record<string, string | undefined>,
+  options: FilterOptions = { partialContextMatch: true }
+): Promise<Result<ProcessedResources>> => {
+  const enableDebug = options.enableDebugLogging === true;
+
+  debugLog(enableDebug, '=== SIMPLE FILTER CREATION ===');
+  debugLog(enableDebug, 'Original system:', originalSystem);
+  debugLog(enableDebug, 'Partial context:', partialContext);
+
+  // Validate the original system
+  if (!originalSystem?.resourceManager) {
+    return fail('Original system or resourceManager is undefined');
+  }
+
+  // Filter out undefined values from the context before processing
+  const filteredContext = Object.fromEntries(
+    Object.entries(partialContext).filter(([, value]) => value !== undefined)
+  ) as Record<string, string>;
+
+  // Try to use ResourceManagerBuilder.clone() for proper filtering first
+  debugLog(enableDebug, 'Using ResourceManagerBuilder for proper filtering');
+  debugLog(enableDebug, 'Validating context and cloning manager:', filteredContext);
+  const resourceManagerBuilder = originalSystem.resourceManager;
+
+  return resourceManagerBuilder
+    .validateContext(filteredContext)
+    .onSuccess((validatedContext) => {
+      debugLog(enableDebug, 'Context validated, creating clone with context:', validatedContext);
+      return resourceManagerBuilder.clone({
+        filterForContext: validatedContext,
+        reduceQualifiers: options.reduceQualifiers
+      });
+    })
+    .withErrorFormat((e) => `Failed to validate context or clone: ${e}`)
+    .onSuccess((filteredManager) => {
+      debugLog(enableDebug, 'Filtered manager created:', filteredManager);
+
+      // Create new ImportManager for the filtered system
+      return Import.ImportManager.create({
+        resources: filteredManager
+      })
+        .withErrorFormat((e) => `Failed to create filtered import manager: ${e}`)
+        .onSuccess((newImportManager) => {
+          // Create new ContextQualifierProvider for the filtered system
+          return Runtime.ValidatingSimpleContextQualifierProvider.create({
+            qualifiers: originalSystem.qualifiers
+          })
+            .withErrorFormat((e) => `Failed to create filtered context provider: ${e}`)
+            .onSuccess((newContextQualifierProvider) => {
+              // Build the new system object
+              const newSystem = {
+                qualifierTypes: originalSystem.qualifierTypes,
+                qualifiers: originalSystem.qualifiers,
+                resourceTypes: originalSystem.resourceTypes,
+                resourceManager: filteredManager,
+                importManager: newImportManager,
+                contextQualifierProvider: newContextQualifierProvider
+              };
+
+              // Get compiled collection from the filtered manager
+              return filteredManager
+                .getCompiledResourceCollection({ includeMetadata: true })
+                .withErrorFormat((e) => `Failed to get compiled collection: ${e}`)
+                .onSuccess((compiledCollection) => {
+                  // Create resolver for the filtered system
+                  return Runtime.ResourceResolver.create({
+                    resourceManager: filteredManager,
+                    qualifierTypes: originalSystem.qualifierTypes,
+                    contextQualifierProvider: newContextQualifierProvider
+                  })
+                    .withErrorFormat((e) => `Failed to create resolver: ${e}`)
+                    .onSuccess((resolver) => {
+                      // Create summary
+                      const resourceIds = Array.from(filteredManager.resources.keys());
+                      const summary = {
+                        totalResources: resourceIds.length,
+                        resourceIds,
+                        errorCount: 0,
+                        warnings: [] as string[]
+                      };
+
+                      const processedResources: ProcessedResources = {
+                        system: newSystem,
+                        compiledCollection,
+                        resolver,
+                        resourceCount: resourceIds.length,
+                        summary
+                      };
+
+                      debugLog(enableDebug, '=== FILTERED PROCESSING COMPLETE ===');
+                      debugLog(enableDebug, 'Filtered resource count:', resourceIds.length);
+                      debugLog(enableDebug, 'Filtered resource IDs:', resourceIds);
+
+                      return succeed(processedResources);
+                    });
+                });
+            });
+        });
+    })
+    .onFailure((error) => {
+      debugLog(enableDebug, 'Failed to create filtered resource manager:', error);
+      return fail(`Failed to create filtered resource manager: ${error}`);
+    });
+};
+
+/**
+ * Analyze filtered resources compared to original resources
+ */
+export function analyzeFilteredResources(
+  originalResourceIds: string[],
+  filteredProcessedResources: ProcessedResources,
+  originalProcessedResources: ProcessedResources
+): FilterResult {
+  const filteredResources: FilteredResource[] = [];
+  const warnings: string[] = [];
+
+  for (const resourceId of originalResourceIds) {
+    // Get original resource info
+    const originalResourceResult =
+      originalProcessedResources.system.resourceManager.getBuiltResource(resourceId);
+    const originalCandidateCount = originalResourceResult.isSuccess()
+      ? originalResourceResult.value.candidates.length
+      : 0;
+
+    // Get filtered resource info
+    const filteredResourceResult =
+      filteredProcessedResources.system.resourceManager.getBuiltResource(resourceId);
+    const filteredCandidateCount = filteredResourceResult.isSuccess()
+      ? filteredResourceResult.value.candidates.length
+      : 0;
+
+    const hasWarning = filteredCandidateCount === 0 && originalCandidateCount > 0;
+    if (hasWarning) {
+      warnings.push(`Resource ${resourceId} has no matching candidates after filtering`);
+    }
+
+    filteredResources.push({
+      id: resourceId,
+      originalCandidateCount,
+      filteredCandidateCount,
+      hasWarning
+    });
+  }
+
+  return {
+    success: true,
+    filteredResources,
+    processedResources: filteredProcessedResources,
+    warnings
+  };
+}

package/src/utils/resolutionEditing.ts

@@ -0,0 +1,319 @@
+import { Result, succeed, fail } from '@fgv/ts-utils';
+import { ResourceJson, Resources, Runtime } from '@fgv/ts-res';
+import { Diff } from '@fgv/ts-json';
+import { JsonObject } from '@fgv/ts-json-base';
+import { ProcessedResources, JsonValue } from '../types';
+
+export interface EditedResourceInfo {
+  resourceId: string;
+  originalValue: JsonValue;
+  editedValue: JsonValue;
+  timestamp: Date;
+}
+
+export interface EditValidationResult {
+  isValid: boolean;
+  errors: string[];
+  warnings: string[];
+}
+
+/**
+ * Validates an edited resource JSON value
+ */
+export function validateEditedResource(editedValue: JsonValue): EditValidationResult {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+
+  // Basic JSON validation
+  if (editedValue === null || editedValue === undefined) {
+    errors.push('Resource value cannot be null or undefined');
+  }
+
+  // Check if it's valid JSON-serializable
+  try {
+    JSON.stringify(editedValue);
+  } catch (error) {
+    errors.push(`Invalid JSON: ${error instanceof Error ? error.message : 'Unknown error'}`);
+  }
+
+  // Type-specific validation
+  if (typeof editedValue === 'object' && editedValue !== null) {
+    // Object validation - check for circular references
+    const seen = new Set<unknown>();
+    const checkCircular = (obj: unknown): boolean => {
+      if (seen.has(obj)) return true;
+      seen.add(obj);
+      if (typeof obj === 'object' && obj !== null) {
+        for (const key in obj as Record<string, unknown>) {
+          const objTyped = obj as Record<string, unknown>;
+          if (typeof objTyped[key] === 'object' && objTyped[key] !== null) {
+            if (checkCircular(objTyped[key])) return true;
+          }
+        }
+      }
+      seen.delete(obj);
+      return false;
+    };
+
+    if (checkCircular(editedValue)) {
+      errors.push('Resource contains circular references');
+    }
+  }
+
+  return {
+    isValid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+
+/**
+ * Computes a 3-way diff between base, resolved, and edited values to create minimal delta
+ * @param baseValue - The base/original value before resolution (if available)
+ * @param resolvedValue - The fully resolved/composed value shown to user
+ * @param editedValue - The value after user edits
+ * @returns A minimal delta object with only the changes, or null if no changes
+ */
+export function computeResourceDelta(
+  baseValue: JsonValue | undefined,
+  resolvedValue: JsonValue,
+  editedValue: JsonValue
+): Result<JsonValue> {
+  // Use ts-json's three-way diff for proper delta computation
+  const diffResult = Diff.jsonThreeWayDiff(resolvedValue, editedValue);
+
+  if (diffResult.isFailure()) {
+    // Fall back to full replacement on diff failure
+    console.error('Failed to compute three-way diff:', diffResult.message);
+    return succeed(editedValue);
+  }
+
+  const diff = diffResult.value;
+
+  // If identical, no changes needed
+  if (diff.identical) {
+    return succeed(null);
+  }
+
+  // Build a proper delta that includes deletions as null values
+  const delta: Record<string, JsonValue> = {};
+
+  // Add all changes/additions from onlyInB
+  if (diff.onlyInB !== null) {
+    Object.assign(delta, diff.onlyInB);
+  }
+
+  // Add deletions as null values from onlyInA
+  // onlyInA contains properties that existed in resolved but not in edited
+  if (diff.onlyInA !== null) {
+    // Add null entries for all deleted properties
+    addDeletionsAsNull(diff.onlyInA, delta);
+  }
+
+  // If delta is empty, no changes
+  if (Object.keys(delta).length === 0) {
+    return succeed(null);
+  }
+
+  return succeed(delta);
+}
+
+/**
+ * Recursively adds null values to delta for all properties in the deleted object
+ */
+function addDeletionsAsNull(deleted: JsonValue, delta: Record<string, JsonValue>): void {
+  if (typeof deleted === 'object' && deleted !== null && !Array.isArray(deleted)) {
+    const deletedObj = deleted as Record<string, JsonValue>;
+    for (const key in deletedObj) {
+      if (deletedObj.hasOwnProperty(key)) {
+        // If this key already exists in delta (from onlyInB), it means the property
+        // was modified, not deleted, so don't override with null
+        if (!(key in delta)) {
+          delta[key] = null;
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Creates candidate declarations for edited resources with proper delta handling
+ */
+export function createCandidateDeclarations(
+  editedResources: Map<string, { originalValue: JsonValue; editedValue: JsonValue; delta: JsonValue }>,
+  currentContext: Record<string, string>
+): ResourceJson.Json.ILooseResourceCandidateDecl[] {
+  const declarations: ResourceJson.Json.ILooseResourceCandidateDecl[] = [];
+
+  for (const [resourceId, resourceEdit] of editedResources.entries()) {
+    // Create conditions from current context (using array format)
+    const conditions: ResourceJson.Json.ILooseConditionDecl[] = [];
+
+    for (const [qualifierName, qualifierValue] of Object.entries(currentContext)) {
+      if (qualifierValue && qualifierValue.trim() !== '') {
+        conditions.push({
+          qualifierName,
+          operator: 'matches',
+          value: qualifierValue,
+          priority: 900 // High priority for user edits
+        });
+      }
+    }
+
+    // Always use the delta if we have one (which should be the minimal changes)
+    // The delta will be null if there are no changes, or the delta itself if there are changes
+    const hasChanges = resourceEdit.delta !== null && resourceEdit.delta !== undefined;
+
+    if (!hasChanges) {
+      // No changes, skip this resource
+      continue;
+    }
+
+    // Always save as partial with just the delta when we have changes
+    // This ensures minimal, clean resource files
+    declarations.push({
+      id: resourceId,
+      conditions: conditions.length > 0 ? conditions : undefined,
+      json: resourceEdit.delta as JsonObject, // Always use the delta (minimal changes only)
+      isPartial: true, // Always partial when saving deltas
+      mergeMethod: 'augment' // Always augment to merge the delta with base
+    });
+  }
+
+  return declarations;
+}
+
+/**
+ * Rebuilds the resource system with edited candidates using deltas
+ */
+export async function rebuildSystemWithEdits(
+  originalSystem: ProcessedResources['system'],
+  editedResources: Map<string, { originalValue: JsonValue; editedValue: JsonValue; delta: JsonValue }>,
+  currentContext: Record<string, string>
+): Promise<Result<ProcessedResources>> {
+  try {
+    const candidateDeclarations = createCandidateDeclarations(editedResources, currentContext);
+
+    const clonedManager = originalSystem.resourceManager.clone({
+      candidates: candidateDeclarations
+    });
+
+    if (clonedManager.isFailure()) {
+      return fail(`Failed to clone manager: ${clonedManager.message}`);
+    }
+
+    // Get compiled collection from the updated manager
+    const compiledResult = clonedManager.value.getCompiledResourceCollection({ includeMetadata: true });
+    if (compiledResult.isFailure()) {
+      return fail(`Failed to get compiled collection: ${compiledResult.message}`);
+    }
+
+    // Create resolver for the updated system
+    const resolverResult = Runtime.ResourceResolver.create({
+      resourceManager: clonedManager.value,
+      qualifierTypes: originalSystem.qualifierTypes,
+      contextQualifierProvider: originalSystem.contextQualifierProvider
+    });
+
+    if (resolverResult.isFailure()) {
+      return fail(`Failed to create resolver: ${resolverResult.message}`);
+    }
+
+    // Create summary
+    const resourceIds = Array.from(clonedManager.value.resources.keys());
+    const summary = {
+      totalResources: resourceIds.length,
+      resourceIds,
+      errorCount: 0,
+      warnings: []
+    };
+
+    const updatedSystem: ProcessedResources = {
+      system: {
+        qualifierTypes: originalSystem.qualifierTypes,
+        qualifiers: originalSystem.qualifiers,
+        resourceTypes: originalSystem.resourceTypes,
+        resourceManager: clonedManager.value,
+        importManager: originalSystem.importManager,
+        contextQualifierProvider: originalSystem.contextQualifierProvider
+      },
+      compiledCollection: compiledResult.value,
+      resolver: resolverResult.value,
+      resourceCount: resourceIds.length,
+      summary
+    };
+
+    return succeed(updatedSystem);
+  } catch (error) {
+    return fail(
+      `Failed to rebuild system with edits: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+/**
+ * Extracts the current resolution context from resolver state
+ */
+export function extractResolutionContext(
+  resolver: Runtime.ResourceResolver,
+  contextValues: Record<string, string>
+): Record<string, string> {
+  // Filter out empty/undefined context values
+  const cleanContext: Record<string, string> = {};
+
+  for (const [key, value] of Object.entries(contextValues)) {
+    if (value && value.trim() !== '') {
+      cleanContext[key] = value.trim();
+    }
+  }
+
+  return cleanContext;
+}
+
+/**
+ * Creates a collision detection key for tracking edit conflicts
+ */
+export function createEditCollisionKey(resourceId: string, context: Record<string, string>): string {
+  const contextEntries = Object.entries(context)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([key, value]) => `${key}=${value}`)
+    .join('&');
+
+  return `${resourceId}?${contextEntries}`;
+}
+
+/**
+ * Checks for potential edit conflicts with existing candidates
+ */
+export function checkEditConflicts(
+  resourceManager: Resources.ResourceManagerBuilder | Runtime.IResourceManager,
+  editedResources: Map<string, JsonValue>,
+  currentContext: Record<string, string>
+): { conflicts: string[]; warnings: string[] } {
+  const conflicts: string[] = [];
+  const warnings: string[] = [];
+
+  for (const [resourceId] of editedResources) {
+    try {
+      // Get the current resource to check for conflicts
+      const resourceResult = resourceManager.getBuiltResource(resourceId);
+      if (resourceResult.isSuccess()) {
+        const resource = resourceResult.value;
+
+        // Check if we're likely to create a conflict
+        if (resource.candidates.length > 1) {
+          warnings.push(
+            `Resource ${resourceId} has ${resource.candidates.length} candidates - edits may create conflicts`
+          );
+        }
+
+        // Could add more sophisticated conflict detection here
+        // based on condition overlap analysis
+      }
+    } catch (error) {
+      // Ignore errors in conflict checking
+    }
+  }
+
+  return { conflicts, warnings };
+}