@fgv/ts-res 5.0.1-8 → 5.0.1

package/dist/test/unit/qualifier-types/testQualifierType.js

@@ -0,0 +1,76 @@
+/*
+ * 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, fail, succeed } from '@fgv/ts-utils';
+import * as TsRes from '../../../index';
+export class TestQualifierType extends TsRes.QualifierTypes.QualifierType {
+    constructor(params) {
+        var _a;
+        super({
+            name: (_a = params === null || params === void 0 ? void 0 : params.name) !== null && _a !== void 0 ? _a : 'test',
+            allowContextList: (params === null || params === void 0 ? void 0 : params.allowContextList) === 'true',
+            index: params === null || params === void 0 ? void 0 : params.index
+        });
+        this.systemTypeName = TsRes.Convert.qualifierTypeName
+            .convert('test')
+            .orThrow();
+    }
+    static create(params) {
+        return captureResult(() => new TestQualifierType(params));
+    }
+    isValidConditionValue(value) {
+        return true;
+    }
+    validateCondition(value, operator) {
+        return this.isValidConditionValue(value) ? succeed(value) : fail(`Invalid condition value: ${value}`);
+    }
+    getConfigurationJson() {
+        return succeed({
+            name: this.name,
+            systemType: 'test',
+            configuration: {}
+        });
+    }
+    validateConfigurationJson(from) {
+        // Simple validation for test class
+        if (typeof from !== 'object' || from === null) {
+            return fail('Expected object');
+        }
+        const obj = from;
+        if (typeof obj.name !== 'string') {
+            return fail('name must be string');
+        }
+        if (obj.systemType !== 'test') {
+            return fail('systemType must be test');
+        }
+        return succeed(from);
+    }
+    _matchOne(condition, context, operator) {
+        if (condition === context) {
+            return TsRes.PerfectMatch;
+        }
+        if (condition.toLowerCase() === context.toLowerCase()) {
+            return 0.5;
+        }
+        return TsRes.NoMatch;
+    }
+}
+//# sourceMappingURL=testQualifierType.js.map

package/dist/test/unit/resource-types/testDerivedResourceType.js

@@ -0,0 +1,109 @@
+/*
+ * 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, fail, succeed } from '@fgv/ts-utils';
+import { Convert } from '../../../packlets/common';
+// eslint-disable-next-line @rushstack/packlets/mechanics
+import { ResourceType } from '../../../packlets/resource-types/resourceType';
+/**
+ * A derived resource type for testing that demonstrates:
+ * 1. Custom validation logic
+ * 2. Using a resource resolver to look up template values
+ * 3. Type-specific defaults and error handling
+ */
+export class TestDerivedResourceType extends ResourceType {
+    constructor(key, index, template, templateResourceId) {
+        super(key, index, template);
+        this.systemTypeName = Convert.resourceTypeName
+            .convert('test-derived')
+            .orThrow();
+        this._templateResourceId = templateResourceId;
+    }
+    /**
+     * Factory method to create a new TestDerivedResourceType instance.
+     */
+    static create(params) {
+        var _a;
+        return Convert.resourceTypeName.convert((_a = params === null || params === void 0 ? void 0 : params.key) !== null && _a !== void 0 ? _a : 'test-derived').onSuccess((key) => {
+            return captureResult(() => new TestDerivedResourceType(key, params === null || params === void 0 ? void 0 : params.index, params === null || params === void 0 ? void 0 : params.template, params === null || params === void 0 ? void 0 : params.templateResourceId));
+        });
+    }
+    /**
+     * Validates a resource candidate declaration with custom logic.
+     */
+    validateDeclaration(props) {
+        // Custom validation: merge method must be 'replace' for full candidates
+        if (props.completeness === 'full' && props.mergeMethod !== 'replace') {
+            return fail(`${this.key}: Full candidates must use 'replace' merge method, got '${props.mergeMethod}'`);
+        }
+        return this.validate(props.json, props.completeness);
+    }
+    validate(json, completeness) {
+        if (typeof json !== 'object' || json === null || Array.isArray(json)) {
+            return fail(`${this.key}: Expected JSON object, got ${typeof json}`);
+        }
+        const obj = json;
+        // Validate required title field for full resources
+        if (completeness === 'full' && (typeof obj.title !== 'string' || !obj.title.trim())) {
+            return fail(`${this.key}: 'title' field is required and must be a non-empty string`);
+        }
+        // Validate optional description
+        if (obj.description !== undefined && typeof obj.description !== 'string') {
+            return fail(`${this.key}: 'description' field must be a string if provided`);
+        }
+        // Validate optional metadata
+        if (obj.metadata !== undefined) {
+            if (typeof obj.metadata !== 'object' || obj.metadata === null || Array.isArray(obj.metadata)) {
+                return fail(`${this.key}: 'metadata' field must be an object if provided`);
+            }
+        }
+        const result = Object.assign(Object.assign(Object.assign({}, (obj.title && { title: obj.title })), (obj.description && { description: obj.description })), (obj.metadata && { metadata: obj.metadata }));
+        return succeed(result);
+    }
+    /**
+     * Override to demonstrate looking up template values from another resource.
+     */
+    getDefaultTemplateCandidate(json, conditions, resolver) {
+        // If a template resource ID is configured and resolver is available, try to resolve it
+        if (this._templateResourceId && resolver && !json) {
+            return resolver
+                .resolveComposedResourceValue(this._templateResourceId)
+                .onFailure((error) => fail(`${this.key}: Failed to resolve template resource '${this._templateResourceId}': ${error}`))
+                .onSuccess((resolvedValue) => {
+                // Use the resolved value as our JSON template
+                return super.getDefaultTemplateCandidate(resolvedValue, conditions, resolver);
+            });
+        }
+        // Use provided JSON or fall back to base implementation
+        return super.getDefaultTemplateCandidate(json, conditions, resolver);
+    }
+    /**
+     * Override createTemplate to add additional validation for the derived type.
+     */
+    createTemplate(resourceId, init, conditions, resolver) {
+        // Additional validation: warn if trying to use resolver functionality without a resolver
+        if (this._templateResourceId && !resolver) {
+            return fail(`${this.key}: Template resource ID '${this._templateResourceId}' is configured but no resolver provided`);
+        }
+        return super.createTemplate(resourceId, init, conditions, resolver);
+    }
+}
+//# sourceMappingURL=testDerivedResourceType.js.map

