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

package/CHANGELOG.json

@@ -0,0 +1,23 @@
+{
+  "name": "@fgv/ts-res-cli",
+  "entries": [
+    {
+      "version": "5.0.1",
+      "tag": "@fgv/ts-res-cli_v5.0.1",
+      "date": "Tue, 23 Sep 2025 03:13:55 GMT",
+      "comments": {}
+    },
+    {
+      "version": "5.0.0",
+      "tag": "@fgv/ts-res-cli_v5.0.0",
+      "date": "Tue, 23 Sep 2025 02:54:20 GMT",
+      "comments": {
+        "none": [
+          {
+            "comment": "initial checkin"
+          }
+        ]
+      }
+    }
+  ]
+}

package/eslint.config.js

@@ -0,0 +1,16 @@
+// ESLint 9 flat config
+const nodeProfile = require('@rushstack/eslint-config/flat/profile/node');
+const packletsPlugin = require('@rushstack/eslint-config/flat/mixins/packlets');
+const tsdocPlugin = require('@rushstack/eslint-config/flat/mixins/tsdoc');
+
+module.exports = [
+  ...nodeProfile,
+  packletsPlugin,
+  ...tsdocPlugin,
+  {
+    // Override specific rules if needed
+    rules: {
+      '@rushstack/packlets/mechanics': 'warn'
+    }
+  }
+];

package/lib/cli.d.ts

@@ -28,9 +28,53 @@ export declare class TsResCliApp {
      * Handles the config command
      */
     private _handleConfigCommand;
+    /**
+     * Handles the delta command
+     */
+    private _handleDeltaCommand;
+    /**
+     * Handles the archive command
+     */
+    private _handleArchiveCommand;
+    /**
+     * Parses and validates delta options
+     */
+    private _parseDeltaOptions;
     /**
      * Parses and validates compile options
      */
     private _parseCompileOptions;
+    /**
+     * Generates delta between baseline and target resources
+     */
+    private _generateDelta;
+    /**
+     * Loads system configuration (reused from ResourceCompiler pattern)
+     */
+    private _loadSystemConfiguration;
+    /**
+     * Creates a resource manager from a path (reused from ResourceCompiler pattern)
+     */
+    private _createResourceManager;
+    /**
+     * Imports resources from a file path (reused from ResourceCompiler pattern)
+     */
+    private _importResourcesFromPath;
+    /**
+     * Creates a resource resolver from a resource manager and system configuration
+     */
+    private _createResourceResolver;
+    /**
+     * Generates output blob for delta resources
+     */
+    private _generateDeltaBlob;
+    /**
+     * Generates resource information for delta output
+     */
+    private _generateDeltaResourceInfo;
+    /**
+     * Writes delta output to file
+     */
+    private _writeDeltaOutput;
 }
 //# sourceMappingURL=cli.d.ts.map

package/lib/cli.js

