@cronn/lib-file-snapshots 0.4.0 → 0.6.0

package/dist/index.d.ts

@@ -31,14 +31,22 @@ interface JsonSerializerOptions {
      * @default false
      */
     includeUndefinedObjectProperties?: boolean;
+    /**
+     * Custom normalizers to apply before serialization
+     */
+    normalizers?: JsonNormalizer[];
+}
+type JsonNormalizer = (value: unknown, context: JsonNormalizerContext) => unknown;
+interface JsonNormalizerContext {
+    key?: string;
 }
 declare class JsonSerializer implements SnapshotSerializer {
     private readonly includeUndefinedObjectProperties;
+    private readonly normalizers;
     constructor(options?: JsonSerializerOptions);
     canSerialize(value: unknown): boolean;
     serialize(value: unknown): SnapshotSerializerResult;
     private normalizeValueRecursive;
-    private normalizeValue;
     private normalizeNumber;
     private normalizeArray;
     private normalizeObject;
@@ -47,9 +55,19 @@ declare class JsonSerializer implements SnapshotSerializer {
     private normalizeMap;
     private serializedValue;
     private assertKeyType;
+    private applyCustomNormalizers;
 }
 
+interface TextSerializerOptions {
+    /**
+     * Custom normalizers to apply before serialization
+     */
+    normalizers?: TextNormalizer[];
+}
+type TextNormalizer = (value: string) => string;
 declare class TextSerializer implements SnapshotSerializer {
+    private readonly normalizers;
+    constructor(options?: TextSerializerOptions);
     canSerialize(value: unknown): value is string;
     serialize(value: unknown): SnapshotSerializerResult;
     private normalizeValue;
@@ -110,4 +128,9 @@ declare class ValidationFileMatcher {
     private writeFileSnapshots;
 }
 
-export { JsonSerializer, type SnapshotSerializer, TextSerializer, ValidationFileMatcher };
+declare function isString(value: unknown): value is string;
+declare function isArray(value: unknown): value is unknown[];
+type PlainObject = Record<PropertyKey, unknown>;
+declare function isPlainObject(value: unknown): value is PlainObject;
+
+export { type JsonNormalizer, type JsonNormalizerContext, JsonSerializer, type PlainObject, type SnapshotSerializer, type TextNormalizer, TextSerializer, ValidationFileMatcher, isArray, isPlainObject, isString };

package/dist/index.js

@@ -1,4 +1,7 @@
 // src/utils/guards.ts
+function isString(value) {
+  return typeof value === "string";
+}
 function isArray(value) {
   return Array.isArray(value);
 }
@@ -16,56 +19,54 @@ function isPlainObject(value) {
 // src/serializers/json-serializer.ts
 var JsonSerializer = class {
   includeUndefinedObjectProperties;
+  normalizers;
   constructor(options = {}) {
     this.includeUndefinedObjectProperties = options.includeUndefinedObjectProperties ?? false;
+    this.normalizers = options.normalizers ?? [];
   }
   canSerialize(value) {
     return true;
   }
   serialize(value) {
-    const jsonValue = isPlainObject(value) || isArray(value) ? this.normalizeValueRecursive(value) : this.normalizeValue(value);
+    const jsonValue = this.normalizeValueRecursive(value);
     const serializedValue = JSON.stringify(jsonValue, void 0, 2);
     return {
       serializedValue,
       fileExtension: "json"
     };
   }
-  normalizeValueRecursive(value) {
-    if (isArray(value)) {
-      return this.normalizeArray(value);
-    }
-    if (isPlainObject(value)) {
-      return this.normalizePlainObject(value);
-    }
-    if (typeof value === "string" || typeof value === "boolean" || value === null) {
-      return value;
-    }
-    return this.normalizeValue(value);
-  }
-  normalizeValue(value) {
-    if (value === void 0) {
+  normalizeValueRecursive(value, context) {
+    const customValue = this.applyCustomNormalizers(value, context);
+    if (customValue === void 0) {
       return this.serializedValue("undefined");
     }
-    if (value === null || typeof value === "string" || typeof value === "boolean") {
-      return this.serializedValue(typeof value, { value });
+    if (customValue === null || isString(customValue) || typeof customValue === "boolean") {
+      const isRoot = context === void 0;
+      return isRoot ? this.serializedValue(typeof customValue, {
+        value: customValue
+      }) : customValue;
     }
-    if (typeof value === "number") {
-      return this.normalizeNumber(value);
+    if (typeof customValue === "number") {
+      return this.normalizeNumber(customValue);
     }
-    if (typeof value === "bigint") {
-      return this.serializedValue("bigint", { value: value.toString() });
+    if (typeof customValue === "bigint") {
+      return this.serializedValue("bigint", {
+        value: customValue.toString()
+      });
     }
-    if (typeof value === "symbol") {
-      return this.serializedValue("symbol", { description: value.description });
+    if (typeof customValue === "symbol") {
+      return this.serializedValue("symbol", {
+        description: customValue.description
+      });
     }
-    if (typeof value === "function") {
-      return this.serializedValue("function", { name: value.name });
+    if (typeof customValue === "function") {
+      return this.serializedValue("function", { name: customValue.name });
     }
-    if (typeof value === "object") {
-      return this.normalizeObject(value);
+    if (typeof customValue === "object") {
+      return this.normalizeObject(customValue);
     }
     throw new Error(
-      `Missing JSON normalization for value of type ${typeof value}.`
+      `Missing JSON normalization for value of type ${typeof customValue}.`
     );
   }
   normalizeNumber(value) {
@@ -98,9 +99,17 @@ var JsonSerializer = class {
     }
   }
   normalizeArray(value) {
-    return value.map((item) => this.normalizeValueRecursive(item));
+    return value.map(
+      (item, index) => this.normalizeValueRecursive(item, { key: index.toString() })
+    );
   }
   normalizeObject(value) {
+    if (isArray(value)) {
+      return this.normalizeArray(value);
+    }
+    if (isPlainObject(value)) {
+      return this.normalizePlainObject(value);
+    }
     if (value instanceof Date) {
       return this.normalizeDate(value);
     }
@@ -135,7 +144,9 @@ var JsonSerializer = class {
         continue;
       }
       this.assertKeyType(key);
-      normalizedObject[key] = this.normalizeValueRecursive(propertyValue);
+      normalizedObject[key] = this.normalizeValueRecursive(propertyValue, {
+        key
+      });
     }
     return normalizedObject;
   }
@@ -153,16 +164,27 @@ var JsonSerializer = class {
     return { $type: type, ...additionalProps };
   }
   assertKeyType(key) {
-    if (!(typeof key === "string")) {
+    if (!isString(key)) {
       throw new Error(`Key of type ${typeof key} cannot be normalized.`);
     }
   }
+  applyCustomNormalizers(value, context = {}) {
+    let normalizedValue = value;
+    for (const normalizer of this.normalizers) {
+      normalizedValue = normalizer(normalizedValue, context);
+    }
+    return normalizedValue;
+  }
 };
 
 // src/serializers/text-serializer.ts
 var TextSerializer = class {
+  normalizers;
+  constructor(options = {}) {
+    this.normalizers = options.normalizers ?? [];
+  }
   canSerialize(value) {
-    return typeof value === "string";
+    return isString(value);
   }
   serialize(value) {
     if (!this.canSerialize(value)) {
@@ -176,7 +198,11 @@ var TextSerializer = class {
     };
   }
   normalizeValue(value) {
-    return value.trim();
+    let normalizedValue = value;
+    for (const normalizer of this.normalizers) {
+      normalizedValue = normalizer(normalizedValue);
+    }
+    return normalizedValue.trim();
   }
 };
 
@@ -269,5 +295,8 @@ does not match validation file '${validationFile}'`
 export {
   JsonSerializer,
   TextSerializer,
-  ValidationFileMatcher
+  ValidationFileMatcher,
+  isArray,
+  isPlainObject,
+  isString
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cronn/lib-file-snapshots",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "The library agnostic core for testing file snapshots",
   "keywords": [
     "file snapshots"