package/dist/test/unit/resources/deltaGenerator.helpers.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 '@fgv/ts-utils-jest';
+import { succeed, fail } from '@fgv/ts-utils';
+import * as TsRes from '../../../index';
+/**
+ * Common test data and setup utilities for DeltaGenerator tests
+ */
+// Test resource candidates for baseline and delta scenarios
+export const baselineResources = [
+    {
+        id: 'greeting.hello',
+        json: { message: 'Hello', casual: 'Hi' },
+        conditions: { language: 'en' },
+        resourceTypeName: 'json'
+    },
+    {
+        id: 'greeting.goodbye',
+        json: { message: 'Goodbye', casual: 'Bye' },
+        conditions: { language: 'en' },
+        resourceTypeName: 'json'
+    },
+    {
+        id: 'numbers.count',
+        json: { one: 'one', two: 'two', three: 'three' },
+        conditions: { language: 'en' },
+        resourceTypeName: 'json'
+    }
+];
+export const deltaResources = [
+    // Updated resource - some changes
+    {
+        id: 'greeting.hello',
+        json: { message: 'Hello World', casual: 'Hi there' },
+        conditions: { language: 'en' },
+        resourceTypeName: 'json'
+    },
+    // New resource - not in baseline
+    {
+        id: 'greeting.welcome',
+        json: { message: 'Welcome', casual: 'Hey' },
+        conditions: { language: 'en' },
+        resourceTypeName: 'json'
+    },
+    // Unchanged resource - identical to baseline
+    {
+        id: 'numbers.count',
+        json: { one: 'one', two: 'two', three: 'three' },
+        conditions: { language: 'en' },
+        resourceTypeName: 'json'
+    }
+];
+/**
+ * Creates the base test setup with qualifier types, qualifiers, and resource types
+ */
+export function createBaseTestSetup() {
+    // Set up qualifier types
+    const qualifierTypes = TsRes.QualifierTypes.QualifierTypeCollector.create({
+        qualifierTypes: [
+            TsRes.QualifierTypes.LanguageQualifierType.create().orThrow(),
+            TsRes.QualifierTypes.TerritoryQualifierType.create().orThrow()
+        ]
+    }).orThrow();
+    // Set up qualifiers
+    const qualifiers = TsRes.Qualifiers.QualifierCollector.create({
+        qualifierTypes,
+        qualifiers: [
+            { name: 'language', typeName: 'language', defaultPriority: 100 },
+            { name: 'territory', typeName: 'territory', defaultPriority: 90 }
+        ]
+    }).orThrow();
+    // Set up resource types
+    const resourceTypes = TsRes.ResourceTypes.ResourceTypeCollector.create({
+        resourceTypes: [TsRes.ResourceTypes.JsonResourceType.create().orThrow()]
+    }).orThrow();
+    // Set up context provider
+    const contextProvider = TsRes.Runtime.ValidatingSimpleContextQualifierProvider.create({
+        qualifiers,
+        qualifierValues: {
+            language: 'en',
+            territory: 'US'
+        }
+    }).orThrow();
+    return {
+        qualifierTypes,
+        qualifiers,
+        resourceTypes,
+        contextProvider
+    };
+}
+/**
+ * Creates a mock logger for testing
+ */
+export function createMockLogger() {
+    return {
+        logLevel: 'detail',
+        log: jest.fn(),
+        detail: jest.fn(),
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn()
+    };
+}
+/**
+ * Creates a resource manager with baseline resources
+ */
+export function createResourceManagerWithBaseline(qualifiers, resourceTypes, resources = baselineResources) {
+    const resourceManager = TsRes.Resources.ResourceManagerBuilder.create({
+        qualifiers,
+        resourceTypes
+    }).orThrow();
+    // Add resources
+    resources.forEach((resource) => {
+        resourceManager.addLooseCandidate(resource).orThrow();
+    });
+    return resourceManager;
+}
+/**
+ * Creates a baseline resolver with the given resources
+ */
+export function createBaselineResolver(resourceManager, qualifierTypes, contextProvider) {
+    const builtManager = resourceManager.build().orThrow();
+    return TsRes.Runtime.ResourceResolver.create({
+        resourceManager: builtManager,
+        qualifierTypes,
+        contextQualifierProvider: contextProvider
+    }).orThrow();
+}
+/**
+ * Creates a delta resolver with the given resources
+ */
+export function createDeltaResolver(resources, qualifiers, resourceTypes, qualifierTypes, contextProvider) {
+    const deltaManager = TsRes.Resources.ResourceManagerBuilder.create({
+        qualifiers,
+        resourceTypes
+    }).orThrow();
+    resources.forEach((resource) => {
+        deltaManager.addLooseCandidate(resource).orThrow();
+    });
+    const builtDeltaManager = deltaManager.build().orThrow();
+    return TsRes.Runtime.ResourceResolver.create({
+        resourceManager: builtDeltaManager,
+        qualifierTypes,
+        contextQualifierProvider: contextProvider
+    }).orThrow();
+}
+/**
+ * Creates a complete test setup with all required objects
+ */
+export function createCompleteTestSetup() {
+    const baseSetup = createBaseTestSetup();
+    const mockLogger = createMockLogger();
+    const resourceManager = createResourceManagerWithBaseline(baseSetup.qualifiers, baseSetup.resourceTypes);
+    return Object.assign(Object.assign({}, baseSetup), { resourceManager,
+        mockLogger });
+}
+/**
+ * Test data for various test scenarios
+ */
+export const testData = {
+    // Resources with language variations
+    languageResources: {
+        baseline: [
+            {
+                id: 'greeting.hello',
+                json: { message: 'Hello' },
+                conditions: { language: 'en-US' },
+                resourceTypeName: 'json'
+            },
+            {
+                id: 'greeting.goodbye',
+                json: { message: 'Goodbye' },
+                conditions: { language: 'en-US' },
+                resourceTypeName: 'json'
+            }
+        ],
+        britishEnglish: [
+            {
+                id: 'greeting.hello',
+                json: { message: 'Hello' },
+                conditions: { language: 'en-GB' },
+                resourceTypeName: 'json'
+            },
+            {
+                id: 'greeting.goodbye',
+                json: { message: 'Cheerio' },
+                conditions: { language: 'en-GB' },
+                resourceTypeName: 'json'
+            },
+            {
+                id: 'greeting.thanks',
+                json: { message: 'Cheers' },
+                conditions: { language: 'en-GB' },
+                resourceTypeName: 'json'
+            }
+        ],
+        canadianEnglish: [
+            {
+                id: 'greeting.hello',
+                json: { message: 'Hello' },
+                conditions: { language: 'en-CA' },
+                resourceTypeName: 'json'
+            },
+            {
+                id: 'greeting.goodbye',
+                json: { message: 'See ya' },
+                conditions: { language: 'en-CA' },
+                resourceTypeName: 'json'
+            },
+            {
+                id: 'greeting.apology',
+                json: { message: 'Sorry' },
+                conditions: { language: 'en-CA' },
+                resourceTypeName: 'json'
+            }
+        ]
+    },
+    // Empty scenarios
+    emptyResources: [],
+    // Complex nested resources
+    complexResources: [
+        {
+            id: 'app.config',
+            json: {
+                settings: {
+                    theme: 'dark',
+                    notifications: {
+                        enabled: true,
+                        frequency: 'daily',
+                        types: ['email', 'push']
+                    }
+                },
+                metadata: {
+                    version: '1.0.0',
+                    lastUpdated: '2025-01-01'
+                }
+            },
+            conditions: { language: 'en' },
+            resourceTypeName: 'json'
+        }
+    ]
+};
+/**
+ * Helper to create a failing resolver for error testing
+ */
+export function createFailingResolver(errorMessage) {
+    return {
+        resourceIds: [],
+        resolveComposedResourceValue: jest.fn().mockReturnValue(fail(errorMessage)),
+        withContext: jest.fn().mockReturnValue(succeed({}))
+    };
+}
+/**
+ * Helper to create a custom resolver with specific behavior
+ */
+export function createCustomResolver(resolveImpl, resourceIds = []) {
+    return {
+        resourceIds,
+        resolveComposedResourceValue: jest.fn().mockImplementation(resolveImpl),
+        withContext: jest.fn().mockReturnValue(succeed({}))
+    };
+}
+//# sourceMappingURL=deltaGenerator.helpers.js.map