@@ -142,6 +142,35 @@ class TsResCliApp {
             .action(async (options) => {
             await this._handleConfigCommand(options);
         });
+        this._program
+            .command('archive')
+            .description('Create ZIP archive of resources and configuration')
+            .option('-i, --input <path>', 'Input file or directory path')
+            .option('--config <path>', 'Configuration file path')
+            .requiredOption('-o, --output <path>', 'Output ZIP file path')
+            .option('-v, --verbose', 'Verbose output', false)
+            .option('-q, --quiet', 'Quiet output', false)
+            .action(async (options) => {
+            await this._handleArchiveCommand(options);
+        });
+        this._program
+            .command('delta')
+            .description('Generate delta between baseline and target resources')
+            .requiredOption('--baseline <path>', 'Baseline resource file or directory path')
+            .requiredOption('--target <path>', 'Target resource file or directory path')
+            .requiredOption('-o, --output <path>', 'Output file path')
+            .option('--config <name|path>', 'Predefined configuration name or system configuration file path (JSON, ISystemConfiguration format)')
+            .option('--context-filter <token>', 'Context filter token (pipe-separated, e.g., "language=en-US|territory=US")')
+            .option('--qualifier-defaults <token>', 'Qualifier default values token (pipe-separated, e.g., "language=en-US,en-CA|territory=US")')
+            .option('--resource-ids <ids>', 'Comma-separated list of specific resource IDs to include in delta generation')
+            .option('--skip-unchanged', 'Skip resources that have not changed between baseline and target', true)
+            .option('-f, --format <format>', 'Output format (compiled, source, js, ts, binary, bundle)', 'compiled')
+            .option('-v, --verbose', 'Verbose output', false)
+            .option('-q, --quiet', 'Quiet output', false)
+            .option('--include-metadata', 'Include resource metadata in output', false)
+            .action(async (options) => {
+            await this._handleDeltaCommand(options);
+        });
     }
     /**
      * Handles the compile command
@@ -413,6 +442,120 @@ class TsResCliApp {
             process.exit(1);
         }
     }
+    /**
+     * Handles the delta command
+     */
+    async _handleDeltaCommand(options) {
+        const deltaOptions = this._parseDeltaOptions(options);
+        if (deltaOptions.isFailure()) {
+            console.error(`Error: ${deltaOptions.message}`);
+            process.exit(1);
+        }
+        const result = await this._generateDelta(deltaOptions.value);
+        if (result.isFailure()) {
+            console.error(`Error: ${result.message}`);
+            process.exit(1);
+        }
+        if (!options.quiet) {
+            console.log(`Successfully generated delta to ${options.output}`);
+        }
+    }
+    /**
+     * Handles the archive command
+     */
+    async _handleArchiveCommand(options) {
+        try {
+            // Import ZipArchive dynamically to avoid loading if not needed
+            const { ZipArchive } = await Promise.resolve().then(() => __importStar(require('@fgv/ts-res')));
+            if (!options.input && !options.config) {
+                console.error('Error: At least one of --input or --config must be specified');
+                process.exit(1);
+            }
+            if (!options.quiet) {
+                console.log('Creating ZIP archive...');
+                if (options.input)
+                    console.log(`Input: ${options.input}`);
+                if (options.config)
+                    console.log(`Config: ${options.config}`);
+                console.log(`Output: ${options.output}`);
+            }
+            // Create ZIP archive using the new zip-archive packlet
+            const creator = new ZipArchive.ZipArchiveCreator();
+            const createResult = await creator.createFromBuffer({
+                inputPath: options.input,
+                configPath: options.config
+            }, options.verbose
+                ? (phase, progress, message) => {
+                    console.log(`[${phase}] ${progress}% - ${message}`);
+                }
+                : undefined);
+            if (createResult.isFailure()) {
+                console.error(`Error: Failed to create ZIP archive: ${createResult.message}`);
+                process.exit(1);
+            }
+            const { zipBuffer, manifest, size } = createResult.value;
+            // Write the ZIP buffer to the specified output file
+            const fs = await Promise.resolve().then(() => __importStar(require('fs'))).then((m) => m.promises);
+            const path = await Promise.resolve().then(() => __importStar(require('path')));
+            const outputPath = path.resolve(options.output);
+            const outputDir = path.dirname(outputPath);
+            // Ensure output directory exists
+            await fs.mkdir(outputDir, { recursive: true });
+            // Write ZIP file
+            await fs.writeFile(outputPath, zipBuffer);
+            if (!options.quiet) {
+                console.log(`ZIP archive created successfully: ${outputPath}`);
+                console.log(`Archive size: ${(size / 1024).toFixed(2)} KB`);
+                console.log(`Manifest:`);
+                console.log(JSON.stringify(manifest, null, 2));
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    }
+    /**
+     * Parses and validates delta options
+     */
+    _parseDeltaOptions(options) {
+        var _a;
+        try {
+            const format = options.format;
+            if (!['compiled', 'source', 'js', 'ts', 'binary', 'bundle'].includes(format)) {
+                return (0, ts_utils_1.fail)(`Invalid format: ${format}`);
+            }
+            // Parse resource IDs if provided
+            let resourceIds;
+            if (options.resourceIds) {
+                resourceIds = options.resourceIds
+                    .split(',')
+                    .map((id) => id.trim())
+                    .filter((id) => id.length > 0);
+                if (resourceIds.length === 0) {
+                    return (0, ts_utils_1.fail)('Resource IDs list cannot be empty');
+                }
+            }
+            const deltaOptions = {
+                baseline: options.baseline,
+                target: options.target,
+                output: options.output,
+                config: options.config,
+                contextFilter: options.contextFilter,
+                qualifierDefaults: options.qualifierDefaults,
+                resourceIds,
+                skipUnchanged: (_a = options.skipUnchanged) !== null && _a !== void 0 ? _a : true,
+                format,
+                verbose: options.verbose || false,
+                quiet: options.quiet || false,
+                includeMetadata: options.includeMetadata || false
+            };
+            return (0, ts_utils_1.succeed)(deltaOptions);
+        }
+        catch (error) {
+            return (0, ts_utils_1.fail)(`Failed to parse delta options: ${error}`);
+        }
+    }
     /**
      * Parses and validates compile options
      */
@@ -459,6 +602,426 @@ class TsResCliApp {
             return (0, ts_utils_1.fail)(`Failed to parse options: ${error}`);
         }
     }
+    /**
+     * Generates delta between baseline and target resources
+     */
+    async _generateDelta(options) {
+        try {
+            if (options.verbose) {
+                console.error('Starting delta generation...');
+                console.error(`Baseline: ${options.baseline}`);
+                console.error(`Target: ${options.target}`);
+                console.error(`Output: ${options.output}`);
+            }
+            // Load system configuration
+            const config = await this._loadSystemConfiguration(options.config, options.verbose);
+            if (config.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to load configuration: ${config.message}`);
+            }
+            if (options.verbose) {
+                console.error('Configuration loaded successfully');
+            }
+            // Create resource managers for baseline and target
+            const baselineManager = await this._createResourceManager(config.value, options.baseline, options.qualifierDefaults, options.verbose);
+            if (baselineManager.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to load baseline resources: ${baselineManager.message}`);
+            }
+            const targetManager = await this._createResourceManager(config.value, options.target, options.qualifierDefaults, options.verbose);
+            if (targetManager.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to load target resources: ${targetManager.message}`);
+            }
+            if (options.verbose) {
+                console.error(`Baseline loaded: ${baselineManager.value.numResources} resources, ${baselineManager.value.numCandidates} candidates`);
+                console.error(`Target loaded: ${targetManager.value.numResources} resources, ${targetManager.value.numCandidates} candidates`);
+            }
+            // Create resource resolvers
+            const baselineResolver = await this._createResourceResolver(baselineManager.value, options.contextFilter, options.verbose, config.value);
+            if (baselineResolver.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to create baseline resolver: ${baselineResolver.message}`);
+            }
+            const targetResolver = await this._createResourceResolver(targetManager.value, options.contextFilter, options.verbose, config.value);
+            if (targetResolver.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to create target resolver: ${targetResolver.message}`);
+            }
+            // Create delta generator
+            const deltaGenerator = TsRes.Resources.DeltaGenerator.create({
+                baselineResolver: baselineResolver.value,
+                deltaResolver: targetResolver.value,
+                resourceManager: baselineManager.value,
+                logger: options.verbose ? new ts_utils_1.Logging.ConsoleLogger() : undefined
+            });
+            if (deltaGenerator.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to create delta generator: ${deltaGenerator.message}`);
+            }
+            // Parse context filter for delta generation options
+            let context;
+            if (options.contextFilter) {
+                const contextTokens = new TsRes.Context.ContextTokens(baselineManager.value.qualifiers);
+                const contextResult = contextTokens.contextTokenToPartialContext(options.contextFilter);
+                if (contextResult.isFailure()) {
+                    return (0, ts_utils_1.fail)(`Failed to parse context filter: ${contextResult.message}`);
+                }
+                context = contextResult.value;
+            }
+            // Generate delta
+            const deltaOptions = {
+                context,
+                resourceIds: options.resourceIds,
+                skipUnchanged: options.skipUnchanged
+            };
+            if (options.verbose) {
+                console.error('Generating delta...');
+            }
+            const deltaResult = deltaGenerator.value.generate(deltaOptions);
+            if (deltaResult.isFailure()) {
+                return (0, ts_utils_1.fail)(`Delta generation failed: ${deltaResult.message}`);
+            }
+            const deltaManager = deltaResult.value;
+            if (options.verbose) {
+                console.error(`Delta generated: ${deltaManager.numResources} resources, ${deltaManager.numCandidates} candidates`);
+            }
+            // Generate output blob
+            const blob = await this._generateDeltaBlob(deltaManager, options, config.value);
+            if (blob.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to generate output blob: ${blob.message}`);
+            }
+            // Write output
+            const writeResult = await this._writeDeltaOutput(blob.value, options);
+            if (writeResult.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to write output: ${writeResult.message}`);
+            }
+            if (options.verbose) {
+                console.error(`Delta output written to: ${options.output}`);
+            }
+            return (0, ts_utils_1.succeed)(undefined);
+        }
+        catch (error) {
+            return (0, ts_utils_1.fail)(`Delta generation failed: ${error}`);
+        }
+    }
+    /**
+     * Loads system configuration (reused from ResourceCompiler pattern)
+     */
+    async _loadSystemConfiguration(configOption, verbose) {
+        try {
+            if (configOption) {
+                // Check if it's a predefined configuration name
+                const predefinedNames = [
+                    'default',
+                    'language-priority',
+                    'territory-priority',
+                    'extended-example'
+                ];
+                if (predefinedNames.includes(configOption)) {
+                    const predefinedResult = TsRes.Config.getPredefinedDeclaration(configOption);
+                    if (predefinedResult.isSuccess()) {
+                        if (verbose) {
+                            console.error(`Using predefined configuration: ${predefinedResult.value.name}`);
+                        }
+                        return (0, ts_utils_1.succeed)(predefinedResult.value);
+                    }
+                }
+                // Try to load as file path
+                try {
+                    const path = await Promise.resolve().then(() => __importStar(require('path')));
+                    const fs = await Promise.resolve().then(() => __importStar(require('fs'))).then((m) => m.promises);
+                    const configPath = path.resolve(configOption);
+                    const configContent = await fs.readFile(configPath, 'utf-8');
+                    const configData = JSON.parse(configContent);
+                    const configResult = TsRes.Config.Convert.systemConfiguration.convert(configData);
+                    if (configResult.isFailure()) {
+                        return (0, ts_utils_1.fail)(`Invalid configuration file: ${configResult.message}`);
+                    }
+                    if (verbose) {
+                        console.error(`Using custom configuration: ${configResult.value.name}`);
+                    }
+                    return (0, ts_utils_1.succeed)(configResult.value);
+                }
+                catch (fileError) {
+                    return (0, ts_utils_1.fail)(`Configuration '${configOption}' is not a predefined configuration name and failed to load as file: ${fileError}`);
+                }
+            }
+            else {
+                // Use default configuration
+                const defaultResult = TsRes.Config.getPredefinedDeclaration('default');
+                if (defaultResult.isSuccess()) {
+                    if (verbose) {
+                        console.error(`Using default configuration: ${defaultResult.value.name}`);
+                    }
+                    return (0, ts_utils_1.succeed)(defaultResult.value);
+                }
+                else {
+                    return (0, ts_utils_1.fail)('Failed to load default configuration');
+                }
+            }
+        }
+        catch (error) {
+            return (0, ts_utils_1.fail)(`Failed to load system configuration: ${error}`);
+        }
+    }
+    /**
+     * Creates a resource manager from a path (reused from ResourceCompiler pattern)
+     */
+    async _createResourceManager(systemConfig, inputPath, qualifierDefaults, verbose) {
+        try {
+            // Parse qualifier defaults if provided
+            let qualifierDefaultValues;
+            if (qualifierDefaults) {
+                const tempSystemConfigResult = TsRes.Config.SystemConfiguration.create(systemConfig);
+                if (tempSystemConfigResult.isFailure()) {
+                    return (0, ts_utils_1.fail)(`Failed to create temporary system configuration: ${tempSystemConfigResult.message}`);
+                }
+                const tokens = new TsRes.Qualifiers.QualifierDefaultValueTokens(tempSystemConfigResult.value.qualifiers);
+                const defaultsResult = tokens.qualifierDefaultValuesTokenToDecl(qualifierDefaults);
+                if (defaultsResult.isFailure()) {
+                    return (0, ts_utils_1.fail)(`Failed to parse qualifier defaults: ${defaultsResult.message}`);
+                }
+                qualifierDefaultValues = defaultsResult.value;
+            }
+            // Create system configuration
+            const systemConfigResult = TsRes.Config.SystemConfiguration.create(systemConfig, qualifierDefaultValues ? { qualifierDefaultValues } : undefined);
+            if (systemConfigResult.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to create system configuration: ${systemConfigResult.message}`);
+            }
+            const config = systemConfigResult.value;
+            // Create resource manager
+            const manager = TsRes.Resources.ResourceManagerBuilder.create({
+                qualifiers: config.qualifiers,
+                resourceTypes: config.resourceTypes
+            });
+            if (manager.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to create resource manager: ${manager.message}`);
+            }
+            // Import resources from path
+            const importResult = await this._importResourcesFromPath(manager.value, inputPath, verbose);
+            if (importResult.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to import resources from ${inputPath}: ${importResult.message}`);
+            }
+            return (0, ts_utils_1.succeed)(manager.value);
+        }
+        catch (error) {
+            return (0, ts_utils_1.fail)(`Failed to create resource manager: ${error}`);
+        }
+    }
+    /**
+     * Imports resources from a file path (reused from ResourceCompiler pattern)
+     */
+    async _importResourcesFromPath(manager, inputPath, verbose) {
+        try {
+            const path = await Promise.resolve().then(() => __importStar(require('path')));
+            const { FileTree } = await Promise.resolve().then(() => __importStar(require('@fgv/ts-json-base')));
+            const resolvedPath = path.resolve(inputPath);
+            // Create FileTree for file system operations
+            const fileTree = FileTree.forFilesystem();
+            if (fileTree.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to create file tree: ${fileTree.message}`);
+            }
+            // Create ImportManager
+            const importManager = TsRes.Import.ImportManager.create({
+                resources: manager,
+                fileTree: fileTree.value
+            });
+            if (importManager.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to create import manager: ${importManager.message}`);
+            }
+            // Import resources
+            if (verbose) {
+                console.error(`Importing resources from: ${resolvedPath}`);
+            }
+            const importResult = importManager.value.importFromFileSystem(resolvedPath);
+            if (importResult.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to import from ${resolvedPath}: ${importResult.message}`);
+            }
+            if (verbose) {
+                console.error(`Successfully imported resources from: ${resolvedPath}`);
+            }
+            return (0, ts_utils_1.succeed)(undefined);
+        }
+        catch (error) {
+            return (0, ts_utils_1.fail)(`Failed to import resources: ${error}`);
+        }
+    }
+    /**
+     * Creates a resource resolver from a resource manager and system configuration
+     */
+    async _createResourceResolver(manager, contextFilter, verbose, systemConfig) {
+        try {
+            // Apply context filtering if specified
+            let finalManager = manager;
+            if (contextFilter) {
+                const contextTokens = new TsRes.Context.ContextTokens(manager.qualifiers);
+                const contextResult = contextTokens.contextTokenToPartialContext(contextFilter);
+                if (contextResult.isFailure()) {
+                    return (0, ts_utils_1.fail)(`Failed to parse context filter: ${contextResult.message}`);
+                }
+                const filteredManagerResult = manager.clone({
+                    filterForContext: contextResult.value,
+                    reduceQualifiers: false // Don't reduce qualifiers for delta generation
+                });
+                if (filteredManagerResult.isFailure()) {
+                    return (0, ts_utils_1.fail)(`Failed to apply context filter: ${filteredManagerResult.message}`);
+                }
+                finalManager = filteredManagerResult.value;
+                if (verbose) {
+                    console.error(`After context filtering: ${finalManager.numResources} resources, ${finalManager.numCandidates} candidates`);
+                }
+            }
+            // Build the manager to create the resolver
+            const builtManager = finalManager.build();
+            if (builtManager.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to build resource manager: ${builtManager.message}`);
+            }
+            // Create qualifier types from system config or use default
+            const qualifierTypesResult = systemConfig
+                ? TsRes.Config.SystemConfiguration.create(systemConfig).onSuccess((config) => (0, ts_utils_1.succeed)(config.qualifierTypes))
+                : TsRes.QualifierTypes.QualifierTypeCollector.create({
+                    qualifierTypes: [
+                        TsRes.QualifierTypes.LanguageQualifierType.create().orThrow(),
+                        TsRes.QualifierTypes.TerritoryQualifierType.create().orThrow()
+                    ]
+                });
+            if (qualifierTypesResult.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to create qualifier types: ${qualifierTypesResult.message}`);
+            }
+            // Create context provider - use empty context for default
+            const contextProvider = TsRes.Runtime.ValidatingSimpleContextQualifierProvider.create({
+                qualifiers: finalManager.qualifiers,
+                qualifierValues: {} // Empty context for most general resolution
+            });
+            if (contextProvider.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to create context provider: ${contextProvider.message}`);
+            }
+            // Create resolver with required parameters
+            const resolver = TsRes.Runtime.ResourceResolver.create({
+                resourceManager: builtManager.value,
+                qualifierTypes: qualifierTypesResult.value,
+                contextQualifierProvider: contextProvider.value
+            });
+            if (resolver.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to create resource resolver: ${resolver.message}`);
+            }
+            return (0, ts_utils_1.succeed)(resolver.value);
+        }
+        catch (error) {
+            return (0, ts_utils_1.fail)(`Failed to create resource resolver: ${error}`);
+        }
+    }
+    /**
+     * Generates output blob for delta resources
+     */
+    async _generateDeltaBlob(deltaManager, options, systemConfig) {
+        try {
+            if (options.format === 'compiled') {
+                return deltaManager.getCompiledResourceCollection().onSuccess((compiled) => {
+                    const blob = {
+                        compiledCollection: compiled
+                    };
+                    if (options.includeMetadata) {
+                        blob.metadata = this._generateDeltaResourceInfo(deltaManager);
+                    }
+                    return (0, ts_utils_1.succeed)(blob);
+                });
+            }
+            else if (options.format === 'bundle') {
+                // Create bundle using BundleBuilder
+                const systemConfigResult = TsRes.Config.SystemConfiguration.create(systemConfig);
+                if (systemConfigResult.isFailure()) {
+                    return (0, ts_utils_1.fail)(`Failed to create system configuration for bundle: ${systemConfigResult.message}`);
+                }
+                const bundleParams = {
+                    version: '1.0.0',
+                    description: 'Generated delta bundle from ts-res-cli',
+                    normalize: true
+                };
+                return TsRes.Bundle.BundleBuilder.create(deltaManager, systemConfigResult.value, bundleParams).onSuccess((bundle) => {
+                    const blob = {
+                        bundle
+                    };
+                    if (options.includeMetadata) {
+                        blob.metadata = this._generateDeltaResourceInfo(deltaManager);
+                    }
+                    return (0, ts_utils_1.succeed)(blob);
+                });
+            }
+            else {
+                // Source format
+                return deltaManager.getResourceCollectionDecl().onSuccess((resources) => {
+                    const blob = {
+                        resources
+                    };
+                    if (options.includeMetadata) {
+                        blob.metadata = this._generateDeltaResourceInfo(deltaManager);
+                    }
+                    return (0, ts_utils_1.succeed)(blob);
+                });
+            }
+        }
+        catch (error) {
+            return (0, ts_utils_1.fail)(`Failed to generate delta blob: ${error}`);
+        }
+    }
+    /**
+     * Generates resource information for delta output
+     */
+    _generateDeltaResourceInfo(deltaManager) {
+        const resourceTypes = Array.from(new Set(deltaManager
+            .getAllCandidates()
+            .map((c) => { var _a; return (_a = c.resourceType) === null || _a === void 0 ? void 0 : _a.key; })
+            .filter(Boolean)));
+        const qualifiers = Array.from(deltaManager.qualifiers.keys());
+        return {
+            totalResources: deltaManager.numResources,
+            totalCandidates: deltaManager.numCandidates,
+            resourceTypes,
+            qualifiers
+        };
+    }
+    /**
+     * Writes delta output to file
+     */
+    async _writeDeltaOutput(blob, options) {
+        try {
+            const path = await Promise.resolve().then(() => __importStar(require('path')));
+            const fs = await Promise.resolve().then(() => __importStar(require('fs'))).then((m) => m.promises);
+            const outputPath = path.resolve(options.output);
+            const outputDir = path.dirname(outputPath);
+            // Ensure output directory exists
+            await fs.mkdir(outputDir, { recursive: true });
+            let content;
+            switch (options.format) {
+                case 'compiled':
+                    const compiledData = 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':
+                    const binaryData = blob.compiledCollection || blob;
+                    content = JSON.stringify(binaryData);
+                    break;
+                case 'bundle':
+                    const bundleData = options.includeMetadata ? blob : blob.bundle;
+                    content = JSON.stringify(bundleData, null, 2);
+                    break;
+                default:
+                    return (0, ts_utils_1.fail)(`Unsupported output format: ${options.format}`);
+            }
+            await fs.writeFile(outputPath, content, 'utf-8');
+            return (0, ts_utils_1.succeed)(undefined);
+        }
+        catch (error) {
+            return (0, ts_utils_1.fail)(`Failed to write delta output: ${error}`);
+        }
+    }
 }
 exports.TsResCliApp = TsResCliApp;
 //# sourceMappingURL=cli.js.map