@contrail/cli 3.4.5 → 3.4.6-alpha.cffb28e

package/node_modules/@contrail/loader/lib/common/entity-builder-helpers.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldSkipProperty = exports.addProperty = void 0;
+const types_1 = require("@contrail/types");
+function addProperty(propertyName, allPropertiesSlugs, valueType, object, value) {
+    if (shouldSkipProperty(value, valueType)) {
+        return object;
+    }
+    if (valueType === types_1.PropertyType.SizeRange) {
+        if (!value || typeof value !== 'string') {
+            return object;
+        }
+        const regex = /((\w+):\s*([\d+,]+))/g;
+        const sizes = {};
+        let foundMatches = false;
+        const sizeRangesFound = value.matchAll(regex);
+        for (const sizeRange of sizeRangesFound) {
+            const sizeRangeFirstDimension = sizeRange[2];
+            const sizeRangeSecondDimension = sizeRange[3];
+            sizes[sizeRangeFirstDimension] = sizeRangeSecondDimension.split(',').filter((x) => !!x);
+            foundMatches = true;
+        }
+        if (foundMatches) {
+            object[propertyName] = { sizes };
+            return object;
+        }
+        const split = value.split(',').filter((x) => !!x);
+        if (split.length) {
+            object[propertyName] = { sizes: split };
+            return object;
+        }
+        console.debug('failed to parse size range', value);
+    }
+    if (['currency', 'sequence', 'percent', 'number'].includes(valueType)) {
+        if (value && (isNaN(value) || (typeof value !== 'number' && typeof value === 'string'))) {
+            const noCommaString = value?.replace(/,/g, '');
+            const noBackslashString = noCommaString?.replace(/\\/g, '');
+            const noQuoteString = noBackslashString?.replace(/"/g, '');
+            const parse = Number(noQuoteString);
+            if (!isNaN(parse)) {
+                value = parse;
+            }
+        }
+    }
+    const isValueEmpty = !value || (typeof value === 'string' && !value.trim());
+    const clearablePropertyTypes = [types_1.PropertyType.SingleSelect, types_1.PropertyType.MultiSelect, types_1.PropertyType.Date];
+    if (clearablePropertyTypes.includes(valueType) && isValueEmpty) {
+        value = null;
+    }
+    if (valueType === types_1.PropertyType.MultiSelect && typeof value === 'string') {
+        value = value.split(',');
+    }
+    const propertyLevels = propertyName.split('.');
+    if (allPropertiesSlugs.includes(propertyLevels[0])) {
+        let ref = object;
+        for (let i = 0; i < propertyLevels.length - 1; i++) {
+            ref[propertyLevels[i]] = ref[propertyLevels[i]] || {};
+            ref = ref[propertyLevels[i]];
+        }
+        if (valueType !== types_1.PropertyType.Date || isValueEmpty) {
+            ref[propertyLevels[propertyLevels.length - 1]] = value;
+        }
+        else {
+            ref[propertyLevels[propertyLevels.length - 1]] = new Date(value);
+        }
+    }
+    else if (isDerivedProperty(propertyName, allPropertiesSlugs)) {
+        object[propertyName] = value;
+    }
+    return object;
+}
+exports.addProperty = addProperty;
+function shouldSkipProperty(value, valueType) {
+    if (valueType === 'formula') {
+        return true;
+    }
+    if (value === false) {
+        return false;
+    }
+    const validEmptyStringTypes = [
+        types_1.PropertyType.String,
+        types_1.PropertyType.Text,
+        types_1.PropertyType.SingleSelect,
+        types_1.PropertyType.MultiSelect,
+        types_1.PropertyType.Date,
+    ];
+    if (validEmptyStringTypes.includes(valueType) && value === '') {
+        return false;
+    }
+    if (valueType === types_1.PropertyType.Boolean) {
+        return false;
+    }
+    const validNumberTypes = [
+        types_1.PropertyType.Number,
+        types_1.PropertyType.Currency,
+        types_1.PropertyType.Percent,
+        types_1.PropertyType.Sequence,
+    ];
+    if (validNumberTypes.includes(valueType) && value !== null && value !== undefined && !isNaN(value)) {
+        return false;
+    }
+    if (!value) {
+        return true;
+    }
+    return false;
+}
+exports.shouldSkipProperty = shouldSkipProperty;
+function isDerivedProperty(propertyName, allPropertiesSlugs) {
+    if (!propertyName.endsWith('Family') && !propertyName.endsWith('Option')) {
+        return false;
+    }
+    const basePropertyName = propertyName.replace(/(Family|Option)$/, '');
+    return allPropertiesSlugs.includes(basePropertyName);
+}

package/node_modules/@contrail/loader/lib/common/entity-builder-helpers.spec.d.ts

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

package/node_modules/@contrail/loader/lib/common/entity-builder-helpers.spec.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const entity_types_1 = require("@contrail/entity-types");
+const entity_builder_helpers_1 = require("./entity-builder-helpers");
+describe('addProperty', () => {
+    it('should set single-select value as null when value is ""', () => {
+        const obj = { testSingleSelect: '' };
+        const result = (0, entity_builder_helpers_1.addProperty)('testSingleSelect', ['testSingleSelect'], entity_types_1.PropertyType.SingleSelect, obj, obj.testSingleSelect);
+        expect(result.testSingleSelect).toEqual(null);
+    });
+    it('should set single-select value', () => {
+        const obj = { testSingleSelect: '1' };
+        const result = (0, entity_builder_helpers_1.addProperty)('testSingleSelect', ['testSingleSelect'], entity_types_1.PropertyType.SingleSelect, obj, obj.testSingleSelect);
+        expect(result.testSingleSelect).toEqual('1');
+    });
+    it('should set multi-select value as null when value is ""', () => {
+        const obj = { testMultiSelect: '' };
+        const result = (0, entity_builder_helpers_1.addProperty)('testMultiSelect', ['testMultiSelect'], entity_types_1.PropertyType.MultiSelect, obj, obj.testMultiSelect);
+        expect(result.testMultiSelect).toEqual(null);
+    });
+    it('should set multi-select value from a comma-delimited string', () => {
+        const obj = { testMultiSelect: '1,2' };
+        const result = (0, entity_builder_helpers_1.addProperty)('testMultiSelect', ['testMultiSelect'], entity_types_1.PropertyType.MultiSelect, obj, obj.testMultiSelect);
+        expect(result.testMultiSelect).toEqual(['1', '2']);
+    });
+    it('should set date value as null when value is ""', () => {
+        const obj = { testDate: '' };
+        const result = (0, entity_builder_helpers_1.addProperty)('testDate', ['testDate'], entity_types_1.PropertyType.Date, obj, obj.testDate);
+        expect(result.testDate).toEqual(null);
+    });
+    it('should set date value from a ISO-8601 formatted string', () => {
+        const obj = { testDate: '2024-01-16T13:25:02.619Z' };
+        const result = (0, entity_builder_helpers_1.addProperty)('testDate', ['testDate'], entity_types_1.PropertyType.Date, obj, obj.testDate);
+        expect(result.testDate).toBeInstanceOf(Date);
+        expect(result.testDate.toDateString()).toEqual('Tue Jan 16 2024');
+    });
+    it('should set number value', () => {
+        const obj = { testNumber: 0 };
+        const result = (0, entity_builder_helpers_1.addProperty)('testNumber', ['testNumber'], entity_types_1.PropertyType.Percent, obj, obj.testNumber);
+        expect(result.testNumber).toEqual(0);
+    });
+    it('should set percent value', () => {
+        const obj = { testPercent: 10 };
+        const result = (0, entity_builder_helpers_1.addProperty)('testPercent', ['testPercent'], entity_types_1.PropertyType.Percent, obj, obj.testPercent);
+        expect(result.testPercent).toEqual(10);
+    });
+    it('should set currency value', () => {
+        const obj = { testCurrency: 100 };
+        const result = (0, entity_builder_helpers_1.addProperty)('testCurrency', ['testCurrency'], entity_types_1.PropertyType.Currency, obj, obj.testCurrency);
+        expect(result.testCurrency).toEqual(100);
+    });
+    it('should set sequence value', () => {
+        const obj = { testSequence: 50 };
+        const result = (0, entity_builder_helpers_1.addProperty)('testSequence', ['testSequence'], entity_types_1.PropertyType.Sequence, obj, obj.testSequence);
+        expect(result.testSequence).toEqual(50);
+    });
+    it('should parse simple size range', () => {
+        const obj = { testSizeRange: 'B:05,40' };
+        const result = (0, entity_builder_helpers_1.addProperty)('testSizeRange', ['testSizeRange'], entity_types_1.PropertyType.SizeRange, obj, obj.testSizeRange);
+        expect(result.testSizeRange).toEqual({
+            sizes: {
+                B: ['05', '40'],
+            },
+        });
+    });
+    it('should parse size range with empty values', () => {
+        const obj = { testSizeRange: 'B:05,,,40,,,30' };
+        const result = (0, entity_builder_helpers_1.addProperty)('testSizeRange', ['testSizeRange'], entity_types_1.PropertyType.SizeRange, obj, obj.testSizeRange);
+        expect(result.testSizeRange).toEqual({
+            sizes: {
+                B: ['05', '40', '30'],
+            },
+        });
+    });
+    it('should parse size ranges', () => {
+        const obj = { testSizeRange: 'B:05,055,, D: 05,055,12,' };
+        const result = (0, entity_builder_helpers_1.addProperty)('testSizeRange', ['testSizeRange'], entity_types_1.PropertyType.SizeRange, obj, obj.testSizeRange);
+        expect(result.testSizeRange).toEqual({
+            sizes: {
+                B: ['05', '055'],
+                D: ['05', '055', '12'],
+            },
+        });
+    });
+    it('should parse size ranges if they are a comma separated one dimensional string', () => {
+        const obj = { testSizeRange: '05,055,12,' };
+        const result = (0, entity_builder_helpers_1.addProperty)('testSizeRange', ['testSizeRange'], entity_types_1.PropertyType.SizeRange, obj, obj.testSizeRange);
+        expect(result.testSizeRange).toEqual({
+            sizes: ['05', '055', '12'],
+        });
+    });
+    it('should handle empty values', () => {
+        const testCases = [
+            { value: '', expected: '' },
+            { value: null, expected: null },
+            { value: undefined, expected: undefined },
+            { value: '123', expected: 123 },
+            { value: '123.45', expected: 123.45 },
+            { value: '1,234.56', expected: 1234.56 },
+        ];
+        testCases.forEach(({ value, expected }) => {
+            const result = (0, entity_builder_helpers_1.addProperty)('test', ['test'], entity_types_1.PropertyType.Number, { test: value }, value);
+            console.log('result', result);
+            expect(result.test).toEqual(expected);
+        });
+    });
+});
+describe('shouldSkipProperty', () => {
+    it('should return true for valueType "formula"', () => {
+        const result = (0, entity_builder_helpers_1.shouldSkipProperty)(null, entity_types_1.PropertyType.Formula);
+        expect(result).toBe(true);
+    });
+    it('should return false for empty string or text value', () => {
+        const result = (0, entity_builder_helpers_1.shouldSkipProperty)('', entity_types_1.PropertyType.String);
+        expect(result).toBe(false);
+    });
+    it.each(Object.values(entity_types_1.PropertyType).filter((x) => x !== entity_types_1.PropertyType.Formula))('should not skip boolean value for  "%s" type', (valueType) => {
+        const result = (0, entity_builder_helpers_1.shouldSkipProperty)(false, valueType);
+        expect(result).toBe(false);
+    });
+    it('should return false for empty string value and valueType "Text"', () => {
+        const result = (0, entity_builder_helpers_1.shouldSkipProperty)('', entity_types_1.PropertyType.Text);
+        expect(result).toBe(false);
+    });
+    it('should return false for valueType "Boolean"', () => {
+        const result = (0, entity_builder_helpers_1.shouldSkipProperty)(false, entity_types_1.PropertyType.Boolean);
+        expect(result).toBe(false);
+    });
+    it('should return false for falsy number value', () => {
+        const result = (0, entity_builder_helpers_1.shouldSkipProperty)(0, entity_types_1.PropertyType.Number);
+        expect(result).toBe(false);
+    });
+    it('should return false for valueType "Single Select" and an empty string', () => {
+        const result = (0, entity_builder_helpers_1.shouldSkipProperty)('', entity_types_1.PropertyType.SingleSelect);
+        expect(result).toBe(false);
+    });
+});

package/node_modules/@contrail/loader/lib/common/file-helper.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export declare function uploadFileAsStream(uploadPost: any, buffer: Buffer, contentType?: string): Promise<unknown>;

package/node_modules/@contrail/loader/lib/common/file-helper.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadFileAsStream = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const FormData = require('form-data');
+async function uploadFileAsStream(uploadPost, buffer, contentType) {
+    const formData = new FormData();
+    formData.append('Content-Type', contentType);
+    appendUploadHeaders(uploadPost, formData);
+    formData.append('file', buffer);
+    return new Promise((res, rej) => {
+        formData.getLength(async (err, len) => {
+            if (err) {
+                rej(err);
+            }
+            const response = await (0, node_fetch_1.default)(uploadPost.url, {
+                method: 'POST',
+                body: formData,
+                headers: {
+                    'Content-Length': len,
+                },
+            });
+            const text = await response.text();
+            console.debug('text: ', text);
+            res('ok');
+        });
+    });
+}
+exports.uploadFileAsStream = uploadFileAsStream;
+function appendUploadHeaders(uploadPost, formData) {
+    Object.entries(uploadPost.fields).forEach(([k, v]) => {
+        formData.append(k, v);
+    });
+}

package/node_modules/@contrail/loader/lib/common/file-helper.spec.d.ts

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

package/node_modules/@contrail/loader/lib/common/file-helper.spec.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const file_helper_1 = require("./file-helper");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const form_data_1 = __importDefault(require("form-data"));
+jest.mock('node-fetch');
+jest.mock('form-data');
+describe('uploadFileAsStream', () => {
+    const mockFetch = node_fetch_1.default;
+    const mockFormData = form_data_1.default;
+    beforeEach(() => {
+        mockFetch.mockClear();
+        mockFormData.mockClear();
+    });
+    it('should upload file as stream successfully', async () => {
+        const uploadPost = {
+            url: 'http://example.com/upload',
+            fields: {
+                key1: 'value1',
+                key2: 'value2',
+            },
+        };
+        const buffer = Buffer.from('test buffer');
+        const contentType = 'application/octet-stream';
+        const mockResponse = {
+            text: jest.fn().mockResolvedValue('response text'),
+        };
+        mockFetch.mockResolvedValue(mockResponse);
+        const formDataInstance = new form_data_1.default();
+        formDataInstance.append = jest.fn();
+        formDataInstance.getLength = jest.fn((callback) => callback(null, 123));
+        mockFormData.mockImplementation(() => formDataInstance);
+        const result = await (0, file_helper_1.uploadFileAsStream)(uploadPost, buffer, contentType);
+        expect(result).toBe('ok');
+        expect(formDataInstance.append).toHaveBeenCalledWith('Content-Type', contentType);
+        expect(formDataInstance.append).toHaveBeenCalledWith('file', buffer);
+        expect(mockFetch).toHaveBeenCalledWith(uploadPost.url, {
+            method: 'POST',
+            body: formDataInstance,
+            headers: {
+                'Content-Length': 123,
+            },
+        });
+        expect(mockResponse.text).toHaveBeenCalled();
+    });
+    it('should reject if formData.getLength returns an error', async () => {
+        const uploadPost = {
+            url: 'http://example.com/upload',
+            fields: {
+                key1: 'value1',
+                key2: 'value2',
+            },
+        };
+        const buffer = Buffer.from('test buffer');
+        const contentType = 'application/octet-stream';
+        const formDataInstance = new form_data_1.default();
+        formDataInstance.append = jest.fn();
+        formDataInstance.getLength = jest.fn((callback) => callback(new Error('getLength error'), 0));
+        mockFormData.mockImplementation(() => formDataInstance);
+        await expect((0, file_helper_1.uploadFileAsStream)(uploadPost, buffer, contentType)).rejects.toThrow('getLength error');
+    });
+});

package/node_modules/@contrail/loader/lib/common/size-range-helpers.d.ts

@@ -0,0 +1,42 @@
+import { EntitiesClient } from '@contrail/entity-types';
+import { TypesByPath } from './entities-helper';
+export declare function getSizeRangeTemplates(client: EntitiesClient, ids: string[]): Promise<any[]>;
+interface TwoDimensionalSizeRange {
+    sizes: {
+        [key: string]: Array<string>;
+    };
+}
+interface OneDimensionalSizeRange {
+    sizes: Array<string>;
+}
+declare type SizeRange = OneDimensionalSizeRange | TwoDimensionalSizeRange;
+export interface SizeRangeTemplate {
+    sizeRange: SizeRange;
+}
+export declare class SizeRangeError {
+    sizeRangeTemplate: SizeRangeTemplate;
+    passedSizeRangeSizes: Array<string>;
+    sizeRangeDimension?: string;
+    errorMessage: string;
+    constructor(options: {
+        sizeRangeTemplate: SizeRangeTemplate;
+        passedSizeRangeSizes: Array<string>;
+        errorMessage: string;
+        sizeRangeDimension: any;
+    });
+}
+export declare const SIZE_RANGE_SLUG = "sizeRange";
+export declare const SIZE_RANGE_TEMPLATE_SLUG = "sizeRangeTemplate";
+export declare const SIZE_RANGE_TEMPLATE_SLUG_ID = "sizeRangeTemplateId";
+export declare class SizeRangeSanitizer {
+    private warnings;
+    constructor();
+    getWarnings(): SizeRangeError[];
+    getWarningsAsStringList(): string[];
+    sanitizeSizeRanges(client: EntitiesClient, typesByPath: TypesByPath, incomingEntities: any[]): Promise<SizeRangeError[]>;
+    cleanSizeRangeInEntity(entity: any, sizeRangeTemplates: any[]): SizeRangeError[];
+    validateOneDimensionalSizeRanges(sizeRangeTemplate: any, entity: any): void;
+    validateTwoDimensionalSizeRanges(sizeRangeTemplate: any, entity: any): void;
+    recordSizeRangeError(errorMessage: string, sizeRangeTemplate?: SizeRangeTemplate, passedSizeRangeSizes?: Array<string>, sizeRangeDimension?: string): void;
+}
+export {};

package/node_modules/@contrail/loader/lib/common/size-range-helpers.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SizeRangeSanitizer = exports.SIZE_RANGE_TEMPLATE_SLUG_ID = exports.SIZE_RANGE_TEMPLATE_SLUG = exports.SIZE_RANGE_SLUG = exports.SizeRangeError = exports.getSizeRangeTemplates = void 0;
+const lodash_1 = require("lodash");
+async function getSizeRangeTemplates(client, ids) {
+    const sizeRangeTemplates = [];
+    for (const batch of (0, lodash_1.chunk)([...new Set(ids)], 10)) {
+        const sizeRangeTemplatesBatch = await client.get({
+            entityName: 'size-range-template',
+            criteria: { ids: batch },
+        });
+        sizeRangeTemplates.push(...sizeRangeTemplatesBatch);
+    }
+    return sizeRangeTemplates;
+}
+exports.getSizeRangeTemplates = getSizeRangeTemplates;
+class SizeRangeError {
+    sizeRangeTemplate;
+    passedSizeRangeSizes;
+    sizeRangeDimension;
+    errorMessage;
+    constructor(options) {
+        this.sizeRangeTemplate = options.sizeRangeTemplate;
+        this.passedSizeRangeSizes = options.passedSizeRangeSizes;
+        this.sizeRangeDimension = options.sizeRangeDimension;
+        this.errorMessage = options.errorMessage;
+    }
+}
+exports.SizeRangeError = SizeRangeError;
+exports.SIZE_RANGE_SLUG = 'sizeRange';
+exports.SIZE_RANGE_TEMPLATE_SLUG = 'sizeRangeTemplate';
+exports.SIZE_RANGE_TEMPLATE_SLUG_ID = 'sizeRangeTemplateId';
+class SizeRangeSanitizer {
+    warnings = [];
+    constructor() {
+        this.warnings = [];
+    }
+    getWarnings() {
+        return this.warnings;
+    }
+    getWarningsAsStringList() {
+        return this.warnings.map((x) => JSON.stringify(x));
+    }
+    async sanitizeSizeRanges(client, typesByPath, incomingEntities) {
+        try {
+            const validTypePaths = [];
+            const typePaths = Array.from(new Set(incomingEntities.map((x) => x.typePath)));
+            for (const typePath of typePaths) {
+                const type = typesByPath[typePath]?.type;
+                if (!type) {
+                    console.debug(`No type found for ${typePath}, skipping.`);
+                    continue;
+                }
+                const typePropertySlugs = type?.typeProperties?.map((x) => x.slug);
+                if ((0, lodash_1.intersection)(typePropertySlugs, [exports.SIZE_RANGE_SLUG, exports.SIZE_RANGE_TEMPLATE_SLUG]).length !== 2) {
+                    console.debug(`No size ranges for type ${JSON.stringify(type, null, 2)}, skipping.`);
+                    continue;
+                }
+                validTypePaths.push(typePath);
+            }
+            const validEntities = incomingEntities.filter((x) => validTypePaths.includes(x.typePath));
+            const sizeRangeTemplateIds = validEntities.map((x) => x[exports.SIZE_RANGE_TEMPLATE_SLUG_ID]).filter((x) => !!x);
+            const sizeRangeTemplates = await getSizeRangeTemplates(client, sizeRangeTemplateIds);
+            for (const entity of validEntities) {
+                this.cleanSizeRangeInEntity(entity, sizeRangeTemplates);
+            }
+            return this.warnings;
+        }
+        catch (error) {
+            console.error('Error sanitizing size ranges', error);
+            return this.warnings;
+        }
+    }
+    cleanSizeRangeInEntity(entity, sizeRangeTemplates) {
+        if (!entity[exports.SIZE_RANGE_TEMPLATE_SLUG_ID]) {
+            return;
+        }
+        const sizeRangeTemplate = sizeRangeTemplates.find((x) => x.id === entity[exports.SIZE_RANGE_TEMPLATE_SLUG_ID]);
+        if (!sizeRangeTemplate) {
+            this.recordSizeRangeError(`No size range template found for ${entity[exports.SIZE_RANGE_TEMPLATE_SLUG_ID]}`, null, null, null);
+            return;
+        }
+        if (!sizeRangeTemplate?.sizeRange?.sizes) {
+            this.recordSizeRangeError('Encountered a size range template with a bad format.', sizeRangeTemplate, null, null);
+            return;
+        }
+        const isOneDimensionalSizeRange = Array.isArray(sizeRangeTemplate.sizeRange.sizes);
+        const isTwoDimensionalSizeRange = Object.keys(sizeRangeTemplate.sizeRange.sizes).length > 0;
+        if (isOneDimensionalSizeRange) {
+            this.validateOneDimensionalSizeRanges(sizeRangeTemplate, entity);
+        }
+        else if (isTwoDimensionalSizeRange) {
+            this.validateTwoDimensionalSizeRanges(sizeRangeTemplate, entity);
+        }
+        else {
+            this.recordSizeRangeError('Encountered an Unknown size range template format', sizeRangeTemplate, null, null);
+        }
+    }
+    validateOneDimensionalSizeRanges(sizeRangeTemplate, entity) {
+        if (!entity[exports.SIZE_RANGE_SLUG]) {
+            return;
+        }
+        const allowedSizes = sizeRangeTemplate?.sizeRange?.sizes ?? [];
+        const incomingSizes = entity[exports.SIZE_RANGE_SLUG]?.sizes ?? [];
+        const appliedSizes = (0, lodash_1.intersection)(allowedSizes, incomingSizes);
+        const invalidSizes = (0, lodash_1.difference)(incomingSizes, allowedSizes);
+        if (invalidSizes.length > 0) {
+            this.recordSizeRangeError('Invalid sizes found for size range template', sizeRangeTemplate, invalidSizes, null);
+        }
+        const validSizes = { sizes: appliedSizes };
+        entity[exports.SIZE_RANGE_SLUG] = validSizes;
+    }
+    validateTwoDimensionalSizeRanges(sizeRangeTemplate, entity) {
+        if (!entity[exports.SIZE_RANGE_SLUG]) {
+            return;
+        }
+        const allowedSizes = { sizes: {} };
+        for (const [dimensionName, sizes] of Object.entries(sizeRangeTemplate.sizeRange.sizes)) {
+            if (!Array.isArray(sizes)) {
+                this.recordSizeRangeError('Invalid size range format for template', sizeRangeTemplate, null, null);
+                continue;
+            }
+            allowedSizes.sizes[dimensionName] = [...sizes];
+        }
+        const incomingSizes = entity[exports.SIZE_RANGE_SLUG];
+        const invalidSizes = { sizes: {} };
+        const appliedSizes = { sizes: {} };
+        for (const dimensionName of Object.keys(allowedSizes.sizes)) {
+            appliedSizes.sizes[dimensionName] = [];
+        }
+        for (const [dimensionName, dimensionSizes] of Object.entries(incomingSizes.sizes)) {
+            if (!Array.isArray(dimensionSizes)) {
+                this.recordSizeRangeError('Dimension is not in the correct format. Must be an array of strings.', sizeRangeTemplate, dimensionSizes, dimensionName);
+                continue;
+            }
+            if (!allowedSizes.sizes[dimensionName]) {
+                invalidSizes.sizes[dimensionName] = [...dimensionSizes];
+                continue;
+            }
+            appliedSizes.sizes[dimensionName] = (0, lodash_1.intersection)(allowedSizes.sizes[dimensionName], dimensionSizes);
+            invalidSizes.sizes[dimensionName] = (0, lodash_1.difference)(dimensionSizes, allowedSizes.sizes[dimensionName]);
+        }
+        for (const [dimensionName, value] of Object.entries(invalidSizes.sizes)) {
+            if (value.length > 0) {
+                this.recordSizeRangeError('Invalid size.', sizeRangeTemplate, value, dimensionName);
+            }
+        }
+        if (Object.keys(appliedSizes.sizes)?.length) {
+            entity[exports.SIZE_RANGE_SLUG] = appliedSizes;
+        }
+    }
+    recordSizeRangeError(errorMessage, sizeRangeTemplate = null, passedSizeRangeSizes = null, sizeRangeDimension = null) {
+        console.warn(errorMessage);
+        this.warnings.push(new SizeRangeError({
+            sizeRangeTemplate,
+            passedSizeRangeSizes,
+            sizeRangeDimension,
+            errorMessage,
+        }));
+    }
+}
+exports.SizeRangeSanitizer = SizeRangeSanitizer;

package/node_modules/@contrail/loader/lib/common/size-range-helpers.spec.d.ts

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