package/dist/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.53.3"
+      "packageVersion": "7.54.0"
     }
   ]
 }

package/lib/index.browser.d.ts

@@ -0,0 +1,24 @@
+import * as Bundle from './packlets/bundle';
+import * as QualifierTypes from './packlets/qualifier-types';
+import * as Qualifiers from './packlets/qualifiers';
+import * as Conditions from './packlets/conditions';
+import * as Config from './packlets/config/index.browser';
+import * as Context from './packlets/context';
+import * as Decisions from './packlets/decisions';
+import * as ResourceJson from './packlets/resource-json';
+import * as Resources from './packlets/resources';
+import * as ResourceTypes from './packlets/resource-types';
+import * as Import from './packlets/import/index.browser';
+import * as Runtime from './packlets/runtime';
+import * as ZipArchive from './packlets/zip-archive/index.browser';
+export * from './packlets/common';
+import { Condition, ConditionSet } from './packlets/conditions';
+import { Decision } from './packlets/decisions';
+import { QualifierType } from './packlets/qualifier-types';
+import { Qualifier } from './packlets/qualifiers';
+import { ResourceType } from './packlets/resource-types';
+import { Resource, ResourceCandidate, ResourceManagerBuilder } from './packlets/resources';
+import { IResourceManager, ResourceResolver } from './packlets/runtime';
+import { BundleBuilder, BundleLoader } from './packlets/bundle';
+export { Bundle, BundleBuilder, BundleLoader, Condition, Conditions, ConditionSet, Config, Context, Decision, Decisions, Import, IResourceManager, Qualifier, QualifierType, QualifierTypes, Qualifiers, Resource, ResourceCandidate, ResourceJson, ResourceResolver, ResourceManagerBuilder, ResourceType, ResourceTypes, Resources, Runtime, ZipArchive };
+//# sourceMappingURL=index.browser.d.ts.map

