@contrail/cli 3.5.1-alpha.68d57e0 → 3.5.1-alpha.9da7ac5

package/node_modules/@contrail/loader/lib/pipeline/validate.spec.js

@@ -118,59 +118,6 @@ describe('validate', () => {
         expect(multiSelectIssues).toHaveLength(1);
         expect(multiSelectIssues[0].suggestedFix?.type).toBe(types_3.SuggestedFixType.CHANGE_SEPARATOR);
     });
-    it('should validate Family/Option-suffixed columns against the base option set', async () => {
-        const analysis = makeAnalysis({
-            optionSetUsingTypePropertiesBySlug: {
-                vfAdvConceptsTech: {
-                    slug: 'vfAdvConceptsTech',
-                    label: 'Advanced Concepts Tech',
-                    propertyType: 'multi_select',
-                    typePropertyOptionSetId: 'os-suffix',
-                    options: [
-                        { value: 'ortholite', display: 'Ortholite' },
-                        { value: 'hoverSpring', display: 'Hover Spring' },
-                    ],
-                    optionLookupByValue: {
-                        ortholite: { value: 'ortholite', display: 'Ortholite' },
-                        hoverSpring: { value: 'hoverSpring', display: 'Hover Spring' },
-                    },
-                    optionLookupByDisplay: {
-                        Ortholite: { value: 'ortholite', display: 'Ortholite' },
-                        'Hover Spring': { value: 'hoverSpring', display: 'Hover Spring' },
-                    },
-                },
-            },
-        });
-        const rows = [
-            { federatedId: '1', name: 'A', vfAdvConceptsTechFamily: 'ortholite,GRIPMAX SLIP RESISTANT,hoverSpring' },
-        ];
-        const result = await (0, validate_1.validate)(rows, baseConfig, analysis);
-        expect(result.valid).toBe(false);
-        const issues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.OPTION_SET && i.columnName === 'vfAdvConceptsTechFamily');
-        expect(issues.length).toBeGreaterThan(0);
-        const offending = issues.find((i) => i.message.includes('GRIPMAX SLIP RESISTANT'));
-        expect(offending).toBeDefined();
-    });
-    it('flags missing option set on suffixed columns (no typePropertyOptionSetId)', async () => {
-        const analysis = makeAnalysis({
-            optionSetUsingTypePropertiesBySlug: {
-                lifecycleStage: {
-                    slug: 'lifecycleStage',
-                    label: 'Lifecycle Stage',
-                    propertyType: 'choice',
-                    typePropertyOptionSetId: undefined,
-                    options: [],
-                    optionLookupByValue: {},
-                    optionLookupByDisplay: {},
-                },
-            },
-        });
-        const rows = [{ federatedId: '1', name: 'A', lifecycleStageOption: 'concept' }];
-        const result = await (0, validate_1.validate)(rows, baseConfig, analysis);
-        const issues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.OPTION_SET && i.columnName === 'lifecycleStageOption');
-        expect(issues.length).toBe(1);
-        expect(issues[0].message).toContain('no option set attached');
-    });
     it('should skip empty values in option set validation', async () => {
         const analysis = makeAnalysis({
             optionSetUsingTypePropertiesBySlug: {
@@ -584,6 +531,59 @@ describe('validate', () => {
             expect(conflict).toBeUndefined();
         });
     });
+    describe('validateAssortmentColumns', () => {
+        it('should skip for non-ASSORTMENT loads', async () => {
+            const config = { loadType: [types_1.LoadType.ITEM] };
+            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A' }];
+            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
+            const assortmentIssue = result.issues.find((i) => i.columnName?.includes('assortmentId'));
+            expect(assortmentIssue).toBeUndefined();
+        });
+        it('should error when no rows have assortmentId or assortmentIdentifier', async () => {
+            const config = { loadType: [types_1.LoadType.ASSORTMENT] };
+            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A' }];
+            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
+            const issue = result.issues.find((i) => i.message.includes('ASSORTMENT loads require'));
+            expect(issue).toBeDefined();
+            expect(result.valid).toBe(false);
+        });
+        it('should error when rows have both assortmentId and assortmentIdentifier', async () => {
+            const config = { loadType: [types_1.LoadType.ASSORTMENT] };
+            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: 'id-1', assortmentIdentifier: 'ident-1' }];
+            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
+            const issue = result.issues.find((i) => i.message.includes('both "assortmentId" and "assortmentIdentifier"'));
+            expect(issue).toBeDefined();
+        });
+        it('should error when assortmentId values are empty', async () => {
+            const config = { loadType: [types_1.LoadType.ASSORTMENT] };
+            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: '' }];
+            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
+            const issue = result.issues.find((i) => i.message.includes('"assortmentId" cannot be empty'));
+            expect(issue).toBeDefined();
+        });
+        it('should not error when rows have valid assortmentId', async () => {
+            const config = { loadType: [types_1.LoadType.ASSORTMENT] };
+            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: 'assort-1' }];
+            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
+            const columnIssue = result.issues.find((i) => i.message.includes('ASSORTMENT loads require'));
+            expect(columnIssue).toBeUndefined();
+        });
+        it('should not error on rows missing assortmentId when derived from conditional columns with conditions', async () => {
+            const config = {
+                loadType: [types_1.LoadType.ASSORTMENT],
+                conditionalColumns: [
+                    { toProperty: 'assortmentId', conditions: [{ conditional: "{gender} === 'mens'", value: 'assort-1' }] },
+                ],
+            };
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: 'assort-1' },
+                { itemFamilyFederatedId: 'fam-2', name: 'B' },
+            ];
+            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
+            const emptyIssue = result.issues.find((i) => i.message.includes('"assortmentId" cannot be empty'));
+            expect(emptyIssue).toBeUndefined();
+        });
+    });
     describe('validatePartialAssortmentConfig', () => {
         it('should skip for non-ASSORTMENT loads', async () => {
             const config = { loadType: [types_1.LoadType.ITEM], partialAssortmentUpdate: true };
@@ -1211,108 +1211,4 @@ describe('validate', () => {
             expect(unmappedPropIssues[0].message).toContain('noLabel');
         });
     });
-    describe('object reference resolution validation', () => {
-        const colorConfig = {
-            loadType: [types_1.LoadType.COLOR],
-            federatedMappings: { federatedId: 'federatedId', name: 'name' },
-        };
-        const typesByPathWithVendorRef = {
-            color: {
-                type: { typeProperties: [{ slug: 'vendor', propertyType: 'object_reference' }] },
-                allPropertiesSlugs: ['vendor'],
-                typePropertyToValueType: {},
-                objectReferenceProperties: [
-                    {
-                        slug: 'vendor',
-                        propertyType: 'object_reference',
-                        referencedTypeRootSlug: 'vendor',
-                        referencedTypePath: 'vendor',
-                    },
-                ],
-                userListProperties: [],
-            },
-        };
-        it('should emit one warning per unique missing value with affected rows', async () => {
-            const mockClient = {
-                get: jest.fn().mockResolvedValue([{ federatedId: 'acme', id: 'vendor-acme' }]),
-            };
-            const rows = [
-                { federatedId: 'c-1', name: 'Red', vendor: 'acme' },
-                { federatedId: 'c-2', name: 'Blue', vendor: 'missing-vendor' },
-                { federatedId: 'c-3', name: 'Green', vendor: 'another-missing' },
-                { federatedId: 'c-4', name: 'Yellow', vendor: 'missing-vendor' },
-            ];
-            const analysis = makeAnalysis({}, typesByPathWithVendorRef);
-            const result = await (0, validate_1.validate)(rows, colorConfig, analysis, mockClient);
-            const refIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.REFERENCE_DATA_NOT_FOUND &&
-                i.columnName === 'vendor');
-            expect(refIssues).toHaveLength(2);
-            for (const issue of refIssues) {
-                expect(issue.severity).toBe(types_3.PreValidationSeverity.WARNING);
-                expect(issue.propertyType).toBe('object_reference');
-            }
-            const byValue = new Map(refIssues.map((i) => [i.affectedRows[0].value, i]));
-            expect(byValue.get('missing-vendor').affectedRows.map((r) => r.row).sort()).toEqual([3, 5]);
-            expect(byValue.get('missing-vendor').message).toContain('"missing-vendor"');
-            expect(byValue.get('another-missing').affectedRows.map((r) => r.row)).toEqual([4]);
-            expect(byValue.get('another-missing').message).toContain('"another-missing"');
-        });
-        it('should not emit a warning when all references resolve', async () => {
-            const mockClient = {
-                get: jest.fn().mockResolvedValue([
-                    { federatedId: 'acme', id: 'vendor-acme' },
-                    { federatedId: 'foo', id: 'vendor-foo' },
-                ]),
-            };
-            const rows = [
-                { federatedId: 'c-1', name: 'Red', vendor: 'acme' },
-                { federatedId: 'c-2', name: 'Blue', vendor: 'foo' },
-            ];
-            const analysis = makeAnalysis({}, typesByPathWithVendorRef);
-            const result = await (0, validate_1.validate)(rows, colorConfig, analysis, mockClient);
-            const refIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.REFERENCE_DATA_NOT_FOUND);
-            expect(refIssues).toHaveLength(0);
-        });
-        it('should skip the lookup entirely when no client is provided', async () => {
-            const rows = [{ federatedId: 'c-1', name: 'Red', vendor: 'missing' }];
-            const analysis = makeAnalysis({}, typesByPathWithVendorRef);
-            const result = await (0, validate_1.validate)(rows, colorConfig, analysis);
-            const refIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.REFERENCE_DATA_NOT_FOUND);
-            expect(refIssues).toHaveLength(0);
-        });
-        it('should prefix custom-entity referenced fed ids when looking up', async () => {
-            const customEntityTypesByPath = {
-                color: {
-                    type: { typeProperties: [{ slug: 'category', propertyType: 'object_reference' }] },
-                    allPropertiesSlugs: ['category'],
-                    typePropertyToValueType: {},
-                    objectReferenceProperties: [
-                        {
-                            slug: 'category',
-                            propertyType: 'object_reference',
-                            referencedTypeRootSlug: 'custom-entity',
-                            referencedTypePath: 'custom-entity:category',
-                        },
-                    ],
-                    userListProperties: [],
-                },
-            };
-            const mockClient = {
-                get: jest.fn().mockResolvedValue([
-                    { federatedId: 'custom-entity:category:resolved', id: 'cat-1' },
-                ]),
-            };
-            const rows = [
-                { federatedId: 'c-1', name: 'Red', category: 'resolved' },
-                { federatedId: 'c-2', name: 'Blue', category: 'unresolved' },
-            ];
-            const analysis = makeAnalysis({}, customEntityTypesByPath);
-            const result = await (0, validate_1.validate)(rows, colorConfig, analysis, mockClient);
-            const refIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.REFERENCE_DATA_NOT_FOUND &&
-                i.columnName === 'category');
-            expect(refIssues).toHaveLength(1);
-            expect(refIssues[0].affectedRows).toHaveLength(1);
-            expect(refIssues[0].affectedRows[0].value).toBe('unresolved');
-        });
-    });
 });

