@augment-vir/common 25.0.0 → 26.0.0

package/dist/cjs/augments/error.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeAndReturnError = exports.wrapInTry = exports.ensureErrorAndPrependMessage = exports.ensureError = exports.extractErrorMessage = exports.combineErrorMessages = exports.combineErrors = void 0;
+exports.ensureErrorAndPrependMessage = exports.ensureError = exports.extractErrorMessage = exports.combineErrorMessages = exports.combineErrors = void 0;
 const boolean_1 = require("./boolean");
 const typed_has_property_1 = require("./object/typed-has-property");
-const promise_1 = require("./promise/promise");
 function combineErrors(errors) {
     if (!errors || errors.length === 0) {
         return undefined;
@@ -52,56 +51,3 @@ function ensureErrorAndPrependMessage(maybeError, prependMessage) {
     return error;
 }
 exports.ensureErrorAndPrependMessage = ensureErrorAndPrependMessage;
-function wrapInTry(callback, inputs) {
-    try {
-        const returnValue = callback();
-        if (returnValue instanceof Promise) {
-            return returnValue.catch((error) => {
-                if (inputs.catchCallback) {
-                    return inputs.catchCallback(error);
-                }
-                else {
-                    return inputs.fallbackValue;
-                }
-            });
-        }
-        else {
-            return returnValue;
-        }
-    }
-    catch (error) {
-        if (inputs.catchCallback) {
-            return inputs.catchCallback(error);
-        }
-        else {
-            return inputs.fallbackValue;
-        }
-    }
-}
-exports.wrapInTry = wrapInTry;
-function executeAndReturnError(callback) {
-    let caughtError;
-    try {
-        const result = callback();
-        if ((0, promise_1.isPromiseLike)(result)) {
-            return new Promise(async (resolve) => {
-                try {
-                    const output = await result;
-                    return resolve(output);
-                }
-                catch (error) {
-                    caughtError = ensureError(error);
-                }
-                return resolve(caughtError);
-            });
-        }
-        else {
-            return result;
-        }
-    }
-    catch (error) {
-        caughtError = ensureError(error);
-    }
-    return caughtError;
-}
-exports.executeAndReturnError = executeAndReturnError;

package/dist/cjs/augments/json.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.areJsonEqual = exports.stringifyJson = exports.parseJson = void 0;
+exports.stringifyJson = exports.parseJson = void 0;
 const run_time_assertions_1 = require("run-time-assertions");
-const error_1 = require("./error");
 const matches_object_shape_1 = require("./object/matches-object-shape");
-const object_1 = require("./object/object");
+const wrap_in_try_1 = require("./wrap-in-try");
 function parseJson({ jsonString, errorHandler, shapeMatcher, }) {
     try {
         const parsedJson = JSON.parse(jsonString);
@@ -28,71 +27,13 @@ function parseJson({ jsonString, errorHandler, shapeMatcher, }) {
     }
 }
 exports.parseJson = parseJson;
-function stringifyJson({ source, whitespace, errorHandler, }) {
-    try {
-        const stringifiedJson = JSON.stringify(source, undefined, whitespace);
-        return stringifiedJson;
+function stringifyJson(jsonValue, { whitespace, ...tryOptions } = {}) {
+    const result = (0, wrap_in_try_1.wrapInTry)(() => JSON.stringify(jsonValue, undefined, whitespace), tryOptions);
+    if (result instanceof Error) {
+        throw result;
     }
-    catch (error) {
-        if (errorHandler) {
-            return errorHandler(error);
-        }
-        else {
-            throw error;
-        }
+    else {
+        return result;
     }
 }
 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/wrap-in-try.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapInTry = void 0;
+const run_time_assertions_1 = require("run-time-assertions");
+const error_1 = require("./error");
+function wrapInTry(callback, options = {}) {
+    try {
+        const value = callback();
+        if (value instanceof Promise) {
+            return value.catch((error) => {
+                if (options.handleError) {
+                    return options.handleError(error);
+                }
+                else if ((0, run_time_assertions_1.hasProperty)(options, 'fallbackValue')) {
+                    return options.fallbackValue;
+                }
+                else {
+                    return (0, error_1.ensureError)(error);
+                }
+            });
+        }
+        else {
+            return value;
+        }
+    }
+    catch (error) {
+        if (options.handleError) {
+            return options.handleError(error);
+        }
+        else if ((0, run_time_assertions_1.hasProperty)(options, 'fallbackValue')) {
+            return options.fallbackValue;
+        }
+        else {
+            return (0, error_1.ensureError)(error);
+        }
+    }
+}
+exports.wrapInTry = wrapInTry;

package/dist/cjs/index.js

@@ -55,3 +55,4 @@ __exportStar(require("./augments/time"), exports);
 __exportStar(require("./augments/truncate-number"), exports);
 __exportStar(require("./augments/tuple"), exports);
 __exportStar(require("./augments/type"), exports);
+__exportStar(require("./augments/wrap-in-try"), exports);

package/dist/esm/augments/error.js

@@ -1,6 +1,5 @@
 import { isTruthy } from './boolean';
 import { typedHasProperty } from './object/typed-has-property';
-import { isPromiseLike } from './promise/promise';
 export function combineErrors(errors) {
     if (!errors || errors.length === 0) {
         return undefined;
@@ -44,54 +43,3 @@ export function ensureErrorAndPrependMessage(maybeError, prependMessage) {
     error.message = `${prependMessage}: ${error.message}`;
     return error;
 }
-export function wrapInTry(callback, inputs) {
-    try {
-        const returnValue = callback();
-        if (returnValue instanceof Promise) {
-            return returnValue.catch((error) => {
-                if (inputs.catchCallback) {
-                    return inputs.catchCallback(error);
-                }
-                else {
-                    return inputs.fallbackValue;
-                }
-            });
-        }
-        else {
-            return returnValue;
-        }
-    }
-    catch (error) {
-        if (inputs.catchCallback) {
-            return inputs.catchCallback(error);
-        }
-        else {
-            return inputs.fallbackValue;
-        }
-    }
-}
-export function executeAndReturnError(callback) {
-    let caughtError;
-    try {
-        const result = callback();
-        if (isPromiseLike(result)) {
-            return new Promise(async (resolve) => {
-                try {
-                    const output = await result;
-                    return resolve(output);
-                }
-                catch (error) {
-                    caughtError = ensureError(error);
-                }
-                return resolve(caughtError);
-            });
-        }
-        else {
-            return result;
-        }
-    }
-    catch (error) {
-        caughtError = ensureError(error);
-    }
-    return caughtError;
-}

package/dist/esm/augments/json.js

@@ -1,7 +1,6 @@
 import { assertRunTimeType, getRunTimeType, isRunTimeType } from 'run-time-assertions';
-import { ensureError } from './error';
 import { assertMatchesObjectShape } from './object/matches-object-shape';
-import { isObject } from './object/object';
+import { wrapInTry } from './wrap-in-try';
 export function parseJson({ jsonString, errorHandler, shapeMatcher, }) {
     try {
         const parsedJson = JSON.parse(jsonString);
@@ -24,69 +23,12 @@ 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;
-        }
+export function stringifyJson(jsonValue, { whitespace, ...tryOptions } = {}) {
+    const result = wrapInTry(() => JSON.stringify(jsonValue, undefined, whitespace), tryOptions);
+    if (result instanceof Error) {
+        throw result;
     }
-}
-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;
+    else {
+        return result;
     }
 }

package/dist/esm/augments/wrap-in-try.js

@@ -0,0 +1,34 @@
+import { hasProperty } from 'run-time-assertions';
+import { ensureError } from './error';
+export function wrapInTry(callback, options = {}) {
+    try {
+        const value = callback();
+        if (value instanceof Promise) {
+            return value.catch((error) => {
+                if (options.handleError) {
+                    return options.handleError(error);
+                }
+                else if (hasProperty(options, 'fallbackValue')) {
+                    return options.fallbackValue;
+                }
+                else {
+                    return ensureError(error);
+                }
+            });
+        }
+        else {
+            return value;
+        }
+    }
+    catch (error) {
+        if (options.handleError) {
+            return options.handleError(error);
+        }
+        else if (hasProperty(options, 'fallbackValue')) {
+            return options.fallbackValue;
+        }
+        else {
+            return ensureError(error);
+        }
+    }
+}

package/dist/esm/index.js

@@ -39,3 +39,4 @@ export * from './augments/time';
 export * from './augments/truncate-number';
 export * from './augments/tuple';
 export * from './augments/type';
+export * from './augments/wrap-in-try';

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

@@ -1,5 +1,3 @@
-import { RequireExactlyOne } from 'type-fest';
-import { NoInputsFunction } from './function';
 import { AtLeastTuple } from './tuple';
 export declare function combineErrors(errors: AtLeastTuple<Error, 1>): Error;
 export declare function combineErrors(errors: ReadonlyArray<never>): undefined;
@@ -9,10 +7,3 @@ export declare function combineErrorMessages(errors?: ReadonlyArray<Error | stri
 export declare function extractErrorMessage(maybeError: unknown): string;
 export declare function ensureError(maybeError: unknown): Error;
 export declare function ensureErrorAndPrependMessage(maybeError: unknown, prependMessage: string): Error;
-export type TryWrapConfig<FallbackReturn> = RequireExactlyOne<{
-    fallbackValue: FallbackReturn;
-    catchCallback: (error: unknown) => FallbackReturn;
-}>;
-export declare function wrapInTry<CallbackReturn, FallbackReturn>(callback: () => CallbackReturn, inputs: TryWrapConfig<FallbackReturn>): FallbackReturn | CallbackReturn;
-export declare function executeAndReturnError<CallbackGeneric extends NoInputsFunction<PromiseLike<any>>>(callback: CallbackGeneric): Promise<Error | Awaited<ReturnType<CallbackGeneric>>>;
-export declare function executeAndReturnError<CallbackGeneric extends NoInputsFunction>(callback: CallbackGeneric): Error | ReturnType<CallbackGeneric>;

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

@@ -1,14 +1,10 @@
 import { JsonCompatibleValue } from './json-compatible';
+import { WrapInTryOptions } from './wrap-in-try';
 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;
+export declare function stringifyJson(jsonValue: JsonCompatibleValue, { whitespace, ...tryOptions }?: {
     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;
+} & WrapInTryOptions<string>): string;

package/dist/types/augments/wrap-in-try.d.ts

@@ -0,0 +1,40 @@
+import { NoInputsFunction } from './function';
+import { PartialAndUndefined } from './object/object';
+export type WrapInTryOptions<FallbackValue> = PartialAndUndefined<{
+    /**
+     * A callback that is passed the error. The output of this callback is returned by `wrapInTry`.
+     * This takes precedence over the other two options.
+     */
+    handleError: (error: unknown) => FallbackValue;
+    /**
+     * Fallback to this value if the callback passed to `wrapInTry` throws an error. Takes
+     * precedence over `returnError`.
+     */
+    fallbackValue: FallbackValue;
+}>;
+export declare function wrapInTry<Value extends Promise<any>>(callback: NoInputsFunction<Value>, options?: undefined | {
+    handleError?: undefined;
+    fallbackValue?: never;
+}): Promise<Error | Awaited<Value>>;
+export declare function wrapInTry<Value>(callback: NoInputsFunction<Value>, options?: undefined | {
+    handleError?: undefined;
+    fallbackValue?: never;
+}): Error | Value;
+export declare function wrapInTry<Value extends Promise<any>, FallbackValue = undefined>(callback: NoInputsFunction<Value>, options: {
+    handleError: (error: unknown) => FallbackValue;
+    fallbackValue?: FallbackValue;
+}): Promise<Awaited<FallbackValue> | Awaited<Value>>;
+export declare function wrapInTry<Value, FallbackValue = undefined>(callback: NoInputsFunction<Value>, options: {
+    handleError: (error: unknown) => FallbackValue;
+    fallbackValue?: FallbackValue;
+}): FallbackValue | Value;
+export declare function wrapInTry<Value extends Promise<any>, FallbackValue = undefined>(callback: NoInputsFunction<Value>, options: {
+    handleError?: ((error: unknown) => FallbackValue) | undefined;
+    fallbackValue: FallbackValue;
+}): Promise<Awaited<FallbackValue> | Awaited<Value>>;
+export declare function wrapInTry<Value, FallbackValue = undefined>(callback: NoInputsFunction<Value>, options: {
+    handleError?: ((error: unknown) => FallbackValue) | undefined;
+    fallbackValue: FallbackValue;
+}): FallbackValue | Value;
+export declare function wrapInTry<Value extends Promise<any>, FallbackValue = undefined>(callback: NoInputsFunction<Value>, options?: WrapInTryOptions<FallbackValue> | undefined): Promise<FallbackValue | Value | Error>;
+export declare function wrapInTry<Value, FallbackValue = undefined>(callback: NoInputsFunction<Value>, options?: WrapInTryOptions<FallbackValue> | undefined): FallbackValue | Value | Error;

package/dist/types/index.d.ts

@@ -39,3 +39,4 @@ export * from './augments/time';
 export * from './augments/truncate-number';
 export * from './augments/tuple';
 export * from './augments/type';
+export * from './augments/wrap-in-try';

package/package.json

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