@cronn/lib-file-snapshots 0.12.0 → 0.14.0

package/dist/index.d.ts

@@ -30,6 +30,12 @@ interface JsonSerializerOptions {
      * Custom normalizers to apply before serialization
      */
     normalizers?: Array<JsonNormalizer>;
+    /**
+     * Indentation size in spaces
+     *
+     * @default 2
+     */
+    indentSize?: number;
 }
 type JsonNormalizer = (value: unknown, context: JsonNormalizerContext) => unknown;
 interface JsonNormalizerContext {
@@ -40,6 +46,7 @@ declare class JsonSerializer implements SnapshotSerializer {
     readonly fileExtension = "json";
     private readonly includeUndefinedObjectProperties;
     private readonly normalizers;
+    private readonly indentSize;
     constructor(options?: JsonSerializerOptions);
     canSerialize(_value: unknown): boolean;
     serialize(value: unknown): string;
@@ -85,35 +92,16 @@ interface ValidationFileMatcherConfig {
      */
     outputDir?: string;
     /**
-     * The full path to the current test file
+     * The full path to the snapshot file
      *
-     * @example "src/tests/feature.test.ts"
+     * @example "src/tests/feature/test/when_x_then_y"
      */
-    testPath: string;
-    /**
-     * The full path of titles describing the current test, including nested blocks
-     *
-     * @example ["test A", "when x, then y"]
-     */
-    titlePath: Array<string>;
-    /**
-     * Unique name of the file snapshot
-     *
-     * Used to distinguish multiple file snapshots within the same `test`.
-     */
-    name?: string;
-    /**
-     * The naming strategy to use for storing the file snapshot
-     *
-     * @default "file"
-     */
-    namingStrategy?: SnapshotNamingStrategy;
+    filePath: string;
     /**
      * The serializer to use for the snapshot
      */
     serializer: SnapshotSerializer;
 }
-type SnapshotNamingStrategy = "file" | "fileSuffix";
 interface ValidationFileMatcherResult {
     actual: string;
     expected: string;
@@ -122,6 +110,12 @@ interface ValidationFileMatcherResult {
     message: () => string;
     writeFileSnapshots: () => void;
 }
+type FilePathResolver = (params: FilePathResolverParams) => string;
+interface FilePathResolverParams {
+    testPath: string;
+    titlePath: Array<string>;
+    name?: string;
+}
 
 declare class ValidationFileMatcher {
     private readonly serializer;
@@ -131,15 +125,19 @@ declare class ValidationFileMatcher {
     get isValidationFileMissing(): boolean;
     matchFileSnapshot(actual: unknown): ValidationFileMatcherResult;
     private buildFilePaths;
-    private applyNamingStrategy;
     private readValidationFile;
     private createMatcherResult;
     private writeFileSnapshots;
 }
 
+declare function resolveNameAsFile(params: FilePathResolverParams): string;
+declare function resolveNameAsFileSuffix(params: FilePathResolverParams): string;
+
+declare function normalizeFileName(testName: string): string;
+
 declare function isString(value: unknown): value is string;
 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, type ValidationFileMatcherResult, isArray, isPlainObject, isString };
+export { type FilePathResolver, type FilePathResolverParams, type JsonNormalizer, type JsonNormalizerContext, JsonSerializer, type PlainObject, type SnapshotSerializer, type TextNormalizer, TextSerializer, ValidationFileMatcher, type ValidationFileMatcherResult, isArray, isPlainObject, isString, normalizeFileName, resolveNameAsFile, resolveNameAsFileSuffix };

package/dist/index.js

@@ -6,15 +6,15 @@ var EMOJI_REGEXP = /(?!(\*|#|\d))[\p{Extended_Pictographic}\p{Emoji_Component}]|
 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 readSnapshotFile(path4) {
+  return fs.readFileSync(path4, { 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 mkdirRecursive(path4) {
+  fs.mkdirSync(path4, { recursive: true });
 }
 function addTrailingNewLine(data) {
   return `${data}${NEW_LINE_SEPARATOR}`;
@@ -41,21 +41,33 @@ function isPlainObject(value) {
   return proto === null || proto === Object.prototype;
 }
 
+// src/utils/validators.ts
+function isPositiveInteger(value) {
+  return Number.isInteger(value) && value > 0;
+}
+
 // src/serializers/json-serializer.ts
 var JsonSerializer = class {
   fileExtension = "json";
   includeUndefinedObjectProperties;
   normalizers;
+  indentSize;
   constructor(options = {}) {
+    if (options.indentSize !== void 0 && !isPositiveInteger(options.indentSize)) {
+      throw new Error(
+        "Invalid option indentSize: value must be a positive integer."
+      );
+    }
     this.includeUndefinedObjectProperties = options.includeUndefinedObjectProperties ?? false;
     this.normalizers = options.normalizers ?? [];
+    this.indentSize = options.indentSize ?? 2;
   }
   canSerialize(_value) {
     return true;
   }
   serialize(value) {
     const jsonValue = this.normalizeValueRecursive(value);
-    const jsonString = JSON.stringify(jsonValue, void 0, 2);
+    const jsonString = JSON.stringify(jsonValue, void 0, this.indentSize);
     return addTrailingNewLine(jsonString);
   }
   normalizeValueRecursive(value, context) {
@@ -262,32 +274,12 @@ var ValidationFileMatcher = class {
   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
-    );
-    const relativeFilePathWithExtension = `${relativeFilePathWithName}.${this.serializer.fileExtension}`;
+    const filePathWithExtenion = `${config.filePath}.${config.serializer.fileExtension}`;
     return {
-      outputFilePath: path2.join(outputDir, relativeFilePathWithExtension),
-      validationFilePath: path2.join(
-        validationDir,
-        relativeFilePathWithExtension
-      )
+      outputFilePath: path2.join(outputDir, filePathWithExtenion),
+      validationFilePath: path2.join(validationDir, filePathWithExtenion)
     };
   }
-  applyNamingStrategy(filePath, snapshotName, namingStrategy = "file") {
-    if (snapshotName === void 0) {
-      return filePath;
-    }
-    const normalizedSnapshotName = normalizeFileName(snapshotName);
-    if (namingStrategy === "fileSuffix") {
-      return `${filePath}_${normalizedSnapshotName}`;
-    }
-    return path2.join(filePath, normalizedSnapshotName);
-  }
   readValidationFile() {
     const { validationFilePath } = this.filePaths;
     if (!fs2.existsSync(validationFilePath)) {
@@ -317,11 +309,43 @@ does not match validation file '${validationFilePath}'`,
     }
   }
 };
+
+// src/matcher/file-path-resolver.ts
+import path3 from "path";
+function resolveNameAsFile(params) {
+  return resolveFilePath(
+    params,
+    ({ basePath, normalizedName }) => path3.join(basePath, normalizedName)
+  );
+}
+function resolveNameAsFileSuffix(params) {
+  return resolveFilePath(
+    params,
+    ({ basePath, normalizedName }) => `${basePath}_${normalizedName}`
+  );
+}
+function resolveBasePath(params) {
+  const { testPath, titlePath } = params;
+  const normalizedTitlePath = titlePath.map(normalizeFileName);
+  return path3.join(testPath, ...normalizedTitlePath);
+}
+function resolveFilePath(params, resolveNamedFilePath) {
+  const { name, ...baseParams } = params;
+  const basePath = resolveBasePath(baseParams);
+  if (name === void 0) {
+    return basePath;
+  }
+  const normalizedName = normalizeFileName(name);
+  return resolveNamedFilePath({ basePath, normalizedName });
+}
 export {
   JsonSerializer,
   TextSerializer,
   ValidationFileMatcher,
   isArray,
   isPlainObject,
-  isString
+  isString,
+  normalizeFileName,
+  resolveNameAsFile,
+  resolveNameAsFileSuffix
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cronn/lib-file-snapshots",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "The library agnostic core for testing file snapshots",
   "keywords": [
     "file snapshots"
@@ -33,15 +33,15 @@
   ],
   "devDependencies": {
     "@trivago/prettier-plugin-sort-imports": "5.2.2",
-    "@types/node": "22.16.5",
+    "@types/node": "22.18.0",
     "@vitest/coverage-istanbul": "3.2.4",
-    "eslint": "9.32.0",
+    "eslint": "9.34.0",
     "eslint-config-prettier": "10.1.8",
-    "eslint-plugin-unused-imports": "4.1.4",
+    "eslint-plugin-unused-imports": "4.2.0",
     "prettier": "3.6.2",
     "tsup": "8.5.0",
-    "typescript": "5.8.3",
-    "typescript-eslint": "8.38.0",
+    "typescript": "5.9.2",
+    "typescript-eslint": "8.42.0",
     "vitest": "3.2.4",
     "@cronn/shared-configs": "0.0.0"
   },