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

package/lib/packlets/runtime/compiledResourceCollection.d.ts

@@ -7,7 +7,7 @@ import { QualifierType, QualifierTypeCollector } from '../qualifier-types';
 import { ResourceId } from '../common';
 import { IResourceManager, IResource } from './iResourceManager';
 import * as ResourceJson from '../resource-json';
-import { IReadOnlyResourceTreeRoot } from './resource-tree';
+import { ReadOnlyResourceTreeRoot } from './resource-tree';
 import * as Context from '../context';
 /**
  * Interface for parameters to create a {@link Runtime.CompiledResourceCollection | CompiledResourceCollection}.
@@ -33,7 +33,7 @@ export interface ICompiledResourceCollectionCreateParams {
  * and use pre-compiled resource collections without rebuilding them from scratch.
  * @public
  */
-export declare class CompiledResourceCollection implements IResourceManager {
+export declare class CompiledResourceCollection implements IResourceManager<IResource> {
     readonly conditions: ReadOnlyConditionCollector;
     readonly conditionSets: ReadOnlyConditionSetCollector;
     readonly decisions: ReadOnlyAbstractDecisionCollector;
@@ -105,7 +105,7 @@ export declare class CompiledResourceCollection implements IResourceManager {
      * @returns Result containing the resource tree root, or failure if tree construction fails
      * @public
      */
-    getBuiltResourceTree(): Result<IReadOnlyResourceTreeRoot<IResource>>;
+    getBuiltResourceTree(): Result<ReadOnlyResourceTreeRoot<IResource>>;
     /**
      * Reconstructs a QualifierTypeCollector from compiled data.
      * @param compiled - The compiled resource collection

package/lib/packlets/runtime/compiledResourceCollection.js

@@ -446,9 +446,16 @@ class CompiledResourceCollection {
                 continue;
             }
             const concreteDecision = concreteDecisionResult.value;
+            const { value: name, message: nameError } = common_1.Helpers.getNameForResourceId(compiledResource.id);
+            /* c8 ignore next 4 - defense in depth nearly impossible to reproduce */
+            if (nameError !== undefined) {
+                errors.addMessage(`Failed to get name for resource ${compiledResource.id}: ${nameError}`);
+                continue;
+            }
             // Create minimal resource that implements IResource
             const resource = {
                 id: compiledResource.id,
+                name,
                 resourceType,
                 decision: concreteDecision,
                 candidates

package/lib/packlets/runtime/iResourceManager.d.ts

@@ -3,8 +3,9 @@ import { JsonObject } from '@fgv/ts-json-base';
 import { ReadOnlyConditionCollector, ReadOnlyConditionSetCollector } from '../conditions';
 import { ReadOnlyAbstractDecisionCollector, ConcreteDecision } from '../decisions';
 import { ResourceId, ResourceValueMergeMethod } from '../common';
-import { ResourceType } from '../resource-types';
+import { IResourceType } from '../resource-types';
 import { IContextDecl, IValidatedContextDecl } from '../context';
+import { IReadOnlyResourceTreeRoot } from './resource-tree';
 /**
  * Runtime representation of a resource candidate with the minimal data needed for resolution.
  * @public
@@ -30,8 +31,10 @@ export interface IResourceCandidate {
 export interface IResource {
     /** The resource identifier */
     readonly id: string;
+    /** The resource name */
+    readonly name: string;
     /** The resource type */
-    readonly resourceType: ResourceType;
+    readonly resourceType: IResourceType;
     /** The decision used to select candidates */
     readonly decision: ConcreteDecision;
     /** The available candidates for this resource */
@@ -43,7 +46,7 @@ export interface IResource {
  * implementations without requiring the full ResourceManagerBuilder build mechanics.
  * @public
  */
-export interface IResourceManager {
+export interface IResourceManager<TR extends IResource = IResource> {
     /**
      * A {@link Conditions.ReadOnlyConditionCollector | ReadOnlyConditionCollector} which
      * contains the {@link Conditions.Condition | conditions} used by resource candidates.
@@ -64,12 +67,17 @@ export interface IResourceManager {
      * @param id - The resource identifier
      * @returns Success with the runtime resource if found, Failure otherwise
      */
-    getBuiltResource(id: string): Result<IResource>;
+    getBuiltResource(id: string): Result<TR>;
+    /**
+     * Gets a resource tree built from the resources in this resource manager.
+     * @returns Result containing the resource tree root, or failure if tree construction fails
+     */
+    getBuiltResourceTree(): Result<IReadOnlyResourceTreeRoot<TR>>;
     /**
      * A read-only result map of all built resources, keyed by resource ID.
      * Resources are built on-demand when accessed and returns Results for error handling.
      */
-    readonly builtResources: Collections.IReadOnlyValidatingResultMap<ResourceId, IResource>;
+    readonly builtResources: Collections.IReadOnlyValidatingResultMap<ResourceId, TR>;
     /**
      * The number of resources in this resource manager.
      */

package/lib/packlets/runtime/resource-tree/resourceTreeChildrenValidator.d.ts

@@ -14,7 +14,7 @@ import { IReadOnlyResourceTreeBranch, IReadOnlyResourceTreeChildren, IReadOnlyRe
  * strongly-typed internal tree operations, ensuring type safety and consistent
  * error handling throughout the resource tree navigation.
  *
- * @internal
+ * @public
  */
 export declare class ResourceTreeChildrenValidator<T> implements IReadOnlyResourceTreeChildren<T, string, string> {
     private readonly _inner;
@@ -69,17 +69,17 @@ export declare class ResourceTreeChildrenValidator<T> implements IReadOnlyResour
      */
     forEach(cb: (value: unknown, key: string, map: IReadOnlyResultMap<string, unknown>, thisArg?: unknown) => void, arg?: unknown): void;
     /**
-     * Gets a child node by its ResourceName key with detailed error information.
-     * @param key - The ResourceName key to look up
+     * Gets a child node by its string key with detailed error information.
+     * @param key - The string key to look up
      * @returns DetailedResult containing the node if found, or failure with details
      */
-    get(key: ResourceName): DetailedResult<IReadOnlyResourceTreeNode<T>, Collections.ResultMapResultDetail>;
+    get(key: string): DetailedResult<IReadOnlyResourceTreeNode<T>, Collections.ResultMapResultDetail>;
     /**
-     * Checks if a child node exists at the given ResourceName key.
-     * @param key - The ResourceName key to check
+     * Checks if a child node exists at the given string key.
+     * @param key - The string key to check
      * @returns True if a child node exists at the key, false otherwise
      */
-    has(key: ResourceName): boolean;
+    has(key: string): boolean;
     /**
      * Returns an iterator of ResourceName keys for all child nodes.
      * @returns Map iterator for all child node keys

package/lib/packlets/runtime/resource-tree/resourceTreeChildrenValidator.js

@@ -37,7 +37,7 @@ const ts_utils_1 = require("@fgv/ts-utils");
  * strongly-typed internal tree operations, ensuring type safety and consistent
  * error handling throughout the resource tree navigation.
  *
- * @internal
+ * @public
  */
 class ResourceTreeChildrenValidator {
     /**
@@ -121,8 +121,8 @@ class ResourceTreeChildrenValidator {
         }
     }
     /**
-     * Gets a child node by its ResourceName key with detailed error information.
-     * @param key - The ResourceName key to look up
+     * Gets a child node by its string key with detailed error information.
+     * @param key - The string key to look up
      * @returns DetailedResult containing the node if found, or failure with details
      */
     get(key) {
@@ -132,8 +132,8 @@ class ResourceTreeChildrenValidator {
         return (0, ts_utils_1.failWithDetail)(`${key}: invalid resource name.`, 'invalid-key');
     }
     /**
-     * Checks if a child node exists at the given ResourceName key.
-     * @param key - The ResourceName key to check
+     * Checks if a child node exists at the given string key.
+     * @param key - The string key to check
      * @returns True if a child node exists at the key, false otherwise
      */
     has(key) {

package/lib/packlets/runtime/resourceResolver.d.ts

@@ -20,6 +20,19 @@ export type DecisionResolutionResult = {
     instanceIndices: ReadonlyArray<number>;
     defaultInstanceIndices: ReadonlyArray<number>;
 };
+/**
+ * Options for configuring a {@link Runtime.ResourceResolver | ResourceResolver}.
+ * @public
+ */
+export interface IResourceResolverOptions {
+    /**
+     * Controls whether null values in resource composition should suppress properties
+     * instead of setting them to null. When true, properties with null values from
+     * higher-priority partial candidates will be omitted from the final composed resource.
+     * @defaultValue false
+     */
+    suppressNullAsDelete?: boolean;
+}
 /**
  * Parameters for creating a {@link Runtime.ResourceResolver | ResourceResolver}.
  * @public
@@ -44,6 +57,10 @@ export interface IResourceResolverCreateParams {
      * An optional listener for {@link Runtime.ResourceResolver | ResourceResolver} cache activity.
      */
     listener?: IResourceResolverCacheListener;
+    /**
+     * Optional configuration options for the {@link Runtime.ResourceResolver | ResourceResolver}.
+     */
+    options?: IResourceResolverOptions;
 }
 /**
  * High-performance runtime resource resolver with O(1) condition caching.
@@ -64,6 +81,10 @@ export declare class ResourceResolver {
      * The context qualifier provider that resolves qualifier values.
      */
     readonly contextQualifierProvider: IContextQualifierProvider;
+    /**
+     * The configuration options for this resource resolver.
+     */
+    readonly options: IResourceResolverOptions;
     /**
      * The cache array for resolved conditions, indexed by condition index for O(1) lookup.
      * Each entry stores the resolved {@link Runtime.IConditionMatchResult | condition match result} for

package/lib/packlets/runtime/resourceResolver.js

@@ -61,9 +61,13 @@ class ResourceResolver {
      * @param params - {@link Runtime.IResourceResolverCreateParams | Parameters} used to create the resolver.
      */
     constructor(params) {
+        var _a, _b;
         this.resourceManager = params.resourceManager;
         this.qualifierTypes = params.qualifierTypes;
         this.contextQualifierProvider = params.contextQualifierProvider;
+        this.options = {
+            suppressNullAsDelete: (_b = (_a = params.options) === null || _a === void 0 ? void 0 : _a.suppressNullAsDelete) !== null && _b !== void 0 ? _b : false
+        };
         // Initialize condition cache array with size matching the condition collector
         const conditionCollectorSize = this.resourceManager.conditions.size;
         this._conditionCache = new Array(conditionCollectorSize);
@@ -94,7 +98,7 @@ class ResourceResolver {
      * @public
      */
     resolveCondition(condition) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         // Get the condition's index for cache lookup
         const conditionIndex = condition.index;
         if (conditionIndex === undefined) {
@@ -107,16 +111,20 @@ class ResourceResolver {
             return (0, ts_utils_1.succeed)(cachedResult);
         }
         // Resolve the condition by getting qualifier value and evaluating with qualifier type
-        const qualifierValueResult = this.contextQualifierProvider.get(condition.qualifier);
-        if (qualifierValueResult.isFailure()) {
-            (_b = this._listener) === null || _b === void 0 ? void 0 : _b.onCacheError('condition', conditionIndex);
-            return (0, ts_utils_1.fail)(`Failed to get qualifier value for "${condition.qualifier.name}": ${qualifierValueResult.message}`);
-        }
-        const qualifierValue = qualifierValueResult.value;
-        // Evaluate the condition using the qualifier type's matching logic
-        const score = condition.qualifier.type.matches(condition.value, qualifierValue, condition.operator);
+        const score = this.contextQualifierProvider
+            .get(condition.qualifier)
+            .onSuccess((qualifierValue) => {
+            // Evaluate the condition using the qualifier type's matching logic
+            return (0, ts_utils_1.succeed)(condition.qualifier.type.matches(condition.value, qualifierValue, condition.operator));
+        })
+            .onFailure((err) => {
+            var _a;
+            (_a = this._listener) === null || _a === void 0 ? void 0 : _a.onContextError(condition.qualifier.name, err);
+            return (0, ts_utils_1.fail)(err);
+        })
+            .orDefault(common_1.NoMatch);
         const priority = condition.priority;
-        const scoreAsDefault = (_c = condition.scoreAsDefault) !== null && _c !== void 0 ? _c : common_1.NoMatch;
+        const scoreAsDefault = (_b = condition.scoreAsDefault) !== null && _b !== void 0 ? _b : common_1.NoMatch;
         const matchResult = score > common_1.NoMatch
             ? { score, priority, matchType: 'match' }
             : scoreAsDefault > common_1.NoMatch
@@ -124,7 +132,7 @@ class ResourceResolver {
                 : { score: common_1.NoMatch, priority, matchType: 'noMatch' };
         // Cache the resolved value for future O(1) lookup
         this._conditionCache[conditionIndex] = matchResult;
-        (_d = this._listener) === null || _d === void 0 ? void 0 : _d.onCacheMiss('condition', conditionIndex);
+        (_c = this._listener) === null || _c === void 0 ? void 0 : _c.onCacheMiss('condition', conditionIndex);
         return (0, ts_utils_1.succeed)(matchResult);
     }
     /**
@@ -153,8 +161,8 @@ class ResourceResolver {
         let matchType = 'match';
         for (const condition of conditionSet.conditions) {
             const { value: conditionResult, message: conditionMessage } = this.resolveCondition(condition);
+            /* c8 ignore next 4 - defensive coding: extreme internal error scenario not reachable in normal operation */
             if (conditionMessage !== undefined) {
-                /* c8 ignore next 2 - defensive coding: extreme internal error scenario not reachable in normal operation */
                 (_b = this._listener) === null || _b === void 0 ? void 0 : _b.onCacheError('conditionSet', conditionSetIndex);
                 return (0, ts_utils_1.fail)(`Failed to resolve condition "${condition.key}": ${conditionMessage}`);
             }
@@ -223,8 +231,8 @@ class ResourceResolver {
         for (let instanceIndex = 0; instanceIndex < decision.candidates.length; instanceIndex++) {
             const candidate = decision.candidates[instanceIndex];
             const conditionSetResult = this.resolveConditionSet(candidate.conditionSet);
+            /* c8 ignore next 4 - defensive coding: extreme internal error scenario not reachable in normal operation */
             if (conditionSetResult.isFailure()) {
-                /* c8 ignore next 2 - defensive coding: extreme internal error scenario not reachable in normal operation */
                 (_b = this._listener) === null || _b === void 0 ? void 0 : _b.onCacheError('decision', decisionIndex);
                 return (0, ts_utils_1.fail)(`${decision.key}: Failed to resolve condition set": ${conditionSetResult.message}`);
             }
@@ -370,9 +378,22 @@ class ResourceResolver {
             // If no full candidate found, use the last candidate as the base
             const baseCandidateIndex = fullCandidateIndex >= 0 ? fullCandidateIndex : candidates.length - 1;
             const baseCandidate = candidates[baseCandidateIndex];
-            // If there are no partial candidates to merge, return the base candidate's value
+            // If there are no partial candidates to merge, but null-as-delete is enabled,
+            // still process through JsonEditor to handle null properties in the base candidate
             if (partialCandidates.length === 0) {
-                return (0, ts_utils_1.succeed)(baseCandidate.json);
+                if (this.options.suppressNullAsDelete || !(0, ts_json_base_1.isJsonObject)(baseCandidate.json)) {
+                    return (0, ts_utils_1.succeed)(baseCandidate.json);
+                }
+                // Process single candidate through JsonEditor to apply null-as-delete
+                const editor = ts_json_1.JsonEditor.create({
+                    merge: {
+                        arrayMergeBehavior: 'replace',
+                        nullAsDelete: true
+                    }
+                }).orThrow(); // Should never fail with valid options
+                return editor
+                    .mergeObjectsInPlace({}, [baseCandidate.json])
+                    .withErrorFormat((err) => `${resource.id}: Composition failed: ${err}`);
             }
             const allCandidates = [
                 baseCandidate.json,
@@ -382,10 +403,11 @@ class ResourceResolver {
             if (allCandidates.length !== partialCandidates.length + 1) {
                 return (0, ts_utils_1.fail)(`${resource.id}: Unable to compose non-object candidate values.`);
             }
-            // Create JsonEditor with array replacement behavior for resource composition
+            // Create JsonEditor with array replacement behavior and null-as-delete for resource composition
             const editor = ts_json_1.JsonEditor.create({
                 merge: {
-                    arrayMergeBehavior: 'replace'
+                    arrayMergeBehavior: 'replace',
+                    nullAsDelete: !this.options.suppressNullAsDelete
                 }
             }).orThrow(); // Should never fail with valid options
             return editor

package/lib/packlets/runtime/validate.js

@@ -42,6 +42,7 @@ exports.resourceCandidate = ts_utils_1.Validators.object({
  */
 exports.resource = ts_utils_1.Validators.object({
     id: ts_utils_1.Validators.isA('ResourceId', (v) => typeof v === 'string' && common_1.Validate.isValidResourceId(v)),
+    name: ts_utils_1.Validators.isA('ResourceName', (v) => typeof v === 'string' && common_1.Validate.isValidResourceName(v)),
     resourceType: ts_utils_1.Validators.isA('ResourceType instance', (v) => v instanceof resource_types_1.ResourceType),
     decision: ts_utils_1.Validators.isA('ConcreteDecision instance', (v) => v instanceof decisions_1.ConcreteDecision),
     candidates: ts_utils_1.Validators.arrayOf(exports.resourceCandidate)

package/lib/packlets/zip-archive/convert.d.ts

@@ -0,0 +1,52 @@
+import { Validator, Converter } from '@fgv/ts-utils';
+import * as Json from './json';
+import { Model as ConfigModel } from '../config';
+/**
+ * Validator for ZIP archive input type
+ * @public
+ */
+export declare const zipArchiveInputType: Validator<'file' | 'directory'>;
+/**
+ * Validator for ZIP archive config type
+ * @public
+ */
+export declare const zipArchiveConfigType: Validator<'file'>;
+/**
+ * Validator for ZIP archive input information
+ * @public
+ */
+export declare const zipArchiveInputInfo: Validator<Json.IZipArchiveInputInfo>;
+/**
+ * Validator for ZIP archive config information
+ * @public
+ */
+export declare const zipArchiveConfigInfo: Validator<Json.IZipArchiveConfigInfo>;
+/**
+ * Validator for ZIP archive manifest
+ * Compatible with existing tools from ts-res-browser-cli
+ * @public
+ */
+export declare const zipArchiveManifest: Validator<Json.IZipArchiveManifest>;
+/**
+ * Validator for MIME type strings
+ * @public
+ */
+export declare const mimeType: Validator<string>;
+/**
+ * Converter for imported file
+ * @public
+ */
+export declare const importedFile: Converter<Json.IImportedFile>;
+/**
+ * Converter for imported directory structure (recursive)
+ * Note: Uses Converter pattern because Validators don't support recursion with self parameter
+ * @public
+ */
+export declare const importedDirectory: Converter<Json.IImportedDirectory>;
+/**
+ * Validator for system configuration (delegates to config packlet)
+ * This validates that the parsed JSON conforms to the system configuration schema
+ * @public
+ */
+export declare const systemConfiguration: Validator<ConfigModel.ISystemConfiguration>;
+//# sourceMappingURL=convert.d.ts.map

package/lib/packlets/zip-archive/convert.js

@@ -0,0 +1,104 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.systemConfiguration = exports.importedDirectory = exports.importedFile = exports.mimeType = exports.zipArchiveManifest = exports.zipArchiveConfigInfo = exports.zipArchiveInputInfo = exports.zipArchiveConfigType = exports.zipArchiveInputType = void 0;
+/* eslint-disable @rushstack/typedef-var */
+const ts_utils_1 = require("@fgv/ts-utils");
+const config_1 = require("../config");
+/**
+ * Validator for ZIP archive input type
+ * @public
+ */
+exports.zipArchiveInputType = ts_utils_1.Validators.enumeratedValue([
+    'file',
+    'directory'
+]);
+/**
+ * Validator for ZIP archive config type
+ * @public
+ */
+exports.zipArchiveConfigType = ts_utils_1.Validators.enumeratedValue(['file']);
+/**
+ * Validator for ZIP archive input information
+ * @public
+ */
+exports.zipArchiveInputInfo = ts_utils_1.Validators.object({
+    type: exports.zipArchiveInputType,
+    originalPath: ts_utils_1.Validators.string,
+    archivePath: ts_utils_1.Validators.string
+});
+/**
+ * Validator for ZIP archive config information
+ * @public
+ */
+exports.zipArchiveConfigInfo = ts_utils_1.Validators.object({
+    type: exports.zipArchiveConfigType,
+    originalPath: ts_utils_1.Validators.string,
+    archivePath: ts_utils_1.Validators.string
+});
+/**
+ * Validator for ZIP archive manifest
+ * Compatible with existing tools from ts-res-browser-cli
+ * @public
+ */
+exports.zipArchiveManifest = ts_utils_1.Validators.object({
+    timestamp: ts_utils_1.Validators.string,
+    input: exports.zipArchiveInputInfo.optional(),
+    config: exports.zipArchiveConfigInfo.optional()
+});
+/**
+ * Validator for MIME type strings
+ * @public
+ */
+exports.mimeType = ts_utils_1.Validators.string;
+/**
+ * Converter for imported file
+ * @public
+ */
+exports.importedFile = ts_utils_1.Converters.strictObject({
+    name: ts_utils_1.Converters.string,
+    path: ts_utils_1.Converters.string,
+    content: ts_utils_1.Converters.string,
+    type: ts_utils_1.Converters.string // MIME type as string
+});
+/**
+ * Converter for imported directory structure (recursive)
+ * Note: Uses Converter pattern because Validators don't support recursion with self parameter
+ * @public
+ */
+exports.importedDirectory = ts_utils_1.Converters.generic((from, self, context) => {
+    return ts_utils_1.Converters.strictObject({
+        name: ts_utils_1.Converters.string,
+        files: ts_utils_1.Converters.arrayOf(exports.importedFile),
+        subdirectories: ts_utils_1.Converters.arrayOf(self)
+    }).convert(from, context);
+});
+/**
+ * Validator for system configuration (delegates to config packlet)
+ * This validates that the parsed JSON conforms to the system configuration schema
+ * @public
+ */
+exports.systemConfiguration = ts_utils_1.Validators.isA('system configuration', (value) => {
+    return config_1.Convert.systemConfiguration.convert(value).isSuccess();
+});
+//# sourceMappingURL=convert.js.map

package/lib/packlets/zip-archive/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ZIP archive functionality for ts-res source file archives
+ *
+ * This packlet provides consolidated ZIP archive creation and loading functionality
+ * for source files, compatible with existing tools while using fflate for
+ * universal browser compatibility.
+ *
+ * @remarks
+ * ZIP archives contain source files for resource ingestion with directory
+ * structure preserved and optional validation but no processing or transformation.
+ * This is distinct from ZIP bundles which contain processed resource output.
+ *
+ * @packageDocumentation
+ */
+import * as Json from './json';
+import * as Convert from './convert';
+export { Json, Convert };
+export { ZipArchiveCreator } from './zipArchiveCreator';
+export { ZipArchiveLoader } from './zipArchiveLoader';
+export type { IZipArchivePathOptions, IZipArchiveFileTreeOptions, ZipArchiveOptions, IZipArchiveResult, IZipArchiveManifest, IZipArchiveLoadOptions, IZipArchiveLoadResult, IImportedFile, IImportedDirectory, ZipArchiveProgressCallback } from './types';
+export { createZipArchiveManifest, parseZipArchiveManifest, validateZipArchiveManifest, parseZipArchiveConfiguration, generateZipArchiveFilename, normalizePath, getDirectoryName, sanitizeFilename, isZipFile } from './zipArchiveFormat';
+export { ZipArchiveConstants } from './types';
+//# sourceMappingURL=index.d.ts.map

package/lib/packlets/zip-archive/index.js

@@ -0,0 +1,95 @@
+"use strict";
+/*
+ * 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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZipArchiveConstants = exports.isZipFile = exports.sanitizeFilename = exports.getDirectoryName = exports.normalizePath = exports.generateZipArchiveFilename = exports.parseZipArchiveConfiguration = exports.validateZipArchiveManifest = exports.parseZipArchiveManifest = exports.createZipArchiveManifest = exports.ZipArchiveLoader = exports.ZipArchiveCreator = exports.Convert = exports.Json = void 0;
+/**
+ * ZIP archive functionality for ts-res source file archives
+ *
+ * This packlet provides consolidated ZIP archive creation and loading functionality
+ * for source files, compatible with existing tools while using fflate for
+ * universal browser compatibility.
+ *
+ * @remarks
+ * ZIP archives contain source files for resource ingestion with directory
+ * structure preserved and optional validation but no processing or transformation.
+ * This is distinct from ZIP bundles which contain processed resource output.
+ *
+ * @packageDocumentation
+ */
+const Json = __importStar(require("./json"));
+exports.Json = Json;
+const Convert = __importStar(require("./convert"));
+exports.Convert = Convert;
+// Core classes
+var zipArchiveCreator_1 = require("./zipArchiveCreator");
+Object.defineProperty(exports, "ZipArchiveCreator", { enumerable: true, get: function () { return zipArchiveCreator_1.ZipArchiveCreator; } });
+var zipArchiveLoader_1 = require("./zipArchiveLoader");
+Object.defineProperty(exports, "ZipArchiveLoader", { enumerable: true, get: function () { return zipArchiveLoader_1.ZipArchiveLoader; } });
+// Format utilities
+var zipArchiveFormat_1 = require("./zipArchiveFormat");
+Object.defineProperty(exports, "createZipArchiveManifest", { enumerable: true, get: function () { return zipArchiveFormat_1.createZipArchiveManifest; } });
+Object.defineProperty(exports, "parseZipArchiveManifest", { enumerable: true, get: function () { return zipArchiveFormat_1.parseZipArchiveManifest; } });
+Object.defineProperty(exports, "validateZipArchiveManifest", { enumerable: true, get: function () { return zipArchiveFormat_1.validateZipArchiveManifest; } });
+Object.defineProperty(exports, "parseZipArchiveConfiguration", { enumerable: true, get: function () { return zipArchiveFormat_1.parseZipArchiveConfiguration; } });
+Object.defineProperty(exports, "generateZipArchiveFilename", { enumerable: true, get: function () { return zipArchiveFormat_1.generateZipArchiveFilename; } });
+Object.defineProperty(exports, "normalizePath", { enumerable: true, get: function () { return zipArchiveFormat_1.normalizePath; } });
+Object.defineProperty(exports, "getDirectoryName", { enumerable: true, get: function () { return zipArchiveFormat_1.getDirectoryName; } });
+Object.defineProperty(exports, "sanitizeFilename", { enumerable: true, get: function () { return zipArchiveFormat_1.sanitizeFilename; } });
+Object.defineProperty(exports, "isZipFile", { enumerable: true, get: function () { return zipArchiveFormat_1.isZipFile; } });
+// Constants
+var types_1 = require("./types");
+Object.defineProperty(exports, "ZipArchiveConstants", { enumerable: true, get: function () { return types_1.ZipArchiveConstants; } });
+//# sourceMappingURL=index.js.map