@fgv/ts-res-browser 5.0.0-2 → 5.0.0-21

package/src/utils/tsResIntegration.ts

@@ -1,467 +0,0 @@
-import { Result, succeed, fail, FileTree } from '@fgv/ts-utils';
-import {
-  QualifierTypes,
-  Qualifiers,
-  ResourceTypes,
-  Resources,
-  Import,
-  Runtime,
-  ResourceJson,
-  Config
-} from '@fgv/ts-res';
-import { ImportedDirectory, ImportedFile } from './fileImport';
-import { BrowserFileTreeAccessors } from './browserFileTreeAccessors';
-
-/**
- * Configuration for setting up ts-res system
- */
-export interface TsResConfig {
-  qualifierDecls?: Qualifiers.IQualifierDecl[];
-  additionalQualifierTypes?: QualifierTypes.QualifierType[];
-  additionalResourceTypes?: ResourceTypes.ResourceType[];
-}
-
-/**
- * Complete ts-res system setup
- */
-export interface TsResSystem {
-  qualifierTypes: QualifierTypes.ReadOnlyQualifierTypeCollector;
-  qualifiers: Qualifiers.IReadOnlyQualifierCollector;
-  resourceTypes: ResourceTypes.ReadOnlyResourceTypeCollector;
-  resourceManager: Resources.ResourceManagerBuilder;
-  importManager: Import.ImportManager;
-  contextQualifierProvider: Runtime.ValidatingSimpleContextQualifierProvider;
-}
-
-/**
- * Result of processing resources
- */
-export interface ProcessedResources {
-  system: TsResSystem;
-  compiledCollection: ResourceJson.Compiled.ICompiledResourceCollection;
-  resolver: Runtime.ResourceResolver;
-  resourceCount: number;
-  summary: {
-    totalResources: number;
-    resourceIds: string[];
-    errorCount: number;
-    warnings: string[];
-  };
-}
-
-/**
- * Get the default system configuration from ts-res library
- */
-export function getDefaultSystemConfiguration(): Config.Model.ISystemConfiguration {
-  const defaultResult = Config.getPredefinedDeclaration('default');
-  if (defaultResult.isSuccess()) {
-    return defaultResult.value;
-  }
-
-  // Fallback configuration if predefined default is not available
-  return {
-    name: 'Browser Default Configuration',
-    description: 'Fallback default configuration for ts-res browser tool',
-    qualifierTypes: [
-      {
-        name: 'language',
-        systemType: 'language',
-        configuration: {
-          allowContextList: true
-        }
-      },
-      {
-        name: 'territory',
-        systemType: 'territory',
-        configuration: {
-          allowContextList: false
-        }
-      }
-    ],
-    qualifiers: [
-      {
-        name: 'currentTerritory',
-        token: 'geo',
-        typeName: 'territory',
-        defaultPriority: 850
-      },
-      {
-        name: 'language',
-        token: 'lang',
-        typeName: 'language',
-        defaultPriority: 800
-      }
-    ],
-    resourceTypes: [
-      {
-        name: 'json',
-        typeName: 'json'
-      }
-    ]
-  };
-}
-
-/**
- * Default system configuration for ts-res browser tool
- * Now uses the predefined default from ts-res library
- */
-export const DEFAULT_SYSTEM_CONFIGURATION: Config.Model.ISystemConfiguration =
-  getDefaultSystemConfiguration();
-
-/**
- * Get all available predefined configuration options
- */
-export function getAvailablePredefinedConfigurations(): {
-  name: Config.PredefinedSystemConfiguration;
-  label: string;
-  description: string;
-}[] {
-  return [
-    {
-      name: 'default',
-      label: 'Default',
-      description: 'Default system configuration'
-    },
-    {
-      name: 'language-priority',
-      label: 'Language Priority',
-      description: 'Language priority system configuration'
-    },
-    {
-      name: 'territory-priority',
-      label: 'Territory Priority',
-      description: 'Territory priority system configuration'
-    },
-    {
-      name: 'extended-example',
-      label: 'Extended Example',
-      description: 'Extended example configuration with market, role, environment, and currency qualifiers'
-    }
-  ];
-}
-
-/**
- * Get a predefined configuration by name
- */
-export function getPredefinedConfiguration(
-  name: Config.PredefinedSystemConfiguration
-): Result<Config.Model.ISystemConfiguration> {
-  return Config.getPredefinedDeclaration(name);
-}
-
-/**
- * Legacy default qualifier declarations for backward compatibility
- */
-export const DEFAULT_QUALIFIER_DECLARATIONS: Qualifiers.IQualifierDecl[] = [
-  {
-    name: 'homeTerritory',
-    typeName: 'territory',
-    defaultPriority: 800,
-    token: 'home'
-  },
-  {
-    name: 'currentTerritory',
-    typeName: 'territory',
-    defaultPriority: 700
-  },
-  {
-    name: 'language',
-    typeName: 'language',
-    defaultPriority: 600,
-    token: 'lang'
-  },
-  {
-    name: 'role',
-    typeName: 'literal',
-    defaultPriority: 550
-  },
-  {
-    name: 'env',
-    typeName: 'literal',
-    defaultPriority: 500
-  },
-  {
-    name: 'platform',
-    typeName: 'literal',
-    defaultPriority: 450
-  },
-  {
-    name: 'density',
-    typeName: 'literal',
-    defaultPriority: 400
-  }
-];
-
-/**
- * Creates a complete ts-res system setup using SystemConfiguration
- */
-export function createTsResSystemFromConfig(
-  systemConfig?: Config.Model.ISystemConfiguration
-): Result<TsResSystem> {
-  const configToUse = systemConfig ?? DEFAULT_SYSTEM_CONFIGURATION;
-
-  return Config.SystemConfiguration.create(configToUse).onSuccess((systemConfiguration) => {
-    try {
-      // Set up resource manager
-      const resourceManager = Resources.ResourceManagerBuilder.create({
-        qualifiers: systemConfiguration.qualifiers,
-        resourceTypes: systemConfiguration.resourceTypes
-      }).orThrow();
-
-      // Set up import manager
-      const importManager = Import.ImportManager.create({
-        resources: resourceManager
-      }).orThrow();
-
-      // Set up context qualifier provider
-      const contextQualifierProvider = Runtime.ValidatingSimpleContextQualifierProvider.create({
-        qualifiers: systemConfiguration.qualifiers
-      }).orThrow();
-
-      return succeed({
-        qualifierTypes: systemConfiguration.qualifierTypes,
-        qualifiers: systemConfiguration.qualifiers,
-        resourceTypes: systemConfiguration.resourceTypes,
-        resourceManager,
-        importManager,
-        contextQualifierProvider
-      });
-    } catch (error) {
-      return fail(
-        `Failed to create ts-res system: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  });
-}
-
-/**
- * Legacy function - creates a complete ts-res system setup using manual construction
- * @deprecated Use createTsResSystemFromConfig instead
- */
-export function createTsResSystem(config: TsResConfig = {}): Result<TsResSystem> {
-  try {
-    // Set up qualifier types
-    const defaultQualifierTypes = [
-      QualifierTypes.LanguageQualifierType.create().orThrow(),
-      QualifierTypes.TerritoryQualifierType.create().orThrow(),
-      QualifierTypes.LiteralQualifierType.create().orThrow()
-    ];
-
-    const qualifierTypes = QualifierTypes.QualifierTypeCollector.create({
-      qualifierTypes: [...defaultQualifierTypes, ...(config.additionalQualifierTypes ?? [])]
-    }).orThrow();
-
-    // Set up qualifiers
-    const qualifierDecls = config.qualifierDecls ?? DEFAULT_QUALIFIER_DECLARATIONS;
-    const qualifiers = Qualifiers.QualifierCollector.create({
-      qualifierTypes,
-      qualifiers: qualifierDecls
-    }).orThrow();
-
-    // Set up resource types
-    const defaultResourceTypes = [ResourceTypes.JsonResourceType.create().orThrow()];
-
-    const resourceTypes = ResourceTypes.ResourceTypeCollector.create({
-      resourceTypes: [...defaultResourceTypes, ...(config.additionalResourceTypes ?? [])]
-    }).orThrow();
-
-    // Set up resource manager
-    const resourceManager = Resources.ResourceManagerBuilder.create({
-      qualifiers,
-      resourceTypes
-    }).orThrow();
-
-    // Set up import manager
-    const importManager = Import.ImportManager.create({
-      resources: resourceManager
-    }).orThrow();
-
-    // Set up context qualifier provider
-    const contextQualifierProvider = Runtime.ValidatingSimpleContextQualifierProvider.create({
-      qualifiers
-    }).orThrow();
-
-    return succeed({
-      qualifierTypes,
-      qualifiers,
-      resourceTypes,
-      resourceManager,
-      importManager,
-      contextQualifierProvider
-    });
-  } catch (error) {
-    return fail(`Failed to create ts-res system: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
-/**
- * Processes imported files through ts-res ImportManager
- */
-export function processImportedFiles(
-  files: ImportedFile[],
-  systemConfigOrSystem?: Config.Model.ISystemConfiguration | TsResSystem
-): Result<ProcessedResources> {
-  if (files.length === 0) {
-    return fail('No files provided for processing');
-  }
-
-  // Determine if we have a system or a config
-  const systemResult =
-    systemConfigOrSystem &&
-    'qualifierTypes' in systemConfigOrSystem &&
-    'resourceManager' in systemConfigOrSystem
-      ? succeed(systemConfigOrSystem as TsResSystem)
-      : createTsResSystemFromConfig(systemConfigOrSystem as Config.Model.ISystemConfiguration);
-
-  return systemResult.onSuccess((tsResSystem) => {
-    // Convert ImportedFile[] to IInMemoryFile[] format
-    const inMemoryFiles = files.map((file) => ({
-      path: file.path,
-      contents: file.content
-    }));
-
-    return FileTree.inMemory(inMemoryFiles)
-      .onSuccess((fileTree) => {
-        return Import.ImportManager.create({
-          fileTree,
-          resources: tsResSystem.resourceManager
-        });
-      })
-      .onSuccess<ProcessedResources>((importManager) => {
-        // Import each file using its filesystem path
-        for (const file of files) {
-          const importResult = importManager.importFromFileSystem(file.path);
-          if (importResult.isFailure()) {
-            return fail(`Failed to import file ${file.path}: ${importResult.message}`);
-          }
-        }
-        // Update the system with the new ImportManager
-        const updatedSystem = {
-          ...tsResSystem,
-          importManager
-        };
-        return finalizeProcessing(updatedSystem);
-      })
-      .withErrorFormat((message) => `processImportedFiles failed: ${message}`);
-  });
-}
-
-export function processImportedDirectory(
-  directory: ImportedDirectory,
-  systemConfigOrSystem?: Config.Model.ISystemConfiguration | TsResSystem
-): Result<ProcessedResources> {
-  // Determine if we have a system or a config
-  const systemResult =
-    systemConfigOrSystem &&
-    'qualifierTypes' in systemConfigOrSystem &&
-    'resourceManager' in systemConfigOrSystem
-      ? succeed(systemConfigOrSystem as TsResSystem)
-      : createTsResSystemFromConfig(systemConfigOrSystem as Config.Model.ISystemConfiguration);
-
-  return systemResult.onSuccess((tsResSystem) => {
-    // Create custom FileTree that preserves directory structure
-    return BrowserFileTreeAccessors.create(directory)
-      .onSuccess((accessors) => {
-        return FileTree.FileTree.create(accessors);
-      })
-      .onSuccess((fileTree) => {
-        return Import.ImportManager.create({
-          fileTree,
-          resources: tsResSystem.resourceManager
-        });
-      })
-      .onSuccess<ProcessedResources>((importManager) => {
-        // Import from root path since we set the imported directory as the FileTree root
-        // The importer will traverse the tree structure and extract qualifiers from directory names
-        const importResult = importManager.importFromFileSystem('/');
-        if (importResult.isFailure()) {
-          return fail(`Failed to import directory ${directory.name}: ${importResult.message}`);
-        }
-
-        // Update the system with the new ImportManager
-        const updatedSystem = {
-          ...tsResSystem,
-          importManager
-        };
-        return finalizeProcessing(updatedSystem);
-      })
-      .withErrorFormat((message) => `processImportedDirectory failed: ${message}`);
-  });
-}
-
-/**
- * Finalizes processing and creates compiled resources
- */
-function finalizeProcessing(system: TsResSystem): Result<ProcessedResources> {
-  console.log('=== FINALIZING PROCESSING ===');
-  console.log('Resource manager resources:', system.resourceManager.resources.size);
-  console.log('Resource manager resource keys:', Array.from(system.resourceManager.resources.keys()));
-
-  return system.resourceManager
-    .getCompiledResourceCollection({ includeMetadata: true })
-    .onSuccess((compiledCollection: ResourceJson.Compiled.ICompiledResourceCollection) => {
-      console.log('=== COMPILED COLLECTION CREATED ===');
-      console.log('Compiled collection data:', compiledCollection);
-      console.log('Decisions length:', compiledCollection.decisions?.length);
-      console.log('ConditionSets length:', compiledCollection.conditionSets?.length);
-      console.log('Conditions length:', compiledCollection.conditions?.length);
-      console.log('Resources length:', compiledCollection.resources?.length);
-
-      return Runtime.ResourceResolver.create({
-        resourceManager: system.resourceManager,
-        qualifierTypes: system.qualifierTypes,
-        contextQualifierProvider: system.contextQualifierProvider
-      }).onSuccess((resolver) => {
-        // Create summary
-        const resourceIds = Array.from(system.resourceManager.resources.keys());
-        const summary = {
-          totalResources: resourceIds.length,
-          resourceIds,
-          errorCount: 0, // TODO: Track errors during processing
-          warnings: [] // TODO: Collect warnings during processing
-        };
-
-        console.log('=== FINALIZATION COMPLETE ===');
-        console.log('Resource count:', resourceIds.length);
-        console.log('Resource IDs:', resourceIds);
-
-        return succeed({
-          system,
-          compiledCollection,
-          resolver,
-          resourceCount: resourceIds.length,
-          summary
-        });
-      });
-    })
-    .withErrorFormat((message: string) => `Failed to finalize processing: ${message}`);
-}
-
-/**
- * Creates a simple context for resource resolution
- */
-export function createSimpleContext(
-  contextValues: Record<string, string>,
-  system: TsResSystem
-): Result<Runtime.ValidatingSimpleContextQualifierProvider> {
-  return Runtime.ValidatingSimpleContextQualifierProvider.create({
-    qualifiers: system.qualifiers
-  })
-    .onSuccess((provider): Result<Runtime.ValidatingSimpleContextQualifierProvider> => {
-      // Set context values
-      for (const [qualifierName, value] of Object.entries(contextValues)) {
-        try {
-          provider.set(qualifierName as any, value as any);
-        } catch (error) {
-          return fail(
-            `Failed to set context value ${qualifierName}=${value}: ${
-              error instanceof Error ? error.message : String(error)
-            }`
-          );
-        }
-      }
-
-      return succeed(provider);
-    })
-    .withErrorFormat((message) => `Failed to create context: ${message}`);
-}

package/src/utils/urlParams.ts

@@ -1,238 +0,0 @@
-/*
- * Copyright (c) 2025 Erik Fortune
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/**
- * Configuration options that can be passed via URL parameters
- */
-export interface IUrlConfigOptions {
-  /**
-   * Input file path
-   */
-  input?: string;
-
-  /**
-   * Configuration name or path
-   */
-  config?: string;
-
-  /**
-   * Context filter token (pipe-separated)
-   */
-  contextFilter?: string;
-
-  /**
-   * Qualifier defaults token (pipe-separated)
-   */
-  qualifierDefaults?: string;
-
-  /**
-   * Resource types filter (comma-separated)
-   */
-  resourceTypes?: string;
-
-  /**
-   * Maximum distance for language matching
-   */
-  maxDistance?: number;
-
-  /**
-   * Whether to reduce qualifiers
-   */
-  reduceQualifiers?: boolean;
-
-  /**
-   * Whether to launch in interactive mode
-   */
-  interactive?: boolean;
-
-  /**
-   * Starting directory for input file picker (derived from input path)
-   */
-  inputStartDir?: string;
-
-  /**
-   * Starting directory for config file picker (derived from config path)
-   */
-  configStartDir?: string;
-
-  /**
-   * Whether to use ZIP loading mode
-   */
-  loadZip?: boolean;
-
-  /**
-   * Path to ZIP file to load (for CLI-generated ZIPs)
-   */
-  zipPath?: string;
-
-  /**
-   * Name of ZIP file to load from Downloads (filename only)
-   */
-  zipFile?: string;
-}
-
-/**
- * Parses URL parameters and extracts configuration options
- */
-export function parseUrlParameters(): IUrlConfigOptions {
-  const params = new URLSearchParams(window.location.search);
-
-  const options: IUrlConfigOptions = {};
-
-  // Parse string parameters
-  const input = params.get('input');
-  if (input) {
-    options.input = input;
-    // Set starting directory for input file picker
-    if (isFilePath(input)) {
-      options.inputStartDir = extractDirectoryPath(input);
-    }
-  }
-
-  const config = params.get('config');
-  if (config) {
-    options.config = config;
-    // Set starting directory for config file picker
-    if (isFilePath(config)) {
-      options.configStartDir = extractDirectoryPath(config);
-    }
-  }
-
-  const contextFilter = params.get('contextFilter');
-  if (contextFilter) options.contextFilter = contextFilter;
-
-  const qualifierDefaults = params.get('qualifierDefaults');
-  if (qualifierDefaults) options.qualifierDefaults = qualifierDefaults;
-
-  const resourceTypes = params.get('resourceTypes');
-  if (resourceTypes) options.resourceTypes = resourceTypes;
-
-  // Parse numeric parameters
-  const maxDistance = params.get('maxDistance');
-  if (maxDistance) {
-    const parsed = parseInt(maxDistance, 10);
-    if (!isNaN(parsed)) options.maxDistance = parsed;
-  }
-
-  // Parse boolean parameters
-  const reduceQualifiers = params.get('reduceQualifiers');
-  if (reduceQualifiers === 'true') options.reduceQualifiers = true;
-
-  const interactive = params.get('interactive');
-  if (interactive === 'true') options.interactive = true;
-
-  // Parse ZIP loading parameters
-  const loadZip = params.get('loadZip');
-  if (loadZip === 'true') options.loadZip = true;
-
-  const zipPath = params.get('zipPath');
-  if (zipPath) options.zipPath = zipPath;
-
-  const zipFile = params.get('zipFile');
-  if (zipFile) options.zipFile = zipFile;
-
-  return options;
-}
-
-/**
- * Converts context filter token to context object
- * Example: "language=en-US|territory=US" -> { language: "en-US", territory: "US" }
- */
-export function parseContextFilter(contextFilter: string): Record<string, string> {
-  const context: Record<string, string> = {};
-
-  const tokens = contextFilter.split('|');
-  for (const token of tokens) {
-    const [key, value] = token.split('=');
-    if (key && value) {
-      context[key.trim()] = value.trim();
-    }
-  }
-
-  return context;
-}
-
-/**
- * Converts qualifier defaults token to structured format
- * Example: "language=en-US,en-CA|territory=US" -> { language: ["en-US", "en-CA"], territory: ["US"] }
- */
-export function parseQualifierDefaults(qualifierDefaults: string): Record<string, string[]> {
-  const defaults: Record<string, string[]> = {};
-
-  const tokens = qualifierDefaults.split('|');
-  for (const token of tokens) {
-    const [key, values] = token.split('=');
-    if (key && values) {
-      defaults[key.trim()] = values.split(',').map((v) => v.trim());
-    }
-  }
-
-  return defaults;
-}
-
-/**
- * Converts resource types string to array
- * Example: "json,string" -> ["json", "string"]
- */
-export function parseResourceTypes(resourceTypes: string): string[] {
-  return resourceTypes
-    .split(',')
-    .map((t) => t.trim())
-    .filter((t) => t.length > 0);
-}
-
-/**
- * Extracts the directory path from a file or directory path
- * If the path appears to be a directory (no extension), returns it as-is
- * If the path appears to be a file, returns the parent directory
- */
-export function extractDirectoryPath(path: string): string {
-  if (!path) return '';
-
-  // Normalize path separators
-  const normalizedPath = path.replace(/\\/g, '/');
-
-  // Check if it looks like a file (has an extension)
-  const parts = normalizedPath.split('/');
-  const lastPart = parts[parts.length - 1];
-
-  // If the last part has an extension, treat as file and return directory
-  if (lastPart.includes('.') && !lastPart.startsWith('.')) {
-    return parts.slice(0, -1).join('/') || '/';
-  }
-
-  // Otherwise, treat as directory
-  return normalizedPath;
-}
-
-/**
- * Determines if a path appears to be a file (has extension) or directory
- */
-export function isFilePath(path: string): boolean {
-  if (!path) return false;
-
-  const parts = path.split('/');
-  const lastPart = parts[parts.length - 1];
-
-  // Has extension and doesn't start with dot (hidden files)
-  return lastPart.includes('.') && !lastPart.startsWith('.');
-}