helm-env-delta 1.0.0

package/dist/jsonReporter.d.ts

@@ -0,0 +1,70 @@
+import { Config } from './configFile';
+import { FileDiffResult } from './fileDiff';
+import { ValidationResult } from './stopRulesValidator';
+declare const JsonReporterErrorClass: {
+    new (message: string, options?: import("./utils/errors").ErrorOptions): {
+        [key: string]: unknown;
+        readonly code?: string;
+        readonly path?: string;
+        readonly cause?: Error;
+        name: string;
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare class JsonReporterError extends JsonReporterErrorClass {
+}
+export declare const isJsonReporterError: (error: unknown) => error is JsonReporterError;
+export interface JsonReportMetadata {
+    timestamp: string;
+    source: string;
+    destination: string;
+    dryRun: boolean;
+    version: string;
+}
+export interface JsonReportSummary {
+    added: number;
+    deleted: number;
+    changed: number;
+    formatted: number;
+    unchanged: number;
+}
+export interface FieldChange {
+    path: string;
+    oldValue: unknown;
+    updatedValue: unknown;
+}
+export interface ChangedFileDetail {
+    path: string;
+    diff: string;
+    changes: FieldChange[];
+}
+export interface JsonReportFiles {
+    added: string[];
+    deleted: string[];
+    changed: ChangedFileDetail[];
+    formatted: string[];
+    unchanged: string[];
+}
+export interface StopRuleViolationJson {
+    file: string;
+    rule: {
+        type: string;
+        path: string;
+    };
+    path: string;
+    oldValue: unknown;
+    updatedValue: unknown;
+    message: string;
+}
+export interface JsonReport {
+    metadata: JsonReportMetadata;
+    summary: JsonReportSummary;
+    files: JsonReportFiles;
+    stopRuleViolations: StopRuleViolationJson[];
+}
+export declare const generateJsonReport: (diffResult: FileDiffResult, formattedFiles: string[], validationResult: ValidationResult, config: Config, dryRun: boolean, version: string) => void;
+export {};

package/dist/jsonReporter.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateJsonReport = exports.isJsonReporterError = exports.JsonReporterError = void 0;
+const deepEqual_1 = require("./utils/deepEqual");
+const diffGenerator_1 = require("./utils/diffGenerator");
+const errors_1 = require("./utils/errors");
+const JsonReporterErrorClass = (0, errors_1.createErrorClass)('JSON Reporter Error', {});
+class JsonReporterError extends JsonReporterErrorClass {
+}
+exports.JsonReporterError = JsonReporterError;
+exports.isJsonReporterError = (0, errors_1.createErrorTypeGuard)(JsonReporterError);
+const isPrimitive = (value) => {
+    return value === undefined || value === null || typeof value !== 'object';
+};
+const isObject = (value) => {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+const formatJsonPath = (path) => {
+    if (path.length === 0)
+        return '$';
+    return `$.${path.join('.')}`;
+};
+const detectDeepChanges = (oldData, updatedData, currentPath = []) => {
+    const changes = [];
+    if (isPrimitive(oldData) || isPrimitive(updatedData)) {
+        if (!(0, deepEqual_1.deepEqual)(oldData, updatedData))
+            changes.push({
+                path: formatJsonPath(currentPath),
+                oldValue: oldData,
+                updatedValue: updatedData
+            });
+        return changes;
+    }
+    if (Array.isArray(oldData) && Array.isArray(updatedData)) {
+        if (!(0, deepEqual_1.deepEqual)(oldData, updatedData))
+            changes.push({
+                path: formatJsonPath(currentPath),
+                oldValue: `Array with ${oldData.length} item(s)`,
+                updatedValue: `Array with ${updatedData.length} item(s)`
+            });
+        return changes;
+    }
+    if (Array.isArray(oldData) !== Array.isArray(updatedData)) {
+        changes.push({
+            path: formatJsonPath(currentPath),
+            oldValue: Array.isArray(oldData) ? `Array with ${oldData.length} item(s)` : oldData,
+            updatedValue: Array.isArray(updatedData) ? `Array with ${updatedData.length} item(s)` : updatedData
+        });
+        return changes;
+    }
+    if (isObject(oldData) && isObject(updatedData)) {
+        const allKeys = new Set([...Object.keys(oldData), ...Object.keys(updatedData)]);
+        for (const key of allKeys) {
+            const oldValue = oldData[key];
+            const updatedValue = updatedData[key];
+            const subChanges = detectDeepChanges(oldValue, updatedValue, [...currentPath, key]);
+            changes.push(...subChanges);
+        }
+    }
+    return changes;
+};
+const generateChangedFileDetail = (file) => {
+    const diff = (0, diffGenerator_1.generateUnifiedDiff)(file.path, file.destinationContent, file.sourceContent);
+    const changes = detectDeepChanges(file.processedDestContent, file.processedSourceContent);
+    return {
+        path: file.path,
+        diff,
+        changes
+    };
+};
+const generateJsonReport = (diffResult, formattedFiles, validationResult, config, dryRun, version) => {
+    try {
+        const metadata = {
+            timestamp: new Date().toISOString(),
+            source: config.source,
+            destination: config.destination,
+            dryRun,
+            version
+        };
+        const summary = {
+            added: diffResult.addedFiles.length,
+            deleted: diffResult.deletedFiles.length,
+            changed: diffResult.changedFiles.length,
+            formatted: formattedFiles.length,
+            unchanged: diffResult.unchangedFiles.length
+        };
+        const changedFileDetails = diffResult.changedFiles.map((file) => generateChangedFileDetail(file));
+        const files = {
+            added: diffResult.addedFiles,
+            deleted: diffResult.deletedFiles,
+            changed: changedFileDetails,
+            formatted: formattedFiles,
+            unchanged: diffResult.unchangedFiles
+        };
+        const stopRuleViolations = validationResult.violations.map((violation) => ({
+            file: violation.file,
+            rule: {
+                type: violation.rule.type,
+                path: violation.rule.path
+            },
+            path: violation.path,
+            oldValue: violation.oldValue,
+            updatedValue: violation.updatedValue,
+            message: violation.message
+        }));
+        const report = {
+            metadata,
+            summary,
+            files,
+            stopRuleViolations
+        };
+        console.log(JSON.stringify(report, undefined, 2));
+    }
+    catch (error) {
+        if (error instanceof Error)
+            throw new JsonReporterError('Failed to generate JSON report', {
+                cause: error
+            });
+        throw new JsonReporterError('Failed to generate JSON report');
+    }
+};
+exports.generateJsonReport = generateJsonReport;

package/dist/stopRulesValidator.d.ts

@@ -0,0 +1,33 @@
+import { StopRule } from './configFile';
+import { FileDiffResult } from './fileDiff';
+declare const StopRulesValidatorErrorClass: {
+    new (message: string, options?: import("./utils/errors").ErrorOptions): {
+        [key: string]: unknown;
+        readonly code?: string;
+        readonly path?: string;
+        readonly cause?: Error;
+        name: string;
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare class StopRulesValidatorError extends StopRulesValidatorErrorClass {
+}
+export declare const isStopRulesValidatorError: (error: unknown) => error is StopRulesValidatorError;
+export interface StopRuleViolation {
+    file: string;
+    rule: StopRule;
+    path: string;
+    oldValue: unknown;
+    updatedValue: unknown;
+    message: string;
+}
+export interface ValidationResult {
+    violations: StopRuleViolation[];
+    isValid: boolean;
+}
+export declare const validateStopRules: (diffResult: FileDiffResult, stopRulesConfig?: Record<string, StopRule[]>) => ValidationResult;
+export {};

package/dist/stopRulesValidator.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateStopRules = exports.isStopRulesValidatorError = exports.StopRulesValidatorError = void 0;
+const picomatch_1 = require("picomatch");
+const errors_1 = require("./utils/errors");
+const jsonPath_1 = require("./utils/jsonPath");
+const StopRulesValidatorErrorClass = (0, errors_1.createErrorClass)('Stop Rules Validator Error', {}, (message, options) => {
+    let fullMessage = `Stop Rules Validator Error: ${message}`;
+    if (options.code)
+        fullMessage += `\n  Code: ${options.code}`;
+    if (options['violations'] && Array.isArray(options['violations']) && options['violations'].length > 0) {
+        fullMessage += `\n  Violations (${options['violations'].length}):`;
+        for (const v of options['violations'])
+            fullMessage += `\n    - ${v.file}:${v.path} (${v.rule.type})`;
+    }
+    if (options.cause)
+        fullMessage += `\n  Cause: ${options.cause.message}`;
+    return fullMessage;
+});
+class StopRulesValidatorError extends StopRulesValidatorErrorClass {
+}
+exports.StopRulesValidatorError = StopRulesValidatorError;
+exports.isStopRulesValidatorError = (0, errors_1.createErrorTypeGuard)(StopRulesValidatorError);
+const validateStopRules = (diffResult, stopRulesConfig) => {
+    if (!stopRulesConfig)
+        return { violations: [], isValid: true };
+    const violations = [];
+    for (const changedFile of diffResult.changedFiles) {
+        const fileViolations = validateFileAgainstRules(changedFile, stopRulesConfig);
+        violations.push(...fileViolations);
+    }
+    return {
+        violations,
+        isValid: violations.length === 0
+    };
+};
+exports.validateStopRules = validateStopRules;
+const validateFileAgainstRules = (changedFile, stopRulesConfig) => {
+    const violations = [];
+    const applicableRules = getApplicableRules(changedFile.path, stopRulesConfig);
+    if (applicableRules.length === 0)
+        return violations;
+    const oldData = changedFile.processedDestContent;
+    const updatedData = changedFile.processedSourceContent;
+    for (const rule of applicableRules) {
+        const violation = validateRule(rule, oldData, updatedData, changedFile.path);
+        if (violation)
+            violations.push(violation);
+    }
+    return violations;
+};
+const getApplicableRules = (filePath, stopRulesConfig) => {
+    const rules = [];
+    for (const [pattern, ruleList] of Object.entries(stopRulesConfig))
+        if ((0, picomatch_1.isMatch)(filePath, pattern))
+            rules.push(...ruleList);
+    return rules;
+};
+const validateRule = (rule, oldData, updatedData, filePath) => {
+    const pathParts = (0, jsonPath_1.parseJsonPath)(rule.path);
+    const oldValue = oldData ? (0, jsonPath_1.getValueAtPath)(oldData, pathParts) : undefined;
+    const updatedValue = updatedData ? (0, jsonPath_1.getValueAtPath)(updatedData, pathParts) : undefined;
+    if (oldValue === undefined && updatedValue === undefined)
+        return undefined;
+    switch (rule.type) {
+        case 'semverMajorUpgrade':
+            return validateSemverMajorUpgrade(rule, oldValue, updatedValue, filePath);
+        case 'semverDowngrade':
+            return validateSemverDowngrade(rule, oldValue, updatedValue, filePath);
+        case 'numeric':
+            return validateNumeric(rule, oldValue, updatedValue, filePath);
+        case 'regex':
+            return validateRegex(rule, oldValue, updatedValue, filePath);
+        default:
+            return undefined;
+    }
+};
+const validateSemverMajorUpgrade = (rule, oldValue, updatedValue, filePath) => {
+    if (oldValue === undefined || updatedValue === undefined)
+        return undefined;
+    const oldVersion = String(oldValue);
+    const updatedVersion = String(updatedValue);
+    const oldMajor = parseMajorVersion(oldVersion);
+    const updatedMajor = parseMajorVersion(updatedVersion);
+    if (oldMajor === undefined || updatedMajor === undefined)
+        return undefined;
+    if (updatedMajor > oldMajor)
+        return {
+            file: filePath,
+            rule,
+            path: rule.path,
+            oldValue,
+            updatedValue,
+            message: `Major version upgrade detected: ${oldVersion} → ${updatedVersion}`
+        };
+    return undefined;
+};
+const validateSemverDowngrade = (rule, oldValue, updatedValue, filePath) => {
+    if (oldValue === undefined || updatedValue === undefined)
+        return undefined;
+    const oldVersion = String(oldValue);
+    const updatedVersion = String(updatedValue);
+    const oldMajor = parseMajorVersion(oldVersion);
+    const updatedMajor = parseMajorVersion(updatedVersion);
+    if (oldMajor === undefined || updatedMajor === undefined)
+        return undefined;
+    if (updatedMajor < oldMajor)
+        return {
+            file: filePath,
+            rule,
+            path: rule.path,
+            oldValue,
+            updatedValue,
+            message: `Major version downgrade detected: ${oldVersion} → ${updatedVersion}`
+        };
+    return undefined;
+};
+const validateNumeric = (rule, oldValue, updatedValue, filePath) => {
+    const valueToCheck = updatedValue === undefined ? oldValue : updatedValue;
+    if (valueToCheck === undefined)
+        return undefined;
+    const numberValue = Number(valueToCheck);
+    if (Number.isNaN(numberValue))
+        return undefined;
+    if (rule.min !== undefined && numberValue < rule.min)
+        return {
+            file: filePath,
+            rule,
+            path: rule.path,
+            oldValue,
+            updatedValue,
+            message: `Value ${numberValue} is below minimum ${rule.min}`
+        };
+    if (rule.max !== undefined && numberValue > rule.max)
+        return {
+            file: filePath,
+            rule,
+            path: rule.path,
+            oldValue,
+            updatedValue,
+            message: `Value ${numberValue} exceeds maximum ${rule.max}`
+        };
+    return undefined;
+};
+const validateRegex = (rule, oldValue, updatedValue, filePath) => {
+    const valueToCheck = updatedValue === undefined ? oldValue : updatedValue;
+    if (valueToCheck === undefined)
+        return undefined;
+    const stringValue = String(valueToCheck);
+    const pattern = new RegExp(rule.regex);
+    if (pattern.test(stringValue))
+        return {
+            file: filePath,
+            rule,
+            path: rule.path,
+            oldValue,
+            updatedValue,
+            message: `Value "${stringValue}" matches forbidden pattern ${rule.regex}`
+        };
+    return undefined;
+};
+const parseMajorVersion = (version) => {
+    const cleaned = version.startsWith('v') ? version.slice(1) : version;
+    const match = /^(\d+)/.exec(cleaned);
+    if (!match || !match[1])
+        return undefined;
+    return Number.parseInt(match[1], 10);
+};

package/dist/utils/deepEqual.d.ts

@@ -0,0 +1 @@
+export declare const deepEqual: (a: unknown, b: unknown) => boolean;

package/dist/utils/deepEqual.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepEqual = void 0;
+const serialization_1 = require("./serialization");
+const deepEqual = (a, b) => {
+    const normalizedA = (0, serialization_1.normalizeForComparison)(a);
+    const normalizedB = (0, serialization_1.normalizeForComparison)(b);
+    return deepEqualStructural(normalizedA, normalizedB);
+};
+exports.deepEqual = deepEqual;
+const deepEqualStructural = (a, b) => {
+    if (a === b)
+        return true;
+    if (a === null || b === null)
+        return a === b;
+    if (a === undefined || b === undefined)
+        return a === b;
+    const typeA = typeof a;
+    const typeB = typeof b;
+    if (typeA !== typeB)
+        return false;
+    if (typeA === 'string' || typeA === 'number' || typeA === 'boolean')
+        return a === b;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length)
+            return false;
+        for (let index = 0; index < a.length; index++)
+            if (!deepEqualStructural(a[index], b[index]))
+                return false;
+        return true;
+    }
+    if (typeA === 'object' && typeB === 'object') {
+        const objectA = a;
+        const objectB = b;
+        const keysA = Object.keys(objectA).toSorted();
+        const keysB = Object.keys(objectB).toSorted();
+        if (keysA.length !== keysB.length)
+            return false;
+        for (const [index, key] of keysA.entries()) {
+            if (!key || key !== keysB[index])
+                return false;
+            if (!deepEqualStructural(objectA[key], objectB[key]))
+                return false;
+        }
+        return true;
+    }
+    return false;
+};

package/dist/utils/diffGenerator.d.ts

@@ -0,0 +1 @@
+export declare const generateUnifiedDiff: (filePath: string, destinationContent: string, sourceContent: string) => string;

package/dist/utils/diffGenerator.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUnifiedDiff = void 0;
+const diff_1 = require("diff");
+const generateUnifiedDiff = (filePath, destinationContent, sourceContent) => {
+    return (0, diff_1.createTwoFilesPatch)(filePath, filePath, destinationContent, sourceContent, 'Destination', 'Source');
+};
+exports.generateUnifiedDiff = generateUnifiedDiff;

package/dist/utils/errors.d.ts

@@ -0,0 +1,23 @@
+export interface ErrorOptions {
+    code?: string;
+    path?: string;
+    cause?: Error;
+    [key: string]: unknown;
+}
+type ErrorFormatter = (message: string, options: ErrorOptions) => string;
+export declare const createErrorClass: (errorName: string, codeExplanations?: Record<string, string>, customFormatter?: ErrorFormatter) => {
+    new (message: string, options?: ErrorOptions): {
+        [key: string]: unknown;
+        readonly code?: string;
+        readonly path?: string;
+        readonly cause?: Error;
+        name: string;
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare const createErrorTypeGuard: <T extends Error>(ErrorClass: new (...arguments_: any[]) => T) => (error: unknown) => error is T;
+export {};

package/dist/utils/errors.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createErrorTypeGuard = exports.createErrorClass = void 0;
+const createErrorClass = (errorName, codeExplanations = {}, customFormatter) => {
+    const formatMessage = (message, options) => {
+        if (customFormatter)
+            return customFormatter(message, options);
+        let fullMessage = `${errorName}: ${message}`;
+        if (options.path)
+            fullMessage += `\n  Path: ${options.path}`;
+        if (options.code) {
+            const explanation = codeExplanations[options.code] || `Error (${options.code})`;
+            fullMessage += `\n  Reason: ${explanation}`;
+        }
+        if (options.cause)
+            fullMessage += `\n  Details: ${options.cause.message}`;
+        return fullMessage;
+    };
+    class CustomError extends Error {
+        code;
+        path;
+        cause;
+        constructor(message, options = {}) {
+            super(formatMessage(message, options));
+            this.name = 'CustomError';
+            Object.defineProperty(this, 'name', { value: errorName, enumerable: false });
+            this.code = options.code;
+            this.path = options.path;
+            this.cause = options.cause;
+            for (const [key, value] of Object.entries(options))
+                if (key !== 'code' && key !== 'path' && key !== 'cause')
+                    this[key] = value;
+        }
+    }
+    return CustomError;
+};
+exports.createErrorClass = createErrorClass;
+const createErrorTypeGuard = (ErrorClass) => (error) => error instanceof ErrorClass;
+exports.createErrorTypeGuard = createErrorTypeGuard;

package/dist/utils/fileType.d.ts

@@ -0,0 +1 @@
+export declare const isYamlFile: (filePath: string) => boolean;

package/dist/utils/fileType.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isYamlFile = void 0;
+const YAML_FILE_REGEX = /\.ya?ml$/i;
+const isYamlFile = (filePath) => {
+    return YAML_FILE_REGEX.test(filePath);
+};
+exports.isYamlFile = isYamlFile;

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+export type { ErrorOptions } from './errors';
+export { createErrorClass, createErrorTypeGuard } from './errors';
+export { deepEqual } from './deepEqual';
+export { normalizeForComparison, serializeForDiff } from './serialization';
+export { getValueAtPath, parseJsonPath } from './jsonPath';
+export { isYamlFile } from './fileType';
+export { generateUnifiedDiff } from './diffGenerator';

package/dist/utils/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUnifiedDiff = exports.isYamlFile = exports.parseJsonPath = exports.getValueAtPath = exports.serializeForDiff = exports.normalizeForComparison = exports.deepEqual = exports.createErrorTypeGuard = exports.createErrorClass = void 0;
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "createErrorClass", { enumerable: true, get: function () { return errors_1.createErrorClass; } });
+Object.defineProperty(exports, "createErrorTypeGuard", { enumerable: true, get: function () { return errors_1.createErrorTypeGuard; } });
+var deepEqual_1 = require("./deepEqual");
+Object.defineProperty(exports, "deepEqual", { enumerable: true, get: function () { return deepEqual_1.deepEqual; } });
+var serialization_1 = require("./serialization");
+Object.defineProperty(exports, "normalizeForComparison", { enumerable: true, get: function () { return serialization_1.normalizeForComparison; } });
+Object.defineProperty(exports, "serializeForDiff", { enumerable: true, get: function () { return serialization_1.serializeForDiff; } });
+var jsonPath_1 = require("./jsonPath");
+Object.defineProperty(exports, "getValueAtPath", { enumerable: true, get: function () { return jsonPath_1.getValueAtPath; } });
+Object.defineProperty(exports, "parseJsonPath", { enumerable: true, get: function () { return jsonPath_1.parseJsonPath; } });
+var fileType_1 = require("./fileType");
+Object.defineProperty(exports, "isYamlFile", { enumerable: true, get: function () { return fileType_1.isYamlFile; } });
+var diffGenerator_1 = require("./diffGenerator");
+Object.defineProperty(exports, "generateUnifiedDiff", { enumerable: true, get: function () { return diffGenerator_1.generateUnifiedDiff; } });

package/dist/utils/jsonPath.d.ts

@@ -0,0 +1,2 @@
+export declare const parseJsonPath: (path: string) => string[];
+export declare const getValueAtPath: (object: unknown, path: string[]) => unknown;

package/dist/utils/jsonPath.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValueAtPath = exports.parseJsonPath = void 0;
+const parseJsonPath = (path) => {
+    return path
+        .replaceAll(/\[(\*|\d+)]/g, '.$1')
+        .split('.')
+        .filter((part) => part.length > 0);
+};
+exports.parseJsonPath = parseJsonPath;
+const getValueAtPath = (object, path) => {
+    let current = object;
+    for (const part of path) {
+        if (!current || typeof current !== 'object')
+            return undefined;
+        if (Array.isArray(current)) {
+            if (part === '*')
+                return undefined;
+            const index = Number(part);
+            if (Number.isNaN(index))
+                return undefined;
+            current = current[index];
+        }
+        else
+            current = current[part];
+    }
+    return current;
+};
+exports.getValueAtPath = getValueAtPath;

package/dist/utils/serialization.d.ts

@@ -0,0 +1,2 @@
+export declare const serializeForDiff: (content: unknown, isYaml: boolean) => string;
+export declare const normalizeForComparison: (value: unknown) => unknown;

package/dist/utils/serialization.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeForComparison = exports.serializeForDiff = void 0;
+const yaml_1 = __importDefault(require("yaml"));
+const serializeForDiff = (content, isYaml) => {
+    if (!isYaml)
+        return String(content);
+    return yaml_1.default.stringify(content, {
+        indent: 2,
+        lineWidth: 0,
+        sortMapEntries: true
+    });
+};
+exports.serializeForDiff = serializeForDiff;
+const normalizeForComparison = (value) => {
+    if (value === null || value === undefined)
+        return value;
+    const valueType = typeof value;
+    if (valueType === 'string' || valueType === 'number' || valueType === 'boolean')
+        return value;
+    if (Array.isArray(value)) {
+        const normalized = value.map((item) => (0, exports.normalizeForComparison)(item));
+        return normalized.toSorted((a, b) => {
+            const stringA = yaml_1.default.stringify(a, { sortMapEntries: true });
+            const stringB = yaml_1.default.stringify(b, { sortMapEntries: true });
+            return stringA.localeCompare(stringB);
+        });
+    }
+    if (typeof value === 'object') {
+        const normalized = {};
+        for (const [key, value_] of Object.entries(value))
+            normalized[key] = (0, exports.normalizeForComparison)(value_);
+        return normalized;
+    }
+    return value;
+};
+exports.normalizeForComparison = normalizeForComparison;

package/dist/utils/transformer.d.ts

@@ -0,0 +1,21 @@
+import type { TransformRule } from '../configFile';
+declare const TransformerErrorClass: {
+    new (message: string, options?: import("./errors").ErrorOptions): {
+        [key: string]: unknown;
+        readonly code?: string;
+        readonly path?: string;
+        readonly cause?: Error;
+        name: string;
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare class TransformerError extends TransformerErrorClass {
+}
+export declare const isTransformerError: (error: unknown) => error is TransformerError;
+export declare const getTransformsForFile: (filePath: string, transforms?: Record<string, TransformRule[]>) => TransformRule[];
+export declare const applyTransforms: (data: unknown, filePath: string, transforms?: Record<string, TransformRule[]>) => unknown;
+export {};