@fgv/ts-res 5.0.1-8 → 5.0.1

package/dist/packlets/zip-archive/zipArchiveCreator.js

@@ -0,0 +1,191 @@
+/*
+ * 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 { zipSync } from 'fflate';
+import { succeed, fail } from '@fgv/ts-utils';
+import { FileTree } from '@fgv/ts-json-base';
+import { normalizePath } from './zipArchiveFormat';
+/**
+ * ZIP archive creator using fflate for universal compatibility
+ * @public
+ */
+export class ZipArchiveCreator {
+    /**
+     * Create a ZIP archive buffer from a supplied buffer
+     * @param options - Input paths and configuration
+     * @param onProgress - Optional progress callback
+     * @returns Result containing ZIP buffer and manifest
+     */
+    async createFromBuffer(options, onProgress) {
+        try {
+            onProgress === null || onProgress === void 0 ? void 0 : onProgress('creating-zip', 0, 'Starting ZIP archive creation');
+            const files = {};
+            const manifest = {
+                timestamp: new Date().toISOString()
+            };
+            const { value: inputItem, message: inputItemError } = this._getInputFileTreeItem(options);
+            if (inputItemError !== undefined) {
+                return fail(inputItemError);
+            }
+            if (inputItem !== undefined) {
+                onProgress === null || onProgress === void 0 ? void 0 : onProgress('reading-file', 10, `Processing input: ${inputItem.absolutePath}`);
+                if (inputItem.type === 'directory') {
+                    // Add entire directory recursively, preserving structure
+                    const archivePath = `input/${inputItem.name}`;
+                    const addDirResult = await this._addDirectoryTreeToZip(files, inputItem, archivePath, onProgress);
+                    /* c8 ignore next 3 - defense in depth against internal error */
+                    if (addDirResult.isFailure()) {
+                        return fail(addDirResult.message);
+                    }
+                    manifest.input = {
+                        type: 'directory',
+                        originalPath: inputItem.absolutePath,
+                        archivePath
+                    };
+                }
+                else if (inputItem.type === 'file') {
+                    // Add single file
+                    const archivePath = `input/${inputItem.name}`;
+                    const addFileResult = await this._addFileTreeItemToZip(files, inputItem, archivePath);
+                    /* c8 ignore next 3 - defense in depth against internal error */
+                    if (addFileResult.isFailure()) {
+                        return fail(addFileResult.message);
+                    }
+                    manifest.input = {
+                        type: 'file',
+                        originalPath: inputItem.absolutePath,
+                        archivePath
+                    };
+                }
+            }
+            const { value: configItem, message: configItemError } = this._getConfigFileTreeItem(options);
+            if (configItemError !== undefined) {
+                return fail(configItemError);
+            }
+            if (configItem !== undefined) {
+                onProgress === null || onProgress === void 0 ? void 0 : onProgress('reading-file', 40, `Processing config: ${configItem.absolutePath}`);
+                const archivePath = `config/${configItem.name}`;
+                const addConfigResult = await this._addFileTreeItemToZip(files, configItem, archivePath);
+                /* c8 ignore next 3 - defense in depth against internal error */
+                if (addConfigResult.isFailure()) {
+                    return fail(addConfigResult.message);
+                }
+                // Update manifest with config info
+                manifest.config = {
+                    type: 'file',
+                    originalPath: configItem.absolutePath,
+                    archivePath
+                };
+            }
+            // Add manifest to ZIP
+            onProgress === null || onProgress === void 0 ? void 0 : onProgress('creating-zip', 70, 'Adding manifest');
+            const manifestJson = JSON.stringify(manifest, null, 2);
+            files['manifest.json'] = new TextEncoder().encode(manifestJson);
+            // Create ZIP buffer using fflate
+            onProgress === null || onProgress === void 0 ? void 0 : onProgress('creating-zip', 80, 'Compressing files');
+            const zipBuffer = zipSync(files, { level: 6 });
+            const result = {
+                zipBuffer,
+                manifest,
+                size: zipBuffer.length
+            };
+            onProgress === null || onProgress === void 0 ? void 0 : onProgress('creating-zip', 100, 'ZIP archive buffer created');
+            return succeed(result);
+            /* c8 ignore next 3 - defense in depth against internal error */
+        }
+        catch (error) {
+            return fail(`Failed to create ZIP archive: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Add a single FileTree item to the ZIP archive
+     * @param files - ZIP files collection
+     * @param fileItem - FileTree file item to add
+     * @param archivePath - Path within the archive
+     * @returns Result indicating success or failure
+     */
+    async _addFileTreeItemToZip(files, fileItem, archivePath) {
+        return fileItem.getRawContents().onSuccess((content) => {
+            const contentBuffer = new TextEncoder().encode(content);
+            files[normalizePath(archivePath)] = contentBuffer;
+            return succeed(undefined);
+        });
+    }
+    /**
+     * Add a directory recursively to the ZIP archive using FileTree
+     * @param files - ZIP files collection
+     * @param directoryItem - FileTree directory item to add
+     * @param archivePrefix - Prefix path within the archive
+     * @param onProgress - Optional progress callback
+     * @returns Result indicating success or failure
+     */
+    async _addDirectoryTreeToZip(files, directoryItem, archivePrefix, onProgress) {
+        const childrenResult = directoryItem.getChildren();
+        /* c8 ignore next 3 - defense in depth against internal error */
+        if (childrenResult.isFailure()) {
+            return fail(`Failed to read directory ${directoryItem.absolutePath}: ${childrenResult.message}`);
+        }
+        for (const child of childrenResult.value) {
+            const itemArchivePath = normalizePath(`${archivePrefix}/${child.name}`);
+            if (child.type === 'directory') {
+                // Recursively add subdirectory
+                const addDirResult = await this._addDirectoryTreeToZip(files, child, itemArchivePath, onProgress);
+                /* c8 ignore next 3 - defense in depth against internal error */
+                if (addDirResult.isFailure()) {
+                    return fail(addDirResult.message);
+                }
+            }
+            else if (child.type === 'file') {
+                // Add file
+                const addFileResult = await this._addFileTreeItemToZip(files, child, itemArchivePath);
+                /* c8 ignore next 3 - defense in depth against internal error */
+                if (addFileResult.isFailure()) {
+                    return fail(addFileResult.message);
+                }
+                onProgress === null || onProgress === void 0 ? void 0 : onProgress('reading-file', 0, `Added file: ${itemArchivePath}`);
+            }
+        }
+        return succeed(undefined);
+    }
+    _getInputFileTreeItem(options) {
+        if ('inputPath' in options && options.inputPath !== undefined) {
+            return FileTree.forFilesystem()
+                .withErrorFormat((msg) => `Failed to create file tree: ${msg}`)
+                .onSuccess((fileTree) => fileTree.getItem(options.inputPath).withErrorFormat((msg) => `Failed to get item: ${msg}`));
+        }
+        else if ('inputItem' in options) {
+            return succeed(options.inputItem);
+        }
+        return succeed(undefined);
+    }
+    _getConfigFileTreeItem(options) {
+        if ('configPath' in options && options.configPath !== undefined) {
+            return FileTree.forFilesystem()
+                .withErrorFormat((msg) => `Failed to create file tree: ${msg}`)
+                .onSuccess((fileTree) => fileTree.getFile(options.configPath).withErrorFormat((msg) => `Failed to get config file: ${msg}`));
+        }
+        else if ('configItem' in options && options.configItem !== undefined) {
+            return succeed(options.configItem);
+        }
+        return succeed(undefined);
+    }
+}
+//# sourceMappingURL=zipArchiveCreator.js.map

package/dist/packlets/zip-archive/zipArchiveFormat.js

@@ -0,0 +1,140 @@
+/*
+ * 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 { captureResult } from '@fgv/ts-utils';
+import * as Convert from './convert';
+/**
+ * Create a ZIP archive manifest object
+ * @param inputType - Type of input (file or directory)
+ * @param originalPath - Original file/directory path
+ * @param archivePath - Path within the archive
+ * @param configPath - Optional configuration file path
+ * @returns ZIP archive manifest
+ * @public
+ */
+export function createZipArchiveManifest(inputType, originalPath, archivePath, configPath) {
+    const manifest = {
+        timestamp: new Date().toISOString(),
+        input: {
+            type: inputType,
+            originalPath,
+            archivePath
+        }
+    };
+    if (configPath) {
+        manifest.config = {
+            type: 'file',
+            originalPath: configPath,
+            archivePath: 'config.json'
+        };
+    }
+    return manifest;
+}
+/**
+ * Parse and validate a ZIP archive manifest
+ * @param manifestData - JSON string containing manifest data
+ * @returns Result containing validated manifest
+ * @public
+ */
+export function parseZipArchiveManifest(manifestData) {
+    return captureResult(() => {
+        const parsed = JSON.parse(manifestData);
+        return parsed;
+    })
+        .onSuccess((parsed) => Convert.zipArchiveManifest.validate(parsed))
+        .withErrorFormat((e) => `Failed to parse ZIP archive manifest: ${e}`);
+}
+/**
+ * Validate a ZIP archive manifest object
+ * @param manifest - Object to validate as manifest
+ * @returns Result containing validated manifest
+ * @public
+ */
+export function validateZipArchiveManifest(manifest) {
+    return Convert.zipArchiveManifest.validate(manifest);
+}
+/**
+ * Parse and validate configuration JSON
+ * @param configData - JSON string containing configuration
+ * @returns Result containing validated configuration
+ * @public
+ */
+export function parseZipArchiveConfiguration(configData) {
+    return captureResult(() => {
+        const parsed = JSON.parse(configData);
+        return parsed;
+    })
+        .onSuccess((parsed) => Convert.systemConfiguration.validate(parsed))
+        .withErrorFormat((e) => `Failed to parse ZIP archive configuration: ${e}`);
+}
+/**
+ * Generate a timestamp-based filename for ZIP archives
+ * @param customName - Optional custom name prefix
+ * @returns Generated filename
+ * @public
+ */
+export function generateZipArchiveFilename(customName) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').replace('T', '_').slice(0, -5);
+    return customName ? `${customName}-${timestamp}.zip` : `ts-res-archive-${timestamp}.zip`;
+}
+/**
+ * Normalize path separators for cross-platform compatibility
+ * @param path - Path to normalize
+ * @returns Normalized path
+ * @public
+ */
+export function normalizePath(path) {
+    return path.replace(/\\/g, '/').replace(/\/+/g, '/');
+}
+/**
+ * Extract directory name from a file path
+ * @param path - File path
+ * @returns Directory name
+ * @public
+ */
+export function getDirectoryName(path) {
+    const normalized = normalizePath(path);
+    const parts = normalized.split('/');
+    return parts[parts.length - 1] || 'archive';
+}
+/**
+ * Create a safe filename by removing invalid characters
+ * @param filename - Original filename
+ * @returns Sanitized filename
+ * @public
+ */
+export function sanitizeFilename(filename) {
+    return filename
+        .replace(/[<>:"/\\|?*]/g, '_')
+        .replace(/\s+/g, '_')
+        .replace(/_+/g, '_')
+        .trim();
+}
+/**
+ * Validate ZIP file extension
+ * @param filename - Filename to validate
+ * @returns True if filename has .zip extension
+ * @public
+ */
+export function isZipFile(filename) {
+    return filename.toLowerCase().endsWith('.zip');
+}
+//# sourceMappingURL=zipArchiveFormat.js.map

package/dist/packlets/zip-archive/zipArchiveLoader.js

@@ -0,0 +1,282 @@
+/*
+ * 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 { succeed, fail } from '@fgv/ts-utils';
+// ZipFileTree is browser-safe - doesn't depend on Node.js crypto/fs modules
+import { ZipFileTree } from '@fgv/ts-extras';
+import { parseZipArchiveManifest, parseZipArchiveConfiguration, isZipFile } from './zipArchiveFormat';
+/**
+ * ZIP archive loader extending ts-extras foundation
+ * @public
+ */
+export class ZipArchiveLoader {
+    /**
+     * Load ZIP archive from File object (Browser)
+     * @param file - File object from file input
+     * @param options - Loading options
+     * @param onProgress - Optional progress callback
+     * @returns Result containing loaded archive data
+     */
+    async loadFromFile(file, options = {}, onProgress) {
+        onProgress === null || onProgress === void 0 ? void 0 : onProgress('reading-file', 0, `Reading file: ${file.name}`);
+        if (!isZipFile(file.name)) {
+            return fail(`File ${file.name} is not a ZIP file`);
+        }
+        try {
+            const buffer = await file.arrayBuffer();
+            onProgress === null || onProgress === void 0 ? void 0 : onProgress('reading-file', 100, 'File read complete');
+            return await this.loadFromBuffer(buffer, options, onProgress);
+            /* c8 ignore next 3 - defense in depth against internal error */
+        }
+        catch (error) {
+            return fail(`Failed to read file: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Load ZIP archive from ArrayBuffer (Universal)
+     * @param buffer - ZIP data buffer
+     * @param options - Loading options
+     * @param onProgress - Optional progress callback
+     * @returns Result containing loaded archive data
+     */
+    async loadFromBuffer(buffer, options = {}, onProgress) {
+        onProgress === null || onProgress === void 0 ? void 0 : onProgress('parsing-zip', 0, 'Parsing ZIP archive');
+        const zipAccessorsResult = ZipFileTree.ZipFileTreeAccessors.fromBuffer(buffer);
+        if (zipAccessorsResult.isFailure()) {
+            return fail(`Failed to parse ZIP: ${zipAccessorsResult.message}`);
+        }
+        const zipAccessors = zipAccessorsResult.value;
+        onProgress === null || onProgress === void 0 ? void 0 : onProgress('parsing-zip', 100, 'ZIP archive parsed');
+        // Load manifest
+        onProgress === null || onProgress === void 0 ? void 0 : onProgress('loading-manifest', 0, 'Loading manifest');
+        const manifestResult = this._loadManifestFromAccessors(zipAccessors);
+        if (manifestResult.isFailure()) {
+            return fail(manifestResult.message);
+        }
+        const manifest = manifestResult.value;
+        onProgress === null || onProgress === void 0 ? void 0 : onProgress('loading-manifest', 100, 'Manifest loaded');
+        // Load configuration
+        onProgress === null || onProgress === void 0 ? void 0 : onProgress('loading-config', 0, 'Loading configuration');
+        const configResult = this._loadConfigurationFromAccessors(zipAccessors, manifest, options);
+        if (configResult.isFailure()) {
+            return fail(configResult.message);
+        }
+        const config = configResult.value;
+        onProgress === null || onProgress === void 0 ? void 0 : onProgress('loading-config', 100, 'Configuration loaded');
+        // Extract files and directory structure
+        onProgress === null || onProgress === void 0 ? void 0 : onProgress('extracting-files', 0, 'Extracting files');
+        const filesResult = await this._extractFilesFromAccessors(zipAccessors, onProgress);
+        /* c8 ignore next 3 - defense in depth against internal error */
+        if (filesResult.isFailure()) {
+            return fail(filesResult.message);
+        }
+        const { files, directory } = filesResult.value;
+        onProgress === null || onProgress === void 0 ? void 0 : onProgress('extracting-files', 100, `Extracted ${files.length} files`);
+        onProgress === null || onProgress === void 0 ? void 0 : onProgress('extracting-files', 100, 'ZIP loading complete');
+        return succeed({
+            manifest,
+            config,
+            files,
+            directory
+        });
+    }
+    /**
+     * Load manifest from ZIP using ZipFileTreeAccessors
+     * @param zipAccessors - ZIP file tree accessors
+     * @returns Result containing parsed manifest
+     */
+    _loadManifestFromAccessors(zipAccessors) {
+        const manifestResult = zipAccessors.getFileContents('manifest.json');
+        if (manifestResult.isFailure()) {
+            // Manifest is optional - return success with undefined
+            return succeed(undefined);
+        }
+        const parseResult = parseZipArchiveManifest(manifestResult.value);
+        if (parseResult.isFailure()) {
+            return fail(`Failed to parse manifest.json: ${parseResult.message}`);
+        }
+        return succeed(parseResult.value);
+    }
+    /**
+     * Load configuration from ZIP using ZipFileTreeAccessors
+     * @param zipAccessors - ZIP file tree accessors
+     * @param manifest - Parsed manifest (may be undefined)
+     * @param options - Loading options
+     * @returns Result containing parsed configuration
+     */
+    _loadConfigurationFromAccessors(zipAccessors, manifest, options) {
+        // Check if manifest specifies a config file
+        const manifestSpecifiesConfig = (manifest === null || manifest === void 0 ? void 0 : manifest.config) !== undefined;
+        if (!manifestSpecifiesConfig) {
+            // If no config specified in manifest, config is optional
+            return succeed(undefined);
+        }
+        // Get the config path from the manifest
+        const configPath = manifest.config.archivePath;
+        return zipAccessors
+            .getFileContents(configPath)
+            .withErrorFormat(() => `Manifest specifies config file at '${configPath}' but it was not found in archive`)
+            .onSuccess((configContent) => parseZipArchiveConfiguration(configContent))
+            .withErrorFormat((e) => `Failed to parse config file '${configPath}': ${e}`);
+    }
+    /**
+     * Extract files and directory structure from ZIP
+     * @param zipAccessors - ZIP file tree accessors
+     * @param onProgress - Optional progress callback
+     * @returns Result containing files and directory structure
+     */
+    async _extractFilesFromAccessors(zipAccessors, onProgress) {
+        try {
+            const files = [];
+            const directories = new Map();
+            // Get all children from root
+            const rootChildrenResult = zipAccessors.getChildren('/');
+            /* c8 ignore next 3 - defense in depth against internal error */
+            if (rootChildrenResult.isFailure()) {
+                return fail(`Failed to read ZIP contents: ${rootChildrenResult.message}`);
+            }
+            // Process all items recursively
+            await this._processFileTreeItems(zipAccessors, '/', rootChildrenResult.value, files, directories, onProgress);
+            // Build directory structure
+            const directory = this._buildDirectoryStructure(files, directories);
+            return succeed({ files, directory });
+            /* c8 ignore next 3 - defense in depth against internal error */
+        }
+        catch (error) {
+            return fail(`Failed to extract files: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Recursively process file tree items
+     * @param zipAccessors - ZIP file tree accessors
+     * @param currentPath - Current directory path
+     * @param items - Items to process
+     * @param files - Files collection
+     * @param directories - Directories collection
+     * @param onProgress - Optional progress callback
+     * @param processed - Processing counter
+     */
+    async _processFileTreeItems(zipAccessors, currentPath, items, files, directories, onProgress, processed = { count: 0 }) {
+        for (const item of items) {
+            /* c8 ignore next 1 - defense in depth */
+            const itemPath = item.absolutePath.startsWith('/') ? item.absolutePath.substring(1) : item.absolutePath;
+            if (item.type === 'directory') {
+                // Track directory
+                if (!directories.has(itemPath)) {
+                    directories.set(itemPath, {
+                        name: item.name,
+                        files: [],
+                        subdirectories: []
+                    });
+                }
+                // Recursively process children
+                const childrenResult = zipAccessors.getChildren(item.absolutePath);
+                if (childrenResult.isSuccess()) {
+                    await this._processFileTreeItems(zipAccessors, item.absolutePath, childrenResult.value, files, directories, onProgress, processed);
+                }
+            }
+            else if (item.type === 'file') {
+                // Get file content
+                const contentResult = item.getRawContents();
+                const content = contentResult.orDefault('');
+                files.push({
+                    name: item.name,
+                    path: itemPath,
+                    content,
+                    type: this._getFileType(item.name)
+                });
+            }
+            processed.count++;
+            onProgress === null || onProgress === void 0 ? void 0 : onProgress('extracting-files', 0, `Processing ${itemPath}`);
+        }
+    }
+    /**
+     * Build directory structure from files
+     * @param files - Extracted files
+     * @param directories - Directories map
+     * @returns Root directory structure or null
+     */
+    _buildDirectoryStructure(files, directories) {
+        /* c8 ignore next 3 - should never happen with fflate */
+        if (files.length === 0) {
+            return undefined;
+        }
+        const rootDir = {
+            name: 'root',
+            files: [],
+            subdirectories: []
+        };
+        // Process files to build directory structure
+        for (const file of files) {
+            const pathParts = file.path.split('/').filter((part) => part.length > 0);
+            /* c8 ignore next 1 - defense in depth should never happen */
+            if (pathParts.length === 0)
+                continue;
+            // Ensure all parent directories exist
+            let currentDir = rootDir;
+            for (let i = 0; i < pathParts.length - 1; i++) {
+                const dirName = pathParts[i];
+                let foundDir = currentDir.subdirectories.find((d) => d.name === dirName);
+                if (!foundDir) {
+                    foundDir = {
+                        name: dirName,
+                        files: [],
+                        subdirectories: []
+                    };
+                    currentDir.subdirectories.push(foundDir);
+                }
+                currentDir = foundDir;
+            }
+            // Add file to its parent directory
+            currentDir.files.push(file);
+        }
+        return rootDir;
+    }
+    /**
+     * Get file MIME type based on extension
+     * @param filename - Filename
+     * @returns MIME type
+     */
+    _getFileType(filename) {
+        const ext = filename.toLowerCase().split('.').pop();
+        /* c8 ignore next 20 - no need to test every one */
+        switch (ext) {
+            case 'json':
+                return 'application/json';
+            case 'yaml':
+            case 'yml':
+                return 'application/yaml';
+            case 'xml':
+                return 'application/xml';
+            case 'txt':
+                return 'text/plain';
+            case 'md':
+                return 'text/markdown';
+            case 'js':
+                return 'application/javascript';
+            case 'ts':
+                return 'application/typescript';
+            default:
+                return 'application/octet-stream';
+        }
+    }
+}
+//# sourceMappingURL=zipArchiveLoader.js.map

package/dist/test/data/sample.json

@@ -0,0 +1,32 @@
+[
+  {
+    "id": "some.resource.path",
+    "json": { "home": "United States" },
+    "conditions": {
+      "homeTerritory": "US"
+    }
+  },
+  {
+    "id": "some.resource.path",
+    "json": { "speaks": "English" },
+    "conditions": {
+      "language": "en"
+    }
+  },
+  {
+    "id": "some.resource.path",
+    "json": { "home": "Canada", "speaks": "Canadian English" },
+    "conditions": {
+      "homeTerritory": "CA",
+      "language": "en-CA"
+    },
+    "mergeMethod": "replace"
+  },
+  {
+    "id": "some.resource.path",
+    "json": { "speaks": "Español" },
+    "conditions": {
+      "language": "es"
+    }
+  }
+]