package/node_modules/@contrail/loader/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/loader",
-  "version": "2.0.9",
+  "version": "2.0.6",
   "description": "Client library for helping with loader jobs.",
   "homepage": "https://archergreysorg.github.io/contrail-loader/",
   "main": "lib/index.js",
@@ -36,8 +36,7 @@
     "form-data": "^4.0.0",
     "lodash": "^4.17.21",
     "node-fetch": "^2.6.0",
-    "p-limit": "^3.0.0",
-    "validate-color": "^2.2.4"
+    "p-limit": "^3.0.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.2",

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.5.1-alpha.68d57e0",
+  "version": "3.5.1-alpha.9da7ac5",
   "commands": {
     "app:create": {
       "id": "app:create",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/cli",
-  "version": "3.5.1-alpha.68d57e0",
+  "version": "3.5.1-alpha.9da7ac5",
   "description": "VibeIQ's Contrail Platform CLI.",
   "bin": {
     "contrail-cli": "./bin/run",
@@ -31,7 +31,7 @@
   ],
   "dependencies": {
     "@contrail/entity-types": "^1.6.1",
-    "@contrail/loader": "^2.0.9",
+    "@contrail/loader": "^2.0.6",
     "@contrail/org-config-migration": "^1.1.13",
     "@contrail/sdk": "^1.5.13",
     "@contrail/types": "^3.1.5",

package/node_modules/@contrail/loader/lib/common/color-validation.d.ts

@@ -1,26 +0,0 @@
-import { ProcessingIssues } from '@contrail/entity-types';
-export declare const COLOR_VALIDATION_MESSAGES: {
-    readonly HEX_INVALID: (hex: string) => string;
-    readonly RGB_INCOMPLETE: (missingColumns: string[]) => string;
-    readonly RGB_OUT_OF_RANGE: (column: string, value: string) => string;
-    readonly HEX_PRIORITIZED_OVER_RGB: "Both \"hex\" and red/green/blue values are provided — \"hex\" will be used and red/green/blue will be ignored for this row.";
-};
-export declare const DEFAULT_HEX = "000000";
-export declare function isValidHex(hex: string): boolean;
-export declare function parseRgbComponent(value: any): number | null;
-export interface ColorRowValidationResult {
-    errors: {
-        columnName: string;
-        message: string;
-    }[];
-    warnings: {
-        columnName: string;
-        message: string;
-    }[];
-}
-export declare function validateColorRow(row: Record<string, any>, federatedMappings?: Record<string, string>): ColorRowValidationResult;
-export declare function buildColorRowIssues(row: Record<string, any>, rowNumber: number, federatedMappings?: Record<string, string>): {
-    rowErrors: ProcessingIssues | null;
-    rowWarnings: ProcessingIssues | null;
-};
-export declare function applyHexPriorityToRows<T extends Record<string, any>>(rows: T[]): T[];

package/node_modules/@contrail/loader/lib/common/color-validation.js

@@ -1,163 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyHexPriorityToRows = exports.buildColorRowIssues = exports.validateColorRow = exports.parseRgbComponent = exports.isValidHex = exports.DEFAULT_HEX = exports.COLOR_VALIDATION_MESSAGES = void 0;
-const entity_types_1 = require("@contrail/entity-types");
-const validate_color_1 = require("validate-color");
-exports.COLOR_VALIDATION_MESSAGES = {
-    HEX_INVALID: (hex) => `"hex" value "${hex}" is not a valid hex color code (expected 3, 4, 6, or 8 hex digits, optionally prefixed with #).`,
-    RGB_INCOMPLETE: (missingColumns) => `Row has partial RGB data — "${missingColumns.join('", "')}" must also be provided when using RGB. Provide all of red/green/blue, or use "hex" instead.`,
-    RGB_OUT_OF_RANGE: (column, value) => `"${column}" value "${value}" is not a valid RGB component (must be a whole number between 0 and 255).`,
-    HEX_PRIORITIZED_OVER_RGB: 'Both "hex" and red/green/blue values are provided — "hex" will be used and red/green/blue will be ignored for this row.',
-};
-exports.DEFAULT_HEX = '000000';
-const RGB_TARGET_KEYS = ['red', 'green', 'blue'];
-const HEX_TARGET_KEY = 'hex';
-function getColorValue(row, federatedMappings, targetKey) {
-    const target = row[targetKey];
-    if (!isEmpty(target))
-        return target;
-    const sourceColumn = federatedMappings?.[targetKey];
-    if (sourceColumn && sourceColumn !== targetKey)
-        return row[sourceColumn];
-    return target;
-}
-function isEmpty(value) {
-    return value === null || value === undefined || value === '';
-}
-function isValidHex(hex) {
-    if (typeof hex !== 'string' || hex.length === 0)
-        return false;
-    const normalized = hex.startsWith('#') ? hex : `#${hex}`;
-    return (0, validate_color_1.validateHTMLColorHex)(normalized);
-}
-exports.isValidHex = isValidHex;
-function parseRgbComponent(value) {
-    if (isEmpty(value))
-        return null;
-    if (typeof value === 'number' && Number.isInteger(value) && value >= 0 && value <= 255)
-        return value;
-    if (typeof value === 'string') {
-        const trimmed = value.trim();
-        if (trimmed === '' || !/^-?\d+$/.test(trimmed))
-            return null;
-        const n = Number(trimmed);
-        if (!Number.isInteger(n) || n < 0 || n > 255)
-            return null;
-        return n;
-    }
-    return null;
-}
-exports.parseRgbComponent = parseRgbComponent;
-function validateColorRow(row, federatedMappings) {
-    const errors = [];
-    const warnings = [];
-    const hexValue = getColorValue(row, federatedMappings, HEX_TARGET_KEY);
-    const rgbValues = {
-        red: getColorValue(row, federatedMappings, 'red'),
-        green: getColorValue(row, federatedMappings, 'green'),
-        blue: getColorValue(row, federatedMappings, 'blue'),
-    };
-    const rgbProvided = RGB_TARGET_KEYS.filter((k) => !isEmpty(rgbValues[k]));
-    const hexProvided = !isEmpty(hexValue);
-    if (hexProvided) {
-        if (!isValidHex(String(hexValue))) {
-            errors.push({
-                columnName: HEX_TARGET_KEY,
-                message: exports.COLOR_VALIDATION_MESSAGES.HEX_INVALID(String(hexValue)),
-            });
-        }
-        if (rgbProvided.length > 0) {
-            warnings.push({
-                columnName: HEX_TARGET_KEY,
-                message: exports.COLOR_VALIDATION_MESSAGES.HEX_PRIORITIZED_OVER_RGB,
-            });
-        }
-        return { errors, warnings };
-    }
-    if (rgbProvided.length === 0) {
-        return { errors, warnings };
-    }
-    if (rgbProvided.length < RGB_TARGET_KEYS.length) {
-        const missing = RGB_TARGET_KEYS.filter((k) => isEmpty(rgbValues[k]));
-        for (const k of missing) {
-            errors.push({
-                columnName: k,
-                message: exports.COLOR_VALIDATION_MESSAGES.RGB_INCOMPLETE([...missing]),
-            });
-        }
-        return { errors, warnings };
-    }
-    for (const k of RGB_TARGET_KEYS) {
-        if (parseRgbComponent(rgbValues[k]) === null) {
-            errors.push({
-                columnName: k,
-                message: exports.COLOR_VALIDATION_MESSAGES.RGB_OUT_OF_RANGE(k, String(rgbValues[k])),
-            });
-        }
-    }
-    return { errors, warnings };
-}
-exports.validateColorRow = validateColorRow;
-function buildColorRowIssues(row, rowNumber, federatedMappings) {
-    const { errors, warnings } = validateColorRow(row, federatedMappings);
-    const rowJson = JSON.stringify(row);
-    const rowErrors = errors.length
-        ? {
-            rowNumber,
-            columnIssues: errors.map((e) => ({
-                columnName: e.columnName,
-                message: e.message,
-                issueType: entity_types_1.IssueType.INVALID_DATA,
-                data: rowJson,
-            })),
-        }
-        : null;
-    const rowWarnings = warnings.length
-        ? {
-            rowNumber,
-            columnIssues: warnings.map((w) => ({
-                columnName: w.columnName,
-                message: w.message,
-                issueType: entity_types_1.IssueType.INVALID_DATA,
-                data: rowJson,
-            })),
-        }
-        : null;
-    return { rowErrors, rowWarnings };
-}
-exports.buildColorRowIssues = buildColorRowIssues;
-function applyHexPriorityToRows(rows) {
-    for (const r of rows ?? []) {
-        if (!r)
-            continue;
-        const row = r;
-        const hexRaw = row.hex;
-        const hexNormalized = typeof hexRaw === 'string' && hexRaw.startsWith('#') ? hexRaw.slice(1) : hexRaw;
-        const hexValid = !isEmpty(hexNormalized) && isValidHex(String(hexNormalized));
-        if (hexValid) {
-            row.hex = hexNormalized;
-            delete row.red;
-            delete row.green;
-            delete row.blue;
-            continue;
-        }
-        const rgbAllValid = parseRgbComponent(row.red) !== null &&
-            parseRgbComponent(row.green) !== null &&
-            parseRgbComponent(row.blue) !== null;
-        if (rgbAllValid) {
-            if (!isEmpty(hexNormalized)) {
-                row.hex = hexNormalized;
-            }
-            else if ('hex' in row) {
-                delete row.hex;
-            }
-            continue;
-        }
-        row.hex = exports.DEFAULT_HEX;
-        delete row.red;
-        delete row.green;
-        delete row.blue;
-    }
-    return rows;
-}
-exports.applyHexPriorityToRows = applyHexPriorityToRows;

package/node_modules/@contrail/loader/lib/common/color-validation.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/node_modules/@contrail/loader/lib/common/color-validation.spec.js

@@ -1,102 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const color_validation_1 = require("./color-validation");
-describe('isValidHex', () => {
-    it.each(['#ff0000', 'ff0000', '#FFF', 'fff', '#1a2b3c', '#FFFFFFFF'])('accepts %s', (hex) => {
-        expect((0, color_validation_1.isValidHex)(hex)).toBe(true);
-    });
-    it.each(['', 'notahex', 'gggggg', '#12345', '#1234567', '   ', '#'])('rejects %s', (hex) => {
-        expect((0, color_validation_1.isValidHex)(hex)).toBe(false);
-    });
-});
-describe('parseRgbComponent', () => {
-    it('parses valid integers in range', () => {
-        expect((0, color_validation_1.parseRgbComponent)('0')).toBe(0);
-        expect((0, color_validation_1.parseRgbComponent)('255')).toBe(255);
-        expect((0, color_validation_1.parseRgbComponent)(128)).toBe(128);
-    });
-    it('rejects out-of-range, non-integer, and empty values', () => {
-        expect((0, color_validation_1.parseRgbComponent)('-1')).toBe(null);
-        expect((0, color_validation_1.parseRgbComponent)('256')).toBe(null);
-        expect((0, color_validation_1.parseRgbComponent)('1.5')).toBe(null);
-        expect((0, color_validation_1.parseRgbComponent)('foo')).toBe(null);
-        expect((0, color_validation_1.parseRgbComponent)('')).toBe(null);
-        expect((0, color_validation_1.parseRgbComponent)(null)).toBe(null);
-        expect((0, color_validation_1.parseRgbComponent)(undefined)).toBe(null);
-    });
-});
-describe('validateColorRow', () => {
-    it('returns no errors when only valid hex is present', () => {
-        expect((0, color_validation_1.validateColorRow)({ hex: '#ff0000' })).toEqual({ errors: [], warnings: [] });
-    });
-    it('returns no errors when only valid RGB is present', () => {
-        expect((0, color_validation_1.validateColorRow)({ red: '255', green: '0', blue: '0' })).toEqual({
-            errors: [],
-            warnings: [],
-        });
-    });
-    it('errors on invalid hex', () => {
-        const result = (0, color_validation_1.validateColorRow)({ hex: 'zzz' });
-        expect(result.errors).toEqual([
-            { columnName: 'hex', message: color_validation_1.COLOR_VALIDATION_MESSAGES.HEX_INVALID('zzz') },
-        ]);
-    });
-    it('warns when both hex and RGB are populated', () => {
-        const result = (0, color_validation_1.validateColorRow)({ hex: '#fff', red: '1', green: '2', blue: '3' });
-        expect(result.errors).toEqual([]);
-        expect(result.warnings).toEqual([
-            { columnName: 'hex', message: color_validation_1.COLOR_VALIDATION_MESSAGES.HEX_PRIORITIZED_OVER_RGB },
-        ]);
-    });
-    it('errors per-missing-column when RGB is partial and hex is missing', () => {
-        const result = (0, color_validation_1.validateColorRow)({ red: '255' });
-        expect(result.errors).toEqual([
-            { columnName: 'green', message: color_validation_1.COLOR_VALIDATION_MESSAGES.RGB_INCOMPLETE(['green', 'blue']) },
-            { columnName: 'blue', message: color_validation_1.COLOR_VALIDATION_MESSAGES.RGB_INCOMPLETE(['green', 'blue']) },
-        ]);
-    });
-    it('errors when an RGB component is out of range', () => {
-        const result = (0, color_validation_1.validateColorRow)({ red: '999', green: '0', blue: '0' });
-        expect(result.errors).toEqual([
-            { columnName: 'red', message: color_validation_1.COLOR_VALIDATION_MESSAGES.RGB_OUT_OF_RANGE('red', '999') },
-        ]);
-    });
-    it('reports no errors when neither hex nor RGB is present', () => {
-        expect((0, color_validation_1.validateColorRow)({ name: 'foo' })).toEqual({ errors: [], warnings: [] });
-    });
-    it('resolves federatedMappings to source columns', () => {
-        const row = { hexcode: '#fff', r: '255', g: '0', b: '0' };
-        const mappings = { hex: 'hexcode', red: 'r', green: 'g', blue: 'b' };
-        const result = (0, color_validation_1.validateColorRow)(row, mappings);
-        expect(result.errors).toEqual([]);
-        expect(result.warnings).toEqual([
-            { columnName: 'hex', message: color_validation_1.COLOR_VALIDATION_MESSAGES.HEX_PRIORITIZED_OVER_RGB },
-        ]);
-    });
-});
-describe('applyHexPriorityToRows', () => {
-    it('strips RGB columns when hex is valid', () => {
-        const result = (0, color_validation_1.applyHexPriorityToRows)([
-            { hex: '#ff0000', red: '255', green: '0', blue: '0', name: 'foo' },
-        ]);
-        expect(result).toEqual([{ hex: 'ff0000', name: 'foo' }]);
-    });
-    it('keeps RGB and removes empty hex when hex is absent', () => {
-        const result = (0, color_validation_1.applyHexPriorityToRows)([{ red: '1', green: '2', blue: '3', name: 'foo' }]);
-        expect(result).toEqual([{ red: '1', green: '2', blue: '3', name: 'foo' }]);
-    });
-    it('defaults to DEFAULT_HEX when neither valid hex nor full RGB is present', () => {
-        const result = (0, color_validation_1.applyHexPriorityToRows)([{ name: 'foo' }]);
-        expect(result).toEqual([{ name: 'foo', hex: color_validation_1.DEFAULT_HEX }]);
-    });
-    it('treats invalid hex as missing and falls through to RGB or default', () => {
-        const result = (0, color_validation_1.applyHexPriorityToRows)([
-            { hex: 'zzz', red: '1', green: '2', blue: '3', name: 'with-rgb' },
-            { hex: 'zzz', name: 'no-rgb' },
-        ]);
-        expect(result).toEqual([
-            { hex: 'zzz', red: '1', green: '2', blue: '3', name: 'with-rgb' },
-            { hex: color_validation_1.DEFAULT_HEX, name: 'no-rgb' },
-        ]);
-    });
-});

package/node_modules/@contrail/loader/lib/pipeline/identifier-resolver.d.ts

@@ -1,5 +0,0 @@
-import { EntitiesClient, LoaderConfig, PreValidationIssue } from './types';
-export declare function isProjectItemAndAssortmentLoad(config: LoaderConfig): boolean;
-export declare function resolveIdentifiers(rows: Record<string, any>[], config: LoaderConfig, client?: EntitiesClient): Promise<{
-    issues: PreValidationIssue[];
-}>;