如何在 TypeScript 中创建动态 class？

Question

I'm trying to migrate a project from JavaScript to TypeScript. I'm attempting to use the following code.

// CustomError.ts
class ErrorType {
    defaultMessage: string;
    errorName: string;

    constructor(defaultMessage: string, errorName: string) {
        this.defaultMessage = defaultMessage;
        this.errorName = errorName;
    }

    errorConstructor() {
        const {defaultMessage, errorName} = this;

        class CustomError extends Error {
            name: string;
            message: string;

            constructor(message: string) {
                super();
                this.name = errorName;
                this.message = message || defaultMessage;
                return this;
            }
        }
        return CustomError;
    }
}

export = {
    "InvalidThing": new ErrorType("Invalid Thing", "InvalidThing").errorConstructor()
};


// ---------------------------------------------------------------------------------------------------


// main.ts
// import CustomError from "./CustomError";
// const main = () => throw new CustomError.InvalidThing("Thing A is invalid.");
// main();

// other.js
// const CustomError = require("./CustomError");
// const main = () => throw new CustomError.InvalidThing("Thing A is invalid.");
// main();

The problem is I'm getting the following error.

Default export of the module has or is using private name 'CustomError'.(4082)

Somehow I need to get CustomError to be in a higher scope. But the problem with that is that I need to be able to access that errorName & defaultMessage .

I'm also aware that I could just create a CustomError class for every error type. But in my actual code, I have roughly 8 error types. Which would mean a LOT of repeated code. I'd prefer to keep it DRY and not repeat a bunch of code.

How can I do this in TypeScript without errors?

---

You can also view a TypeScript Playground with this code to see the error it's throwing.

Answer 1

The ErrorType class looks mostly superfluous to me - all it's being used for is to be able to create a CustomError instance with certain properties. To fix your problem, and to make the code much more concise, consider using a higher-order function instead, to which you can pass the defaultMessage and errorName , and returns a function that takes a message and returns a CustomError instance with the desired properties:

class CustomError extends Error {
    name: string;
    message: string;

    constructor(message: string, defaultMessage: string, errorName: string) {
        super();
        this.name = errorName;
        this.message = message || defaultMessage;
        return this;
    }
}
const makeError = (
    defaultMessage: string,
    errorName: string,
) => (message: string) => new CustomError(message, defaultMessage, errorName);
export = {
    "InvalidThing": makeError("Invalid Thing", "InvalidThing")
};

Because the InvalidThing property is now a plain function, call it without new :

throw CustomError.InvalidThing("Thing A is invalid.");

If the consumer must keep calling it with new , it's uglier since Typescript requires new targets to be classes or functions, which cannot return anything explicitly. For the currying sort of thing you're looking for to work, you'll have to have every value of the exported object be a new class:

const makeError = (
    defaultMessage: string,
    errorName: string,
) => class CustomError extends Error {
    public name: string;
    public message: string;

    constructor(message: string) {
        super();
        this.name = errorName;
        this.message = message || defaultMessage;
    }
};
const exportedObj = {
    InvalidThing: makeError('Invalid Thing', 'InvalidThing'),
};

throw new exportedObj.InvalidThing('Thing A is invalid.');