package/lib/index.browser.js

@@ -0,0 +1,116 @@
+"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;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZipArchive = exports.Runtime = exports.Resources = exports.ResourceTypes = exports.ResourceType = exports.ResourceManagerBuilder = exports.ResourceResolver = exports.ResourceJson = exports.ResourceCandidate = exports.Resource = exports.Qualifiers = exports.QualifierTypes = exports.QualifierType = exports.Qualifier = exports.Import = exports.Decisions = exports.Decision = exports.Context = exports.Config = exports.ConditionSet = exports.Conditions = exports.Condition = exports.BundleLoader = exports.BundleBuilder = exports.Bundle = void 0;
+// Browser entry point - excludes Node.js filesystem dependencies
+const Bundle = __importStar(require("./packlets/bundle"));
+exports.Bundle = Bundle;
+const QualifierTypes = __importStar(require("./packlets/qualifier-types"));
+exports.QualifierTypes = QualifierTypes;
+const Qualifiers = __importStar(require("./packlets/qualifiers"));
+exports.Qualifiers = Qualifiers;
+const Conditions = __importStar(require("./packlets/conditions"));
+exports.Conditions = Conditions;
+// eslint-disable-next-line @rushstack/packlets/mechanics -- browser-specific entry point excludes Node.js fs dependencies
+const Config = __importStar(require("./packlets/config/index.browser"));
+exports.Config = Config;
+const Context = __importStar(require("./packlets/context"));
+exports.Context = Context;
+const Decisions = __importStar(require("./packlets/decisions"));
+exports.Decisions = Decisions;
+const ResourceJson = __importStar(require("./packlets/resource-json"));
+exports.ResourceJson = ResourceJson;
+const Resources = __importStar(require("./packlets/resources"));
+exports.Resources = Resources;
+const ResourceTypes = __importStar(require("./packlets/resource-types"));
+exports.ResourceTypes = ResourceTypes;
+// eslint-disable-next-line @rushstack/packlets/mechanics -- browser-specific entry point excludes Node.js fs dependencies
+const Import = __importStar(require("./packlets/import/index.browser"));
+exports.Import = Import;
+const Runtime = __importStar(require("./packlets/runtime"));
+exports.Runtime = Runtime;
+// eslint-disable-next-line @rushstack/packlets/mechanics -- browser-specific entry point excludes Node.js fs dependencies
+const ZipArchive = __importStar(require("./packlets/zip-archive/index.browser"));
+exports.ZipArchive = ZipArchive;
+__exportStar(require("./packlets/common"), exports);
+const conditions_1 = require("./packlets/conditions");
+Object.defineProperty(exports, "Condition", { enumerable: true, get: function () { return conditions_1.Condition; } });
+Object.defineProperty(exports, "ConditionSet", { enumerable: true, get: function () { return conditions_1.ConditionSet; } });
+const decisions_1 = require("./packlets/decisions");
+Object.defineProperty(exports, "Decision", { enumerable: true, get: function () { return decisions_1.Decision; } });
+const qualifier_types_1 = require("./packlets/qualifier-types");
+Object.defineProperty(exports, "QualifierType", { enumerable: true, get: function () { return qualifier_types_1.QualifierType; } });
+const qualifiers_1 = require("./packlets/qualifiers");
+Object.defineProperty(exports, "Qualifier", { enumerable: true, get: function () { return qualifiers_1.Qualifier; } });
+const resource_types_1 = require("./packlets/resource-types");
+Object.defineProperty(exports, "ResourceType", { enumerable: true, get: function () { return resource_types_1.ResourceType; } });
+const resources_1 = require("./packlets/resources");
+Object.defineProperty(exports, "Resource", { enumerable: true, get: function () { return resources_1.Resource; } });
+Object.defineProperty(exports, "ResourceCandidate", { enumerable: true, get: function () { return resources_1.ResourceCandidate; } });
+Object.defineProperty(exports, "ResourceManagerBuilder", { enumerable: true, get: function () { return resources_1.ResourceManagerBuilder; } });
+const runtime_1 = require("./packlets/runtime");
+Object.defineProperty(exports, "ResourceResolver", { enumerable: true, get: function () { return runtime_1.ResourceResolver; } });
+const bundle_1 = require("./packlets/bundle");
+Object.defineProperty(exports, "BundleBuilder", { enumerable: true, get: function () { return bundle_1.BundleBuilder; } });
+Object.defineProperty(exports, "BundleLoader", { enumerable: true, get: function () { return bundle_1.BundleLoader; } });
+// Excluded from browser:
+// - Config: SystemConfiguration.loadFromFile() (requires Node.js fs via JsonFile)
+// - Import: PathImporter, FsItemImporter, FsItem.createForPath() (require Node.js fs)
+// - ZipArchive: ZipArchiveCreator methods using file paths (require Node.js fs)
+//# sourceMappingURL=index.browser.js.map

package/lib/packlets/config/index.browser.d.ts

@@ -0,0 +1,7 @@
+import * as Model from './json';
+import * as Convert from './convert';
+export * from './configInitFactory';
+export * from './common';
+export { SystemConfiguration } from './systemConfiguration';
+export { Model, Convert };
+//# sourceMappingURL=index.browser.d.ts.map