error-serializer/build/src/parse/create.js

Convert errors to/from plain objects

import setErrorClass from"set-error-class";

import{unpackConstructorArgs}from"../args.js";

import{applyTransformArgs}from"./transform_args.js";



export const createError=({
errorObject,
errorObject:{name=DEFAULT_NAME,message,constructorArgs},
options:{transformArgs,classes}
})=>{
const ErrorClass=getErrorClass(name,classes);

if(!Array.isArray(constructorArgs)&&transformArgs===undefined){
return createErrorWithoutArgs(message,ErrorClass)
}

const constructorArgsA=getConstructorArgs(constructorArgs,message);
applyTransformArgs({
transformArgs,
constructorArgs:constructorArgsA,
errorObject,
ErrorClass
});
return createErrorWithArgs(message,ErrorClass,constructorArgsA)
};

const DEFAULT_NAME="Error";





const getErrorClass=(name,classes)=>{
if(classes[name]!==undefined){
return classes[name]
}

return BUILTIN_CLASSES.has(name)&&name in globalThis?
globalThis[name]:
Error
};


const BUILTIN_CLASSES=new Set([
"Error",
"ReferenceError",
"TypeError",
"SyntaxError",
"RangeError",
"URIError",
"EvalError",


"AggregateError",


"DOMException"]
);










const createErrorWithoutArgs=(message,ErrorClass)=>{
const error=new Error(message);
setErrorClass(error,ErrorClass);
return error
};

const getConstructorArgs=(constructorArgs,message)=>
Array.isArray(constructorArgs)?
unpackConstructorArgs(constructorArgs,message):
[message];

















const createErrorWithArgs=(message,ErrorClass,constructorArgs)=>{
try{
return new ErrorClass(...constructorArgs)
}catch{
return new Error(message)
}
};