@fgv/ts-res-cli 5.0.0-9 → 5.0.1-1

package/src/compiler.ts

@@ -1,545 +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.
- */
-
-import { Result, succeed, fail, FileTree } from '@fgv/ts-utils';
-import { JsonObject } from '@fgv/ts-json-base';
-import * as TsRes from '@fgv/ts-res';
-import { ICompileOptions } from './options';
-import { DEFAULT_SYSTEM_CONFIGURATION } from './defaultConfiguration';
-import { promises as fs } from 'fs';
-import * as path from 'path';
-
-/**
- * Information about compiled resources
- */
-export interface IResourceInfo {
-  totalResources: number;
-  totalCandidates: number;
-  filteredResources: number;
-  filteredCandidates: number;
-  resourceTypes: string[];
-  qualifiers: string[];
-  context?: JsonObject;
-}
-
-export interface IFilteredManager {
-  original: TsRes.Resources.ResourceManagerBuilder;
-  manager: TsRes.Resources.ResourceManagerBuilder;
-  context?: JsonObject;
-}
-
-/**
- * Compiled resource blob
- */
-export interface IResourceBlob {
-  resources?: TsRes.ResourceJson.Json.IResourceCollectionDecl;
-  compiledCollection?: TsRes.ResourceJson.Compiled.ICompiledResourceCollection;
-  bundle?: TsRes.Bundle.IBundle;
-  metadata?: IResourceInfo;
-}
-
-/**
- * Main resource compiler class
- */
-export class ResourceCompiler {
-  private readonly _options: ICompileOptions;
-  private _systemConfiguration?: TsRes.Config.Model.ISystemConfiguration;
-
-  public constructor(options: ICompileOptions) {
-    this._options = options;
-  }
-
-  /**
-   * Compiles resources according to the configured options
-   */
-  public async compile(): Promise<Result<IResourceBlob>> {
-    try {
-      if (this._options.debug) {
-        console.error('Starting resource compilation...');
-        console.error('Options:', JSON.stringify(this._options, null, 2));
-      }
-
-      // Load and validate configuration
-      const config = (await this._loadConfiguration()).orThrow(
-        (err) => `Failed to load configuration: ${err}`
-      );
-
-      if (this._options.debug) {
-        console.error('Configuration loaded successfully');
-      }
-
-      // Load resources from input
-      const original = (await this._loadResources(config)).orThrow(
-        (err) => `Failed to load resources: ${err}`
-      );
-
-      if (this._options.verbose) {
-        console.error(`Loaded ${original.numResources} resources with ${original.numCandidates} candidates`);
-      }
-
-      // Apply context filtering if specified
-      const filtered = this._applyFilters(original).orThrow(
-        (err) => `Failed to apply context filtering: ${err}`
-      );
-
-      if (this._options.verbose && filtered.manager !== filtered.original) {
-        console.error(
-          `After context filtering: ${filtered.manager.numResources} resources, ${filtered.manager.numCandidates} candidates`
-        );
-      }
-
-      // Generate output blob
-      const blob = (await this._generateBlob(filtered)).orThrow(
-        (err) => `Failed to generate output blob: ${err}`
-      );
-
-      if (this._options.debug) {
-        console.error(`Generated ${this._options.format} format output blob`);
-      }
-
-      // Write output
-      (await this._writeOutput(blob)).orThrow((err) => `Failed to write output: ${err}`);
-
-      if (this._options.debug) {
-        console.error(`Output written to: ${this._options.output}`);
-      }
-
-      return succeed(blob);
-    } catch (error) {
-      return fail(`Compilation failed: ${error}`);
-    }
-  }
-
-  /**
-   * Validates resources without compilation
-   */
-  public async validate(): Promise<Result<TsRes.Resources.ResourceManagerBuilder>> {
-    try {
-      // Load and validate configuration
-      const config = (await this._loadConfiguration()).orThrow(
-        (err) => `Failed to load configuration: ${err}`
-      );
-
-      const manager = (await this._loadResources(config)).orThrow(
-        (err) => `Failed to load resources: ${err}`
-      );
-
-      const filtered = this._applyFilters(manager).orThrow(
-        (err) => `Failed to apply context filtering: ${err}`
-      );
-
-      // Build all resources to trigger validation
-      return filtered.manager.build().onSuccess((manager) => {
-        if (this._options.verbose) {
-          console.error(
-            `Resource validation successful with ${manager.numResources} resources and ${manager.numCandidates} candidates`
-          );
-        }
-        return succeed(manager);
-      });
-    } catch (error) {
-      return fail(`Validation failed: ${error}`);
-    }
-  }
-
-  /**
-   * Gets information about the resources
-   */
-  public async getInfo(): Promise<Result<IResourceInfo>> {
-    try {
-      // Load and validate configuration
-      const config = (await this._loadConfiguration()).orThrow(
-        (err) => `Failed to load configuration: ${err}`
-      );
-
-      const manager = (await this._loadResources(config)).orThrow(
-        (err) => `Failed to load resources: ${err}`
-      );
-
-      const filtered = this._applyFilters(manager).orThrow(
-        (err) => `Failed to apply context filtering: ${err}`
-      );
-
-      return succeed(this._generateResourceInfo(filtered));
-    } catch (error) {
-      return fail(`Failed to get resource info: ${error}`);
-    }
-  }
-
-  /**
-   * Loads and validates the system configuration
-   */
-  private async _loadConfiguration(): Promise<Result<TsRes.Config.Model.ISystemConfiguration>> {
-    try {
-      if (this._options.config) {
-        // Check if it's a predefined configuration name
-        const predefinedNames: TsRes.Config.PredefinedSystemConfiguration[] = [
-          'default',
-          'language-priority',
-          'territory-priority',
-          'extended-example'
-        ];
-        if (predefinedNames.includes(this._options.config as TsRes.Config.PredefinedSystemConfiguration)) {
-          const predefinedResult = TsRes.Config.getPredefinedDeclaration(
-            this._options.config as TsRes.Config.PredefinedSystemConfiguration
-          );
-          if (predefinedResult.isSuccess()) {
-            this._systemConfiguration = predefinedResult.value;
-            if (this._options.verbose) {
-              console.error(`Using predefined configuration: ${this._systemConfiguration.name}`);
-            }
-            return succeed(this._systemConfiguration);
-          }
-        }
-
-        // If not a predefined config, try to load as file path
-        try {
-          const configPath = path.resolve(this._options.config);
-          if (this._options.debug) {
-            console.error(`Loading configuration from: ${configPath}`);
-          }
-          const configContent = await fs.readFile(configPath, 'utf-8');
-          const configData = JSON.parse(configContent);
-
-          // Validate the configuration using ts-res converter
-          const configResult = TsRes.Config.Convert.systemConfiguration.convert(configData);
-          if (configResult.isFailure()) {
-            return fail(`Invalid configuration file: ${configResult.message}`);
-          }
-
-          this._systemConfiguration = configResult.value;
-          if (this._options.verbose) {
-            console.error(`Using custom configuration: ${this._systemConfiguration.name}`);
-          }
-        } catch (fileError) {
-          return fail(
-            `Configuration '${this._options.config}' is not a predefined configuration name and failed to load as file: ${fileError}`
-          );
-        }
-      } else {
-        // Use default predefined configuration
-        const defaultResult = TsRes.Config.getPredefinedDeclaration('default');
-        if (defaultResult.isSuccess()) {
-          this._systemConfiguration = defaultResult.value;
-        } else {
-          // Fallback to hardcoded default if predefined default is not available
-          this._systemConfiguration = DEFAULT_SYSTEM_CONFIGURATION;
-        }
-        if (this._options.verbose) {
-          console.error(`Using default configuration: ${this._systemConfiguration.name}`);
-        }
-      }
-
-      return succeed(this._systemConfiguration);
-    } catch (error) {
-      return fail(`Failed to load configuration: ${error}`);
-    }
-  }
-
-  /**
-   * Loads resources from the input path using the configured system
-   */
-  private async _loadResources(
-    config: TsRes.Config.Model.ISystemConfiguration
-  ): Promise<Result<TsRes.Resources.ResourceManagerBuilder>> {
-    try {
-      if (!this._systemConfiguration) {
-        return fail('System configuration not loaded');
-      }
-
-      // Parse qualifier defaults if provided
-      let qualifierDefaultValues: Record<string, string | null> | undefined;
-      if (this._options.qualifierDefaults) {
-        // We need to create a temporary system configuration first to parse defaults
-        const tempSystemConfigResult = TsRes.Config.SystemConfiguration.create(this._systemConfiguration);
-        if (tempSystemConfigResult.isFailure()) {
-          return fail(`Failed to create temporary system configuration: ${tempSystemConfigResult.message}`);
-        }
-
-        const tokens = new TsRes.Qualifiers.QualifierDefaultValueTokens(
-          tempSystemConfigResult.value.qualifiers
-        );
-        const defaultsResult = tokens.qualifierDefaultValuesTokenToDecl(this._options.qualifierDefaults);
-        if (defaultsResult.isFailure()) {
-          return fail(`Failed to parse qualifier defaults: ${defaultsResult.message}`);
-        }
-
-        qualifierDefaultValues = defaultsResult.value;
-      }
-
-      // Create system configuration and ts-res system
-      const systemConfigResult = TsRes.Config.SystemConfiguration.create(
-        this._systemConfiguration,
-        qualifierDefaultValues ? { qualifierDefaultValues } : undefined
-      );
-      if (systemConfigResult.isFailure()) {
-        return fail(`Failed to create system configuration: ${systemConfigResult.message}`);
-      }
-
-      const systemConfig = systemConfigResult.value;
-
-      // Create resource manager from system configuration
-      const manager = TsRes.Resources.ResourceManagerBuilder.create({
-        qualifiers: systemConfig.qualifiers,
-        resourceTypes: systemConfig.resourceTypes
-      });
-
-      if (manager.isFailure()) {
-        return fail(`Failed to create resource manager: ${manager.message}`);
-      }
-
-      // Load resources from input path
-      const importResult = await this._importResources(manager.value);
-      if (importResult.isFailure()) {
-        return fail(`Failed to import resources: ${importResult.message}`);
-      }
-
-      return succeed(manager.value);
-    } catch (error) {
-      return fail(`Failed to load resources: ${error}`);
-    }
-  }
-
-  /**
-   * Imports resources from the input path using ImportManager
-   */
-  private async _importResources(manager: TsRes.Resources.ResourceManagerBuilder): Promise<Result<void>> {
-    try {
-      const inputPath = path.resolve(this._options.input);
-
-      // Create FileTree for file system operations
-      const fileTree = FileTree.forFilesystem();
-      if (fileTree.isFailure()) {
-        return fail(`Failed to create file tree: ${fileTree.message}`);
-      }
-
-      // Create ImportManager with the resource manager and file tree
-      const importManager = TsRes.Import.ImportManager.create({
-        resources: manager,
-        fileTree: fileTree.value
-      });
-
-      if (importManager.isFailure()) {
-        return fail(`Failed to create import manager: ${importManager.message}`);
-      }
-
-      // Use ImportManager to handle both files and directories automatically
-      if (this._options.debug) {
-        console.error(`Importing resources from: ${inputPath}`);
-      }
-      const importResult = importManager.value.importFromFileSystem(inputPath);
-      if (importResult.isFailure()) {
-        return fail(`Failed to import from ${inputPath}: ${importResult.message}`);
-      }
-
-      if (this._options.verbose) {
-        console.error(`Successfully imported resources from: ${inputPath}`);
-      }
-
-      return succeed(undefined);
-    } catch (error) {
-      return fail(`Failed to import resources: ${error}`);
-    }
-  }
-
-  /**
-   * Applies filters to imported resources
-   */
-  private _applyFilters(original: TsRes.Resources.ResourceManagerBuilder): Result<IFilteredManager> {
-    if (this._options.contextFilter) {
-      const tokens = new TsRes.Context.ContextTokens(original.qualifiers);
-      return tokens.contextTokenToPartialContext(this._options.contextFilter).onSuccess((context) => {
-        return original
-          .clone({
-            filterForContext: context,
-            reduceQualifiers: this._options.reduceQualifiers
-          })
-          .onSuccess((manager) => {
-            return succeed({ original, manager, context });
-          });
-      });
-    }
-    return succeed({ original, manager: original });
-  }
-
-  /**
-   * Generates the output blob
-   */
-  private async _generateBlob(filtered: IFilteredManager): Promise<Result<IResourceBlob>> {
-    try {
-      if (this._options.format === 'compiled') {
-        return this._generateCompiledBlob(filtered);
-      } else if (this._options.format === 'bundle') {
-        return this._generateBundleBlob(filtered);
-      } else {
-        return this._generateSourceBlob(filtered);
-      }
-    } catch (error) {
-      return fail(`Failed to generate blob: ${error}`);
-    }
-  }
-
-  /**
-   * Generates a compiled resource collection blob
-   */
-  private _generateCompiledBlob(filtered: IFilteredManager): Result<IResourceBlob> {
-    // Build all resources to ensure they're ready for compilation
-    return filtered.manager.getCompiledResourceCollection().onSuccess((compiled) => {
-      const blob: IResourceBlob = {
-        compiledCollection: compiled
-      };
-
-      if (this._options.includeMetadata) {
-        blob.metadata = this._generateResourceInfo(filtered);
-      }
-      return succeed(blob);
-    });
-  }
-
-  /**
-   * Generates a source format blob (legacy format)
-   */
-  private _generateSourceBlob(filtered: IFilteredManager): Result<IResourceBlob> {
-    return filtered.manager.getResourceCollectionDecl().onSuccess((resources) => {
-      const blob: IResourceBlob = { resources };
-
-      if (this._options.includeMetadata) {
-        blob.metadata = this._generateResourceInfo(filtered);
-      }
-
-      return succeed(blob);
-    });
-  }
-
-  /**
-   * Generates a bundle blob
-   */
-  private _generateBundleBlob(filtered: IFilteredManager): Result<IResourceBlob> {
-    if (!this._systemConfiguration) {
-      return fail('System configuration is required for bundle generation');
-    }
-
-    // Create SystemConfiguration from the loaded configuration
-    return TsRes.Config.SystemConfiguration.create(this._systemConfiguration).onSuccess((systemConfig) => {
-      // Create bundle using BundleBuilder
-      const bundleParams: TsRes.Bundle.IBundleCreateParams = {
-        version: '1.0.0',
-        description: 'Generated bundle from ts-res-cli',
-        normalize: true // Use order-resilient normalization for consistent output
-      };
-
-      return TsRes.Bundle.BundleBuilder.create(filtered.manager, systemConfig, bundleParams).onSuccess(
-        (bundle) => {
-          const blob: IResourceBlob = {
-            bundle
-          };
-
-          if (this._options.includeMetadata) {
-            blob.metadata = this._generateResourceInfo(filtered);
-          }
-
-          return succeed(blob);
-        }
-      );
-    });
-  }
-
-  /**
-   * Generates resource information
-   */
-  private _generateResourceInfo(filtered: IFilteredManager): IResourceInfo {
-    const resourceTypes = Array.from(
-      new Set(
-        filtered.manager
-          .getAllCandidates()
-          .map((c) => c.resourceType?.key)
-          .filter(Boolean)
-      )
-    ) as string[];
-
-    const qualifiers = Array.from(filtered.manager.qualifiers.keys());
-
-    const info: IResourceInfo = {
-      totalResources: filtered.original.numResources,
-      totalCandidates: filtered.original.numCandidates,
-      filteredResources: filtered.manager.numResources,
-      filteredCandidates: filtered.manager.numCandidates,
-      resourceTypes,
-      qualifiers,
-      ...(filtered.context ? { context: filtered.context } : undefined)
-    };
-
-    return info;
-  }
-
-  /**
-   * Writes the output blob to the specified output path
-   */
-  private async _writeOutput(blob: IResourceBlob): Promise<Result<void>> {
-    try {
-      const outputPath = path.resolve(this._options.output);
-      const outputDir = path.dirname(outputPath);
-
-      // Ensure output directory exists
-      await fs.mkdir(outputDir, { recursive: true });
-
-      let content: string;
-
-      switch (this._options.format) {
-        case 'compiled':
-          // If metadata is included, write the full blob; otherwise, write just the compiled collection
-          const compiledData = this._options.includeMetadata ? blob : blob.compiledCollection;
-          content = JSON.stringify(compiledData, null, 2);
-          break;
-        case 'source':
-          content = JSON.stringify(blob, null, 2);
-          break;
-        case 'js':
-          const jsData = blob.compiledCollection || blob;
-          content = `module.exports = ${JSON.stringify(jsData, null, 2)};`;
-          break;
-        case 'ts':
-          const tsData = blob.compiledCollection || blob;
-          content = `export const resources = ${JSON.stringify(tsData, null, 2)} as const;`;
-          break;
-        case 'binary':
-          // For binary format, we could use a more efficient serialization
-          // For now, use JSON as a placeholder
-          const binaryData = blob.compiledCollection || blob;
-          content = JSON.stringify(binaryData);
-          break;
-        case 'bundle':
-          // Bundle format outputs the complete bundle with metadata, config, and compiled resources
-          const bundleData = this._options.includeMetadata ? blob : blob.bundle;
-          content = JSON.stringify(bundleData, null, 2);
-          break;
-        default:
-          return fail(`Unsupported output format: ${this._options.format}`);
-      }
-
-      await fs.writeFile(outputPath, content, 'utf-8');
-      return succeed(undefined);
-    } catch (error) {
-      return fail(`Failed to write output: ${error}`);
-    }
-  }
-}

