@cronn/lib-file-snapshots 0.9.0 → 0.11.0

package/dist/index.d.ts

@@ -1,4 +1,8 @@
 interface SnapshotSerializer {
+    /**
+     * The file extension associated with the serialized value
+     */
+    readonly fileExtension: string;
     /**
      * Returns true when value can be serialized
      *
@@ -9,19 +13,10 @@ interface SnapshotSerializer {
      * Serializes value
      *
      * @param value The value to be serialized
+     * @return {string} The serialized value
      * @throws {Error} Will throw an error if value cannot be serialized.
      */
-    serialize(value: unknown): SnapshotSerializerResult;
-}
-interface SnapshotSerializerResult {
-    /**
-     * The serialized value
-     */
-    serializedValue: string;
-    /**
-     * The file extension associated with the serialized value
-     */
-    fileExtension: string;
+    serialize(value: unknown): string;
 }
 
 interface JsonSerializerOptions {
@@ -42,11 +37,12 @@ interface JsonNormalizerContext {
     index?: number;
 }
 declare class JsonSerializer implements SnapshotSerializer {
+    readonly fileExtension = "json";
     private readonly includeUndefinedObjectProperties;
     private readonly normalizers;
     constructor(options?: JsonSerializerOptions);
     canSerialize(_value: unknown): boolean;
-    serialize(value: unknown): SnapshotSerializerResult;
+    serialize(value: unknown): string;
     private normalizeValueRecursive;
     private normalizeNumber;
     private normalizeArray;
@@ -67,10 +63,11 @@ interface TextSerializerOptions {
 }
 type TextNormalizer = (value: string) => string;
 declare class TextSerializer implements SnapshotSerializer {
+    readonly fileExtension = "txt";
     private readonly normalizers;
     constructor(options?: TextSerializerOptions);
     canSerialize(value: unknown): value is string;
-    serialize(value: unknown): SnapshotSerializerResult;
+    serialize(value: unknown): string;
     private normalizeValue;
 }
 
@@ -87,8 +84,6 @@ interface ValidationFileMatcherConfig {
      * @default "data/test/output"
      */
     outputDir?: string;
-}
-interface MatchValidationFileOptions {
     /**
      * The full path to the current test file
      *
@@ -120,20 +115,25 @@ interface MatchValidationFileOptions {
 }
 type SnapshotNamingStrategy = "file" | "fileSuffix";
 interface ValidationFileMatcherResult {
+    isValidationFileMissing: boolean;
     actual: string;
     expected: string;
-    actualFile: string;
-    validationFile: string;
+    outputFilePath: string;
+    validationFilePath: string;
     message: () => string;
+    writeFileSnapshots: () => void;
 }
 
 declare class ValidationFileMatcher {
-    private readonly validationDir;
-    private readonly outputDir;
-    constructor(config?: ValidationFileMatcherConfig);
-    matchFileSnapshot(actual: unknown, options: MatchValidationFileOptions): ValidationFileMatcherResult;
-    private buildValidationFilePath;
+    private readonly serializer;
+    private readonly filePaths;
+    private readonly validationFile;
+    constructor(config: ValidationFileMatcherConfig);
+    matchFileSnapshot(actual: unknown): ValidationFileMatcherResult;
+    private buildFilePaths;
     private applyNamingStrategy;
+    private readValidationFile;
+    private createMatcherResult;
     private writeFileSnapshots;
 }
 
@@ -142,4 +142,4 @@ declare function isArray(value: unknown): value is Array<unknown>;
 type PlainObject = Record<PropertyKey, unknown>;
 declare function isPlainObject(value: unknown): value is PlainObject;
 
-export { type JsonNormalizer, type JsonNormalizerContext, JsonSerializer, type PlainObject, type SnapshotNamingStrategy, type SnapshotSerializer, type TextNormalizer, TextSerializer, ValidationFileMatcher, isArray, isPlainObject, isString };
+export { type JsonNormalizer, type JsonNormalizerContext, JsonSerializer, type PlainObject, type SnapshotNamingStrategy, type SnapshotSerializer, type TextNormalizer, TextSerializer, ValidationFileMatcher, type ValidationFileMatcherResult, isArray, isPlainObject, isString };

package/dist/index.js

@@ -1,3 +1,28 @@
+// src/utils/file.ts
+import fs from "fs";
+import path from "path";
+var NEW_LINE_SEPARATOR = "\n";
+var EMOJI_REGEXP = /(?!(\*|#|\d))[\p{Extended_Pictographic}\p{Emoji_Component}]|[\u0030-\u0039]\ufe0f?[\u20e3]|[\u002A\u0023]?\ufe0f?[\u20e3]/gu;
+function normalizeFileName(testName) {
+  return testName.replaceAll(EMOJI_REGEXP, "").replaceAll(/[+*%~<>?!$#'"`|\\/()[\]{}]/g, "").replaceAll(/[\s.:,;]+/g, "_").replaceAll(/_{2,}/g, "_");
+}
+function readSnapshotFile(path3) {
+  return fs.readFileSync(path3, { encoding: "utf8" });
+}
+function writeSnapshotFile(file, data) {
+  mkdirRecursive(path.dirname(file));
+  fs.writeFileSync(file, data, { encoding: "utf8" });
+}
+function mkdirRecursive(path3) {
+  fs.mkdirSync(path3, { recursive: true });
+}
+function addTrailingNewLine(data) {
+  return `${data}${NEW_LINE_SEPARATOR}`;
+}
+function addMissingFileMarker(data) {
+  return `===== missing file =====${NEW_LINE_SEPARATOR}${data}`;
+}
+
 // src/utils/guards.ts
 function isString(value) {
   return typeof value === "string";
@@ -18,6 +43,7 @@ function isPlainObject(value) {
 
 // src/serializers/json-serializer.ts
 var JsonSerializer = class {
+  fileExtension = "json";
   includeUndefinedObjectProperties;
   normalizers;
   constructor(options = {}) {
@@ -29,11 +55,8 @@ var JsonSerializer = class {
   }
   serialize(value) {
     const jsonValue = this.normalizeValueRecursive(value);
-    const serializedValue = JSON.stringify(jsonValue, void 0, 2);
-    return {
-      serializedValue,
-      fileExtension: "json"
-    };
+    const jsonString = JSON.stringify(jsonValue, void 0, 2);
+    return addTrailingNewLine(jsonString);
   }
   normalizeValueRecursive(value, context) {
     const customValue = this.applyCustomNormalizers(value, context);
@@ -179,6 +202,7 @@ var JsonSerializer = class {
 
 // src/serializers/text-serializer.ts
 var TextSerializer = class {
+  fileExtension = "txt";
   normalizers;
   constructor(options = {}) {
     this.normalizers = options.normalizers ?? [];
@@ -192,10 +216,8 @@ var TextSerializer = class {
         `Missing text serialization for value of type ${typeof value}.`
       );
     }
-    return {
-      serializedValue: this.normalizeValue(value),
-      fileExtension: "txt"
-    };
+    const normalizedValue = this.normalizeValue(value);
+    return addTrailingNewLine(normalizedValue);
   }
   normalizeValue(value) {
     let normalizedValue = value;
@@ -208,72 +230,54 @@ var TextSerializer = class {
 
 // src/matcher/validation-file-matcher.ts
 import * as fs2 from "fs";
-import * as path from "path";
-
-// src/utils/file.ts
-import fs from "fs";
-var NEW_LINE_SEPARATOR = "\n";
-function normalizeFileName(testName) {
-  return testName.replaceAll(/[+*%~<>?!$#'"`|\\/()[\]{}]/g, "").replaceAll(/[\s.:,;]+/g, "_").replaceAll(/_{2,}/g, "_");
-}
-function mkdirRecursive(path2) {
-  fs.mkdirSync(path2, { recursive: true });
-}
-function readSnapshotFile(path2) {
-  return fs.readFileSync(path2, { encoding: "utf8" });
-}
-function writeSnapshotFile(file, data, markAsMissing = false) {
-  let finalizedData = addTrailingNewLine(data);
-  if (markAsMissing) {
-    finalizedData = addMissingFileMarker(finalizedData);
-  }
-  fs.writeFileSync(file, finalizedData, { encoding: "utf8" });
-}
-function addTrailingNewLine(data) {
-  return `${data}${NEW_LINE_SEPARATOR}`;
-}
-function addMissingFileMarker(data) {
-  return `===== missing file =====${NEW_LINE_SEPARATOR}${data}`;
-}
-
-// src/matcher/validation-file-matcher.ts
+import * as path2 from "path";
 var ValidationFileMatcher = class {
-  validationDir;
-  outputDir;
-  constructor(config = {}) {
-    this.validationDir = config.validationDir ?? "data/test/validation";
-    this.outputDir = config.outputDir ?? "data/test/output";
+  serializer;
+  filePaths;
+  validationFile;
+  constructor(config) {
+    this.serializer = config.serializer;
+    this.filePaths = this.buildFilePaths(config);
+    this.validationFile = this.readValidationFile();
   }
-  matchFileSnapshot(actual, options) {
-    const { testPath, titlePath, name, namingStrategy, serializer } = options;
-    if (!serializer.canSerialize(actual)) {
+  matchFileSnapshot(actual) {
+    if (!this.serializer.canSerialize(actual)) {
       throw new Error(`Cannot serialize value of type ${typeof actual}`);
     }
-    const serializerResult = serializer.serialize(actual);
-    const validationFilePath = this.buildValidationFilePath({
-      titlePath,
-      testPath,
-      name,
-      namingStrategy,
-      fileExtension: serializerResult.fileExtension
+    const serializedActual = this.serializer.serialize(actual);
+    if (this.validationFile === void 0) {
+      return this.createMatcherResult({
+        isValidationFileMissing: true,
+        actual: serializedActual,
+        expected: addMissingFileMarker(serializedActual)
+      });
+    }
+    return this.createMatcherResult({
+      isValidationFileMissing: false,
+      actual: serializedActual,
+      expected: this.validationFile
     });
-    return this.writeFileSnapshots(
-      serializerResult.serializedValue,
-      validationFilePath
-    );
   }
-  buildValidationFilePath(options) {
-    const { testPath, titlePath, name, namingStrategy, fileExtension } = options;
-    const normalizedTitlePath = titlePath.map(normalizeFileName);
-    const filePath = path.join(testPath, ...normalizedTitlePath);
-    const fullFilePath = this.applyNamingStrategy(
-      filePath,
-      name,
-      namingStrategy
+  buildFilePaths(config) {
+    const validationDir = config.validationDir ?? "data/test/validation";
+    const outputDir = config.outputDir ?? "data/test/output";
+    const normalizedTitlePath = config.titlePath.map(normalizeFileName);
+    const relativeFilePath = path2.join(config.testPath, ...normalizedTitlePath);
+    const relativeFilePathWithName = this.applyNamingStrategy(
+      relativeFilePath,
+      config.name,
+      config.namingStrategy
     );
-    return `${fullFilePath}.${fileExtension}`;
+    const relativeFilePathWithExtension = `${relativeFilePathWithName}.${this.serializer.fileExtension}`;
+    return {
+      outputFilePath: path2.join(outputDir, relativeFilePathWithExtension),
+      validationFilePath: path2.join(
+        validationDir,
+        relativeFilePathWithExtension
+      )
+    };
   }
-  applyNamingStrategy(filePath, snapshotName, namingStrategy) {
+  applyNamingStrategy(filePath, snapshotName, namingStrategy = "file") {
     if (snapshotName === void 0) {
       return filePath;
     }
@@ -281,29 +285,37 @@ var ValidationFileMatcher = class {
     if (namingStrategy === "fileSuffix") {
       return `${filePath}_${normalizedSnapshotName}`;
     }
-    return path.join(filePath, normalizedSnapshotName);
+    return path2.join(filePath, normalizedSnapshotName);
   }
-  writeFileSnapshots(actual, validationFilePath) {
-    const validationFileDir = path.dirname(validationFilePath);
-    const testOutputDir = `${this.outputDir}/${validationFileDir}`;
-    const actualFile = `${this.outputDir}/${validationFilePath}`;
-    const testValidationDir = `${this.validationDir}/${validationFileDir}`;
-    const validationFile = `${this.validationDir}/${validationFilePath}`;
-    mkdirRecursive(testOutputDir);
-    mkdirRecursive(testValidationDir);
-    if (!fs2.existsSync(validationFile)) {
-      writeSnapshotFile(validationFile, actual, true);
+  readValidationFile() {
+    const { validationFilePath } = this.filePaths;
+    if (!fs2.existsSync(validationFilePath)) {
+      return void 0;
     }
-    writeSnapshotFile(actualFile, actual);
+    return readSnapshotFile(validationFilePath);
+  }
+  createMatcherResult(params) {
+    const { isValidationFileMissing, actual, expected } = params;
+    const { outputFilePath, validationFilePath } = this.filePaths;
     return {
-      actual: readSnapshotFile(actualFile),
-      expected: readSnapshotFile(validationFile),
-      actualFile,
-      validationFile,
-      message: () => `Actual file '${actualFile}'
-does not match validation file '${validationFile}'`
+      isValidationFileMissing,
+      actual,
+      expected,
+      outputFilePath,
+      validationFilePath,
+      message: () => isValidationFileMissing ? `Missing validation file '${validationFilePath}'` : `Output file '${outputFilePath}'
+does not match validation file '${validationFilePath}'`,
+      writeFileSnapshots: () => this.writeFileSnapshots(params)
     };
   }
+  writeFileSnapshots(matcherResult) {
+    const { actual, expected } = matcherResult;
+    const { outputFilePath, validationFilePath } = this.filePaths;
+    writeSnapshotFile(outputFilePath, actual);
+    if (matcherResult.isValidationFileMissing) {
+      writeSnapshotFile(validationFilePath, expected);
+    }
+  }
 };
 export {
   JsonSerializer,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cronn/lib-file-snapshots",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "The library agnostic core for testing file snapshots",
   "keywords": [
     "file snapshots"
@@ -33,28 +33,25 @@
   ],
   "devDependencies": {
     "@trivago/prettier-plugin-sort-imports": "5.2.2",
-    "@types/node": "22.15.30",
+    "@types/node": "22.16.5",
     "@vitest/coverage-istanbul": "3.2.4",
-    "eslint": "9.30.1",
-    "eslint-config-prettier": "10.1.5",
+    "eslint": "9.32.0",
+    "eslint-config-prettier": "10.1.8",
     "eslint-plugin-unused-imports": "4.1.4",
-    "jiti": "2.4.2",
+    "jiti": "2.5.1",
     "prettier": "3.6.2",
     "tsup": "8.5.0",
     "typescript": "5.8.3",
-    "typescript-eslint": "8.36.0",
+    "typescript-eslint": "8.38.0",
     "vitest": "3.2.4",
     "@cronn/shared-configs": "0.0.0"
   },
   "scripts": {
     "lint:check": "eslint src/ --max-warnings=0",
     "lint:fix": "eslint src/ --max-warnings=0 --fix",
-    "check": "pnpm run compile && pnpm run lint:check",
-    "fix": "pnpm run lint:fix",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "compile": "tsc",
-    "build": "tsup",
-    "ci": "pnpm run check && pnpm run test:coverage && pnpm run build"
+    "build": "tsup"
   }
 }