@augment-vir/common 15.1.0 → 15.2.1

package/dist/cjs/augments/json.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseJson = void 0;
+exports.areJsonEqual = exports.stringifyJson = exports.parseJson = void 0;
+const error_1 = require("./error");
 const matches_object_shape_1 = require("./object/matches-object-shape");
+const object_1 = require("./object/object");
 const runtime_type_of_1 = require("./runtime-type-of");
 function parseJson({ jsonString, errorHandler, shapeMatcher, }) {
     try {
@@ -26,3 +28,71 @@ function parseJson({ jsonString, errorHandler, shapeMatcher, }) {
     }
 }
 exports.parseJson = parseJson;
+function stringifyJson({ source, whitespace, errorHandler, }) {
+    try {
+        const stringifiedJson = JSON.stringify(source, undefined, whitespace);
+        return stringifiedJson;
+    }
+    catch (error) {
+        if (errorHandler) {
+            return errorHandler(error);
+        }
+        else {
+            throw error;
+        }
+    }
+}
+exports.stringifyJson = stringifyJson;
+const areJsonEqualFailureMessage = 'Failed to compare objects using JSON.stringify';
+function baseAreJsonEqual(a, b, ignoreStringifyErrors) {
+    return (stringifyJson({
+        source: a,
+        errorHandler(error) {
+            if (ignoreStringifyErrors) {
+                return '';
+            }
+            else {
+                throw error;
+            }
+        },
+    }) ===
+        stringifyJson({
+            source: b,
+            errorHandler(error) {
+                if (ignoreStringifyErrors) {
+                    return '';
+                }
+                else {
+                    throw error;
+                }
+            },
+        }));
+}
+function areJsonEqual(a, b, options = {}) {
+    try {
+        if (a === b) {
+            return true;
+        }
+        if ((0, object_1.isObject)(a) && (0, object_1.isObject)(b)) {
+            const areKeysEqual = baseAreJsonEqual(Object.keys(a).sort(), Object.keys(b).sort(), !!options?.ignoreNonSerializableProperties);
+            if (!areKeysEqual) {
+                return false;
+            }
+            return Object.keys(a).every((keyName) => {
+                return areJsonEqual(a[keyName], b[keyName]);
+            });
+        }
+        else {
+            return baseAreJsonEqual(a, b, !!options?.ignoreNonSerializableProperties);
+        }
+    }
+    catch (caught) {
+        const error = (0, error_1.ensureError)(caught);
+        if (error.message.startsWith(areJsonEqualFailureMessage)) {
+            throw error;
+        }
+        error.message = `${areJsonEqualFailureMessage}: ${error.message}`;
+        throw error;
+    }
+}
+exports.areJsonEqual = areJsonEqual;

package/dist/cjs/augments/object/object.js

@@ -1,43 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.copyThroughJson = exports.areJsonEqual = exports.isObject = void 0;
-const error_1 = require("../error");
+exports.copyThroughJson = exports.isObject = void 0;
 function isObject(input) {
     return !!input && typeof input === 'object';
 }
 exports.isObject = isObject;
-const areJsonEqualFailureMessage = 'Failed to compare objects using JSON.stringify';
-function baseAreJsonEqual(a, b) {
-    return JSON.stringify(a) === JSON.stringify(b);
-}
-function areJsonEqual(a, b) {
-    try {
-        if (a === b) {
-            return true;
-        }
-        if (isObject(a) && isObject(b)) {
-            const areKeysEqual = baseAreJsonEqual(Object.keys(a).sort(), Object.keys(b).sort());
-            if (!areKeysEqual) {
-                return false;
-            }
-            return Object.keys(a).every((keyName) => {
-                return areJsonEqual(a[keyName], b[keyName]);
-            });
-        }
-        else {
-            return baseAreJsonEqual(a, b);
-        }
-    }
-    catch (caught) {
-        const error = (0, error_1.ensureError)(caught);
-        if (error.message.startsWith(areJsonEqualFailureMessage)) {
-            throw error;
-        }
-        error.message = `${areJsonEqualFailureMessage}: ${error.message}`;
-        throw error;
-    }
-}
-exports.areJsonEqual = areJsonEqual;
 /** The input here must be serializable otherwise JSON parsing errors will be thrown */
 function copyThroughJson(input) {
     try {

package/dist/esm/augments/json.js

@@ -1,4 +1,6 @@
+import { ensureError } from './error';
 import { assertMatchesObjectShape } from './object/matches-object-shape';
+import { isObject } from './object/object';
 import { assertRuntimeTypeOf, getRuntimeTypeOf, isRuntimeTypeOf } from './runtime-type-of';
 export function parseJson({ jsonString, errorHandler, shapeMatcher, }) {
     try {
@@ -22,3 +24,69 @@ export function parseJson({ jsonString, errorHandler, shapeMatcher, }) {
         }
     }
 }
+export function stringifyJson({ source, whitespace, errorHandler, }) {
+    try {
+        const stringifiedJson = JSON.stringify(source, undefined, whitespace);
+        return stringifiedJson;
+    }
+    catch (error) {
+        if (errorHandler) {
+            return errorHandler(error);
+        }
+        else {
+            throw error;
+        }
+    }
+}
+const areJsonEqualFailureMessage = 'Failed to compare objects using JSON.stringify';
+function baseAreJsonEqual(a, b, ignoreStringifyErrors) {
+    return (stringifyJson({
+        source: a,
+        errorHandler(error) {
+            if (ignoreStringifyErrors) {
+                return '';
+            }
+            else {
+                throw error;
+            }
+        },
+    }) ===
+        stringifyJson({
+            source: b,
+            errorHandler(error) {
+                if (ignoreStringifyErrors) {
+                    return '';
+                }
+                else {
+                    throw error;
+                }
+            },
+        }));
+}
+export function areJsonEqual(a, b, options = {}) {
+    try {
+        if (a === b) {
+            return true;
+        }
+        if (isObject(a) && isObject(b)) {
+            const areKeysEqual = baseAreJsonEqual(Object.keys(a).sort(), Object.keys(b).sort(), !!options?.ignoreNonSerializableProperties);
+            if (!areKeysEqual) {
+                return false;
+            }
+            return Object.keys(a).every((keyName) => {
+                return areJsonEqual(a[keyName], b[keyName]);
+            });
+        }
+        else {
+            return baseAreJsonEqual(a, b, !!options?.ignoreNonSerializableProperties);
+        }
+    }
+    catch (caught) {
+        const error = ensureError(caught);
+        if (error.message.startsWith(areJsonEqualFailureMessage)) {
+            throw error;
+        }
+        error.message = `${areJsonEqualFailureMessage}: ${error.message}`;
+        throw error;
+    }
+}

package/dist/esm/augments/object/object.js

@@ -1,38 +1,6 @@
-import { ensureError } from '../error';
 export function isObject(input) {
     return !!input && typeof input === 'object';
 }
-const areJsonEqualFailureMessage = 'Failed to compare objects using JSON.stringify';
-function baseAreJsonEqual(a, b) {
-    return JSON.stringify(a) === JSON.stringify(b);
-}
-export function areJsonEqual(a, b) {
-    try {
-        if (a === b) {
-            return true;
-        }
-        if (isObject(a) && isObject(b)) {
-            const areKeysEqual = baseAreJsonEqual(Object.keys(a).sort(), Object.keys(b).sort());
-            if (!areKeysEqual) {
-                return false;
-            }
-            return Object.keys(a).every((keyName) => {
-                return areJsonEqual(a[keyName], b[keyName]);
-            });
-        }
-        else {
-            return baseAreJsonEqual(a, b);
-        }
-    }
-    catch (caught) {
-        const error = ensureError(caught);
-        if (error.message.startsWith(areJsonEqualFailureMessage)) {
-            throw error;
-        }
-        error.message = `${areJsonEqualFailureMessage}: ${error.message}`;
-        throw error;
-    }
-}
 /** The input here must be serializable otherwise JSON parsing errors will be thrown */
 export function copyThroughJson(input) {
     try {

package/dist/types/augments/json.d.ts

@@ -1,5 +1,14 @@
+import { JsonCompatibleValue } from './json-compatible';
 export declare function parseJson<ParsedJsonGeneric>({ jsonString, errorHandler, shapeMatcher, }: {
     jsonString: string;
     errorHandler?: (error: unknown) => never | ParsedJsonGeneric;
     shapeMatcher?: ParsedJsonGeneric;
 }): ParsedJsonGeneric;
+export declare function stringifyJson({ source, whitespace, errorHandler, }: {
+    source: unknown;
+    whitespace?: number;
+    errorHandler?: (error: unknown) => string | never;
+}): string;
+export declare function areJsonEqual(a: Readonly<JsonCompatibleValue | undefined>, b: Readonly<JsonCompatibleValue | undefined>, options?: Partial<{
+    ignoreNonSerializableProperties: boolean | undefined;
+}>): boolean;

package/dist/types/augments/object/object.d.ts

@@ -1,4 +1,3 @@
-import { JsonCompatibleValue } from '../json-compatible';
 export type PartialAndNullable<T extends object> = {
     [Prop in keyof T]?: T[Prop] | null | undefined;
 };
@@ -6,7 +5,6 @@ export type PartialAndUndefined<T extends object> = {
     [Prop in keyof T]?: T[Prop] | undefined;
 };
 export declare function isObject(input: any): input is NonNullable<object>;
-export declare function areJsonEqual(a: Readonly<JsonCompatibleValue | undefined>, b: Readonly<JsonCompatibleValue | undefined>): boolean;
 /** The input here must be serializable otherwise JSON parsing errors will be thrown */
 export declare function copyThroughJson<T>(input: T): T;
 export type PropertyValueType<T> = T[keyof T];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@augment-vir/common",
-    "version": "15.1.0",
+    "version": "15.2.1",
     "homepage": "https://github.com/electrovir/augment-vir/tree/main/packages/common",
     "bugs": {
         "url": "https://github.com/electrovir/augment-vir/issues"