package/src/defaultConfiguration.ts

@@ -1,78 +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.
- */
-
-import * as TsRes from '@fgv/ts-res';
-
-/**
- * Default system configuration for ts-res CLI tool
- * This matches the configuration used in the ts-res-browser tool
- */
-export const DEFAULT_SYSTEM_CONFIGURATION: TsRes.Config.Model.ISystemConfiguration = {
-  name: 'Default CLI Configuration',
-  description: 'Built-in default configuration for ts-res CLI tool',
-  qualifierTypes: [
-    {
-      name: 'language',
-      systemType: 'language',
-      configuration: {}
-    },
-    {
-      name: 'territory',
-      systemType: 'territory',
-      configuration: {}
-    },
-    {
-      name: 'role',
-      systemType: 'literal',
-      configuration: {
-        enumeratedValues: ['admin', 'user', 'guest']
-      }
-    }
-  ],
-  qualifiers: [
-    {
-      name: 'language',
-      typeName: 'language',
-      token: 'language',
-      defaultPriority: 600
-    },
-    {
-      name: 'territory',
-      typeName: 'territory',
-      token: 'territory',
-      defaultPriority: 500
-    },
-    {
-      name: 'role',
-      typeName: 'role',
-      token: 'role',
-      tokenIsOptional: true,
-      defaultPriority: 400
-    }
-  ],
-  resourceTypes: [
-    {
-      name: 'json',
-      typeName: 'json'
-    }
-  ]
-};

package/src/index.ts

@@ -1,25 +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.
- */
-
-export * from './cli';
-export * from './compiler';
-export * from './options';