False error TS4094: ... exported class expression may not be private or protected.

TypeScript Version: 3.3.3333

Code

src/test.ts:

export function test () {
    return class {
        private privateMember () {
        }
    };
}

tsconfig.json:

{
    "compilerOptions": {
        "target": "es5",
        "module": "commonjs",
        "declaration": true
    },
    "include": [
        "src/**/*"
    ],
    "exclude": [
        "node_modules"
    ]
}

Expected behavior:
No compilation error.

Actual behavior:
Compiler prints error:
$ tsc
src/test.ts(1,17): error TS4094: Property 'privateMember' of exported class expression may not be private or protected.

Playground Link: not possible to provide.

Workaround

Declare the return type explicitly:

export function test (): new() => Object {
    return class {
        private privateMember () {
        }
    };
}

The error message didn't accidently write itself... exported anonymous classes can't have private or protected members if declaration emit is enabled, because there's no way to represent that in a .d.ts file.

This issue has been marked 'Working as Intended' and has seen no recent activity. It has been automatically closed for house-keeping purposes.

It is possible to use private in declaration files. In my project, for example, I found a lot of them in node_modules folder:
tslint/lib/formatters/checkstyleFormatter.d.ts:

export declare class Formatter extends AbstractFormatter {
    static metadata: IFormatterMetadata;
    format(failures: RuleFailure[]): string;
    private escapeXml; <- HERE
}

I think this is an issue, too.

Perhaps we should extend d.ts to handle this case then. Ideally the declarations file and the ts source file would be 100% compatible.

It is currently not possible to generate declaration files when using a class mixin pattern, even if that pattern would otherwise compile and type-check just fine. It would be nice to have support for this 🙏

Shouldn't this issue be open?

In particular, it'd be nice to be able to do something like

function foo<T>(arg: T): SomeType<T> { ... }

type Bar = {num: number}

type FooBar = ReturnType<typeof foo<Bar>>

I get what you're saying, that foo<Bar> is already a type, so typeof doesn't make sense. But I think you get what's missing.

This is valid:

type FooBar = ReturnType<typeof foo>

But in that example, TypeScript sets the type of T to unknown, so the type of FooBar is SomeType<T>.

Basically, it just intuitively seems like there should be some way to pass a generic arg there, but we can't, and TypeScript automatically sticks unknown into it. Example on playground shows automatic unknown type for T.

If a function foo has a generic param, then the typeof operator could perhaps return a generic type, and we could write:

type FooBar = ReturnType<(typeof foo)<Bar>>

That would be a breaking change to TypeScript though.

Please see #35822

I re-opened this at #36060

Interesting fix:

Moving the mixin to its own file and doing a default export works:

type Constructor<T = {}> = new (...args: any[]) => T

export default <T extends Constructor>(base: T) => class SomeClass extends base {
    protected something: boolean = false
}

While a named export throws the error:

type Constructor<T = {}> = new (...args: any[]) => T

export const mixin = <T extends Constructor>(base: T) => class SomeClass extends base {
    protected something: boolean = false
}

here is how you can fix it, instead of

function makeClass() {
    return class {
         private x = 0;
         public y = 1;
    }
}

do

type PublicConstructor<T> = new () => T;
interface MyPublicInterface {
    y: number;
}
function makeClass(): PublicConstructor<MyPublicInterface> {
    return class {
         private x = 0;
         public y = 1;
    }
}

Just play with Omit type 😎. Just a example with vitest :

import { vi as _vi } from 'vitest';

type VitestUtils = Omit<
  typeof _vi,
  '_timers' | '_mockedDate' | '_mocker' | 'getImporter' | '_config' // never also works fine
>;
type Primitive = number | boolean | string;
type Props = {
  [key in string]?:
    | Primitive
    | Primitive[]
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    | ((this: VitestUtils, ...args: any) => any);
};

export default function extendVitest<T extends Props>(options: T) {
  return Object.assign(_vi as VitestUtils, options);
}

NB: If you don't know the private members of the class, just put never as second parameter of Omit.

Same thing with "constant class".

export const testClass = class {
  private field = {}
}

Property 'field' of exported class expression may not be private or protected.ts(4094)

Interestingly # private class fields indeed work fine.

Using workaround:

class TestClass {}
export const testClass = new TestClass();

Although use #to declare private member can avoid this declaration error, it will make the property not readable, plus it can not replace protected. I only want some method or property not overridable in some cases.

you can write like this

class C {
    private privateMember () {
    }
}
export function test ()  {
    return C;
}

export function test2 (): typeof C  {
    return class extends C {};
}

Although use #to declare private member can avoid this declaration error, it will make the property not readable, plus it can not replace protected. I only want some method or property not overridable in some cases.

it would be great if ESlint rule will be already aware. I had some error and quick fix was generation of private _data + get/set data methods. And it was throwing errors. Replacing with # helped to solve it.

Interesting fix:

Moving the mixin to its own file and doing a default export works:

type Constructor<T = {}> = new (...args: any[]) => T

export default <T extends Constructor>(base: T) => class SomeClass extends base {
    protected something: boolean = false
}

While a named export throws the error:

type Constructor<T = {}> = new (...args: any[]) => T

export const mixin = <T extends Constructor>(base: T) => class SomeClass extends base {
    protected something: boolean = false
}

isn't it a bug then? So it's doing exactly same, but with two files instead of one. I'm quite surprised to see that this issue is Closed while indeed it must not and should be fixed

Create Angular mixins for fractional-width columns and groupable colu…

https://github.com/microsoft/TypeScript/issues/30355

How that's still closed is beyond me. Please revise.

[FIX] ts: fix compiling of `.d.ts` files

Navigation Menu

Repository navigation

False error TS4094: ... exported class expression may not be private or protected. #30355

3 remaining items

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

False error TS4094: ... exported class expression may not be private or protected. #30355

Description

Activity

RyanCavanaugh commented on Mar 14, 2019

typescript-bot commented on Mar 17, 2019

a-student commented on Mar 18, 2019

taoqf commented on Apr 3, 2019

ozyman42 commented on Apr 28, 2019

cdata commented on Sep 17, 2019

trusktr commented on Oct 8, 2019

trusktr commented on Oct 8, 2019

trusktr commented on Oct 8, 2019

trusktr commented on Dec 21, 2019

trusktr commented on Jan 7, 2020

sebastiandittrich commented on Aug 9, 2020

gumT3KBZ9zMY7kzv commented on May 12, 2021

3 remaining items

chlbri commented on Nov 18, 2022

leppaott commented on Feb 2, 2023

Marckon commented on Apr 11, 2023

zyf0330 commented on Jun 2, 2023

ThePlenkov commented on Aug 11, 2023

ThePlenkov commented on Aug 18, 2023

StiliyanKushev commented on Jan 29, 2025

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions