@gtkx/codegen 1.4.0 → 1.6.0

package/src/fingerprint.ts

@@ -17,6 +17,7 @@ type GiInputs = {
     isValueUnwrapped: boolean;
     isFinishTrimmed: boolean;
     isInoutInPlace: boolean;
+    isTreeShaken: boolean;
 };
 
 type GiFingerprint = {
@@ -30,6 +31,7 @@ type ModuleExport = { module: string; export: string };
 
 type DocsFingerprintInput = {
     basePath: string;
+    linkStyle: string;
     props: Record<string, ModuleExport>;
     omittedProps: Record<string, string[]>;
 };
@@ -46,6 +48,7 @@ type JsxFingerprintInput = {
     lazyElements: string[];
     props: Record<string, ModuleExport>;
     omittedProps: Record<string, string[]>;
+    isTreeShaken: boolean;
 };
 
 type JsxFingerprint = {
@@ -206,6 +209,8 @@ const hashGi = (inputs: GiInputs): string => {
     hash.update("\n");
     hash.update(String(inputs.isInoutInPlace));
     hash.update("\n");
+    hash.update(String(inputs.isTreeShaken));
+    hash.update("\n");
     hash.update(String(inputs.storeVersion));
     const girFiles = sortOrdinal(inputs.girFiles);
 
@@ -270,6 +275,7 @@ const hashDocs = (giValue: string, input: DocsFingerprintInput): string =>
             JSON.stringify([
                 giValue,
                 input.basePath,
+                input.linkStyle,
                 serializeModuleExports(input.props),
                 serializeOmittedProps(input.omittedProps),
             ]),
@@ -311,6 +317,7 @@ const hashJsx = (input: JsxFingerprintInput): string =>
                 sortOrdinal(input.lazyElements),
                 serializeModuleExports(input.props),
                 serializeOmittedProps(input.omittedProps),
+                input.isTreeShaken,
             ]),
         )
         .digest("hex");

package/src/gi.ts

@@ -15,6 +15,7 @@ type GiCodegenOptions = {
     isValueUnwrapped: boolean;
     isFinishTrimmed: boolean;
     isInoutInPlace: boolean;
+    isTreeShaken: boolean;
 };
 
 type SplitNamespaces = {
@@ -39,9 +40,12 @@ const splitNamespaces = (library: Library): SplitNamespaces => {
             continue;
         }
 
+        const generated = generateNamespaceModule(namespace, library);
+
         namespaces.push({
             directory: namespaceDirectory(namespace),
-            rawSource: generateNamespaceModule(namespace, library),
+            rawSource: generated.source,
+            rawBootstrapSource: generated.bootstrapSource,
             girFile: namespace.girFile,
         });
     }
@@ -62,6 +66,7 @@ const runGiCodegen = (library: Library, options: GiCodegenOptions): number => {
         isValueUnwrapped,
         isFinishTrimmed,
         isInoutInPlace,
+        isTreeShaken: options.isTreeShaken,
     });
 
     writeGiStore(gi, namespaces, externalNamespaces, {

package/src/gir/libraries.ts

@@ -17,36 +17,84 @@ type LibrarySelection = "*" | string[] | undefined;
 const LIBRARIES_WILDCARD = "*";
 const GIR_LIBRARY_PATTERN = /^[A-Za-z][A-Za-z0-9]*-\d+(?:\.\d+)*$/;
 const DEFAULT_LIBRARIES: string[] = ["Gtk-4.0"];
+const ADWAITA_DEFAULT_LIBRARIES: string[] = ["Gtk-4.0", "Adw-1"];
 const GIR_FILE_SUFFIX = ".gir";
 
 /**
- * Expands a `libraries` config value into the GIR identifiers to generate from: `"Gtk-4.0"` alone when
- * nothing is configured, everything installed for `"*"`, and otherwise the given list with `"Gtk-4.0"`
- * prepended unless it already names a Gtk version.
+ * Expands a `libraries` config value into the GIR identifiers to generate from: the mandatory set alone
+ * when nothing is configured, everything installed for `"*"`, and otherwise the given list with the
+ * mandatory set prepended.
+ *
+ * The mandatory set is `"Gtk-4.0"`, which joins a list that does not already name a Gtk version. Under
+ * `isAdwaitaDefault` it is `"Gtk-4.0"` and `"Adw-1"`, and it joins `"*"` as well as an explicit list.
+ * Each entry is mandatory by namespace rather than by version, so a list that pins another version of
+ * Gtk or Adwaita keeps its pin.
  *
  * @throws If `"*"` matched no `.gir` file anywhere on the GIR path.
  */
-const resolveLibraries = (libraries: LibrarySelection, girPath: string[]): string[] => {
+const resolveLibraries = (libraries: LibrarySelection, girPath: string[], isAdwaitaDefault = false): string[] => {
     if (libraries === undefined) {
-        return [...DEFAULT_LIBRARIES];
+        return [...mandatoryLibraries(isAdwaitaDefault)];
     }
 
     if (libraries === LIBRARIES_WILDCARD) {
-        const discovered = discoverGirNamespaces(girPath);
+        return installedLibraries(girPath, isAdwaitaDefault);
+    }
 
-        if (discovered.length === 0) {
-            throw new Error(
-                `gtkx.config.ts: \`libraries: "*"\` matched no .gir files in [${girPath.join(", ")}]. ` +
-                "Install gobject-introspection data packages, or list the libraries explicitly.",
-            );
-        }
+    if (isAdwaitaDefault) {
+        return withMandatory(ADWAITA_DEFAULT_LIBRARIES, libraries);
+    }
+
+    return withDefaultGtk(libraries);
+};
+
+const redundantLibraries = (libraries: LibrarySelection, isAdwaitaDefault = false): string[] => {
+    if (!isAdwaitaDefault || !Array.isArray(libraries)) {
+        return [];
+    }
+
+    return libraries.filter((entry) => ADWAITA_DEFAULT_LIBRARIES.includes(entry));
+};
+
+const mandatoryLibraries = (isAdwaitaDefault: boolean): string[] =>
+    isAdwaitaDefault ? ADWAITA_DEFAULT_LIBRARIES : DEFAULT_LIBRARIES;
 
-        return discovered;
+const installedLibraries = (girPath: string[], isAdwaitaDefault: boolean): string[] => {
+    const discovered = discoverGirNamespaces(girPath);
+
+    if (discovered.length === 0) {
+        throw new Error(
+            `gtkx.config.ts: \`libraries: "*"\` matched no .gir files in [${girPath.join(", ")}]. ` +
+            "Install gobject-introspection data packages, or list the libraries explicitly.",
+        );
+    }
+
+    if (isAdwaitaDefault) {
+        return withMandatory(ADWAITA_DEFAULT_LIBRARIES, discovered);
     }
 
-    const hasGtk = libraries.some((library) => library.startsWith("Gtk-"));
+    return discovered;
+};
+
+const getNamespace = (library: string): string => {
+    const separator = library.indexOf("-");
+
+    return separator === -1 ? library : library.slice(0, separator);
+};
+
+const withMandatory = (mandatory: string[], selected: string[]): string[] => {
+    const named: Set<string> = new Set(selected.map((entry) => getNamespace(entry)));
+    const missing = mandatory.filter((library) => !named.has(getNamespace(library)));
+
+    return [...new Set([...missing, ...selected])];
+};
+
+const withDefaultGtk = (libraries: string[]): string[] => {
+    if (libraries.some((library) => library.startsWith("Gtk-"))) {
+        return [...new Set(libraries)];
+    }
 
-    return [...new Set([...(hasGtk ? [] : DEFAULT_LIBRARIES), ...libraries])];
+    return [...new Set([...DEFAULT_LIBRARIES, ...libraries])];
 };
 
 const readDirEntries = (dir: string): string[] => {
@@ -121,4 +169,4 @@ const compareVersions = (a: string, b: string): number => {
     return 0;
 };
 
-export { resolveLibraries, discoverGirNamespaces, type LibrarySelection };
+export { resolveLibraries, redundantLibraries, discoverGirNamespaces, LIBRARIES_WILDCARD, type LibrarySelection };

package/src/gir/library.ts

@@ -34,6 +34,8 @@ type FutureBehavior = {
     isFinishTrimmed?: boolean;
     /** Whether a handle-passing inout parameter is mutated in place rather than packed into the result. */
     isInoutInPlace?: boolean;
+    /** Whether registrations fold into each class so bundlers can drop unused ones. */
+    isTreeShaken?: boolean;
 };
 
 /** A namespace whose header has been read and whose shell is registered, before its body is parsed. */
@@ -105,6 +107,7 @@ class Library {
         library.isValueUnwrappedValue = future.isValueUnwrapped === true;
         library.isFinishTrimmedValue = future.isFinishTrimmed === true;
         library.isInoutInPlaceValue = future.isInoutInPlace === true;
+        library.isTreeShakenValue = future.isTreeShaken === true;
         this.drive(library, libraries, girPath);
 
         return library;
@@ -120,6 +123,7 @@ class Library {
     private isValueUnwrappedValue = false;
     private isFinishTrimmedValue = false;
     private isInoutInPlaceValue = false;
+    private isTreeShakenValue = false;
 
     /** Creates a library with no namespaces loaded; {@link Library.load} builds a populated one. */
     constructor() {
@@ -369,6 +373,11 @@ class Library {
         return this.isInoutInPlaceValue;
     }
 
+    /** Whether registrations fold into each class so bundlers can drop unused ones. */
+    public get isTreeShaken(): boolean {
+        return this.isTreeShakenValue;
+    }
+
     /** Paths of the `.gir` files that were read, in the order they were discovered. */
     public get girFiles(): string[] {
         return this.girFilesValue;

package/src/internal.ts

@@ -1,4 +1,5 @@
 export { writeDocs } from "./docs/pipeline.js";
+export { LIBRARIES_WILDCARD, redundantLibraries } from "./gir/libraries.js";
 export { runGlCodegen } from "./runner.js";
 export { getShadowingStorePaths, sweepProjectStaging } from "./store/resolve-store.js";
 export { ensureStoreLinks } from "./store/store-links.js";

package/src/jsx.ts

@@ -24,6 +24,7 @@ type RunJsxCodegenOptions = {
     userOmittedProps: OmittedProps;
     isGiRegenerated: boolean;
     isForced: boolean;
+    isTreeShaken: boolean;
 };
 
 type RunJsxCodegenResult = {
@@ -45,6 +46,7 @@ const runJsxCodegen = async (options: RunJsxCodegenOptions): Promise<RunJsxCodeg
         lazyElements,
         props,
         omittedProps,
+        isTreeShaken: options.isTreeShaken,
     };
 
     if (!options.isForced && !options.isGiRegenerated) {
@@ -69,6 +71,7 @@ const runJsxCodegen = async (options: RunJsxCodegenOptions): Promise<RunJsxCodeg
         options: options.jsx,
         namespaces,
         metadata,
+        isTreeShaken: options.isTreeShaken,
         externalPackages: storeExternalPackages(library),
         rawFiles: [
             {

package/src/runner.ts

@@ -48,6 +48,8 @@ type CodegenRunnerOptions = {
     isFinishTrimmed?: boolean;
     /** Mutates a handle-passing inout parameter in place instead of packing it into the result; defaults to false. */
     isInoutInPlace?: boolean;
+    /** Folds registrations into each class so bundlers can drop unused ones; defaults to false. */
+    isTreeShaken?: boolean;
 };
 
 /** What a `runCodegen` run produced. */
@@ -152,6 +154,7 @@ const emitJsxStore = async (input: {
         ...jsxUserOptions(options),
         isGiRegenerated,
         isForced: options.isForced === true,
+        isTreeShaken: options.isTreeShaken === true,
     });
 
     return {
@@ -173,7 +176,8 @@ const emitStoresWithConfig = async (config: {
     const isValueUnwrapped = options.isValueUnwrapped === true;
     const isFinishTrimmed = options.isFinishTrimmed === true;
     const isInoutInPlace = options.isInoutInPlace === true;
-    const future = { isByteArrayTyped, isValueUnwrapped, isFinishTrimmed, isInoutInPlace };
+    const isTreeShaken = options.isTreeShaken === true;
+    const future = { isByteArrayTyped, isValueUnwrapped, isFinishTrimmed, isInoutInPlace, isTreeShaken };
     let library: Library | undefined;
     const loadLibrary = (): Library => (library ??= Library.load(libraries, girPath, future));
     const giInputs = { girFiles: [] as string[], libraries, girPath, storeVersion: gi.version, ...future };

package/src/store/gi/bootstrap.ts

@@ -0,0 +1,64 @@
+import { sortStrings, sourceStringLiteral } from "@gtkx/utils";
+import type { ModuleContext } from "../../writer/context.js";
+import { namespaceDirectory } from "../../gir/namespace.js";
+
+const PATCHING_OVERRIDES: Record<string, string[]> = {
+    glib: ["./overrides/regex.js"],
+    gobject: ["./overrides/object.js", "./overrides/param-spec-getters.js", "./overrides/value.js"],
+};
+
+const CORE_WRAPPERS: Record<string, string[]> = {
+    glib: ["Error", "Variant"],
+    gobject: ["ParamSpec", "Value"],
+};
+
+const renderDependencyImports = (context: ModuleContext): string[] => [
+    ...sortStrings(context.dependencies).map((dependency) => `import "../${dependency}/bootstrap.js";`),
+    ...sortStrings(context.externalDependencies).map((packageName) => `import ${sourceStringLiteral(packageName)};`),
+];
+
+const renderOverrideImports = (directory: string): string[] =>
+    (PATCHING_OVERRIDES[directory] ?? []).map((override) => `import ${sourceStringLiteral(override)};`);
+
+const renderRuntimeImport = (context: ModuleContext, coreWrappers: string[]): string[] => {
+    const runtimeImports = new Set(context.bootstrapRuntimeImports);
+
+    if (coreWrappers.length > 0) {
+        runtimeImports.add("retainWrapperClasses");
+    }
+
+    if (runtimeImports.size === 0) {
+        return [];
+    }
+
+    return [`import { ${sortStrings(runtimeImports).join(", ")} } from "@gtkx/runtime";`];
+};
+
+const renderModuleImports = (context: ModuleContext, directory: string, coreWrappers: string[]): string[] => {
+    const moduleImports = sortStrings(new Set([...context.bootstrapModuleExports, ...coreWrappers]));
+
+    return moduleImports.length === 0 ? [] : [`import { ${moduleImports.join(", ")} } from "./${directory}.js";`];
+};
+
+const renderBootstrapModule = (context: ModuleContext): string => {
+    const directory = namespaceDirectory(context.namespace);
+    const coreWrappers = CORE_WRAPPERS[directory] ?? [];
+
+    const retention = coreWrappers.length === 0
+        ? []
+        : [`retainWrapperClasses([${coreWrappers.join(", ")}]);`];
+
+    const lines = [
+        ...renderDependencyImports(context),
+        ...renderOverrideImports(directory),
+        ...renderRuntimeImport(context, coreWrappers),
+        ...renderModuleImports(context, directory, coreWrappers),
+        "",
+        ...retention,
+        ...context.bootstrapCalls,
+    ];
+
+    return `${lines.join("\n")}\n`;
+};
+
+export { renderBootstrapModule };

package/src/store/gi/class.ts

@@ -34,6 +34,7 @@ import {
 } from "./callables.js";
 import { renderClassConstructor, renderConstructorPropsInterface } from "./constructor-props.js";
 import { getDoc } from "./doc-spec.js";
+import { declareFoldedClass, localClassName } from "./folded.js";
 import { gtypeMemberDeclaration, renderSourceGtype } from "./gtype-binding.js";
 import { methodExportName } from "./method.js";
 import { renderPropertyDeclarations } from "./properties.js";
@@ -78,6 +79,14 @@ type AppendInstanceMethodsOptions = {
     className: string;
 };
 
+type TreeShakenClassOptions = {
+    klass: GirClass;
+    className: string;
+    heritage: string;
+    body: string;
+    implemented: ImplementedRef[];
+};
+
 const generateClass = (context: ModuleContext, klass: GirClass): void => {
     if (!isEmittableEntity(klass)) {
         return;
@@ -95,18 +104,25 @@ const generateClass = (context: ModuleContext, klass: GirClass): void => {
     const parentExpression = resolveParent(context, klass);
     const extendsClause = renderExtendsClause(context, parentExpression, klass, callables);
     const implemented = resolveImplementedRefs(context, klass);
-    const typeRefs = implemented.map((ref) => omittedTypeRef(ref.typeRef, ref.conflicts));
-    const implementsClause = typeRefs.length === 0 ? "" : ` implements ${typeRefs.join(", ")}`;
+    const implementsClause = renderImplementsClause(implemented);
+
+    if (context.isTreeShaken) {
+        context.beginRegistrations();
+    }
+
     const { members, accessors } = renderClassMembers(context, klass, callables, parentExpression !== undefined);
     const body = indentMembers(members);
-    const doc = getDoc(klass);
-    const modifier = klass.isAbstract ? "abstract " : "";
-
-    context.declare({
-        name: className,
-        code: `${doc}export ${modifier}class ${className}${extendsClause}${implementsClause} {\n${body}\n}`,
-        owner: klass.name,
-    });
+    const heritage = `${extendsClause}${implementsClause}`;
+
+    if (context.isTreeShaken) {
+        declareTreeShakenClass(context, { klass, className, heritage, body, implemented });
+    } else {
+        context.declare({
+            name: className,
+            code: `${getDoc(klass)}export ${classModifier(klass)}class ${className}${heritage} {\n${body}\n}`,
+            owner: klass.name,
+        });
+    }
 
     context.declare({
         name: `${className}ConstructorProps`,
@@ -114,8 +130,37 @@ const generateClass = (context: ModuleContext, klass: GirClass): void => {
     });
 
     appendMemberDeclarations({ context, klass, className, accessors, implemented });
-    appendInstallMixins(context, className, implemented);
-    appendClassRegistrations(context, klass, className);
+
+    if (!context.isTreeShaken) {
+        appendInstallMixins(context, className, implemented);
+        appendClassRegistrations(context, klass, className);
+    }
+};
+
+const classModifier = (klass: GirClass): string => (klass.isAbstract ? "abstract " : "");
+
+const renderImplementsClause = (implemented: ImplementedRef[]): string => {
+    const typeRefs = implemented.map((ref) => omittedTypeRef(ref.typeRef, ref.conflicts));
+
+    return typeRefs.length === 0 ? "" : ` implements ${typeRefs.join(", ")}`;
+};
+
+const declareTreeShakenClass = (context: ModuleContext, options: TreeShakenClassOptions): void => {
+    const { klass, className, heritage, body, implemented } = options;
+    const localName = localClassName(className);
+    appendInstallMixins(context, localName, implemented);
+    appendClassRegistrations(context, klass, localName);
+    const registrations = context.takeRegistrations();
+
+    declareFoldedClass({
+        context,
+        className,
+        doc: getDoc(klass),
+        owner: klass.name,
+        localDeclaration: `${classModifier(klass)}class ${localName}${heritage} {\n${body}\n}`,
+        registrations,
+        hasInstanceInterface: true,
+    });
 };
 
 const appendMemberDeclarations = (options: MemberDeclarationsOptions): void => {
@@ -224,37 +269,56 @@ const appendInstanceMethods = (options: AppendInstanceMethodsOptions): void => {
     }
 };
 
-const appendInstallMixins = (context: ModuleContext, className: string, implemented: ImplementedRef[]): void => {
+const appendInstallMixins = (context: ModuleContext, targetName: string, implemented: ImplementedRef[]): void => {
     if (implemented.length === 0) {
         return;
     }
 
-    context.addRuntimeImport("installMixins");
-    const makerRefs = implemented.map((ref) => ref.makerRef);
-    const localRefs = makerRefs.filter((ref) => !ref.includes("."));
+    if (!context.isTreeShaken) {
+        context.addRuntimeImport("installMixins");
+        const makerRefs = implemented.map((ref) => ref.makerRef);
+        const localRefs = makerRefs.filter((ref) => !ref.includes("."));
 
-    context.module.appendRegistration(`installMixins(${className}, [${makerRefs.join(", ")}]);`, [
-        className,
-        ...localRefs,
-    ]);
+        context.module.appendRegistration(`installMixins(${targetName}, [${makerRefs.join(", ")}]);`, [
+            targetName,
+            ...localRefs,
+        ]);
+
+        return;
+    }
+
+    const registered = implemented.filter((ref) => ref.interfaceKlass.glibGetType !== undefined);
+    const unregistered = implemented.filter((ref) => ref.interfaceKlass.glibGetType === undefined);
+
+    if (registered.length > 0) {
+        context.addRuntimeImport("installInterfaces");
+        const refs = registered.map((ref) => ref.typeRef);
+        context.collectRegistration(`installInterfaces(${targetName}, [${refs.join(", ")}]);`);
+    }
+
+    if (unregistered.length > 0) {
+        context.addRuntimeImport("installMixins");
+        const refs = unregistered.map((ref) => ref.makerRef);
+        context.collectRegistration(`installMixins(${targetName}, [${refs.join(", ")}]);`);
+    }
 };
 
-const appendClassRegistrations = (context: ModuleContext, klass: GirClass, className: string): void => {
+const appendClassRegistrations = (context: ModuleContext, klass: GirClass, targetName: string): void => {
     const gtypeExpr = renderSourceGtype(context, klass);
 
     appendWrapperClassRegistration(context, {
-        className,
+        className: targetName,
         gtypeExpr,
         vfuncs: renderVfuncMetadata(context, klass),
     });
 
-    appendClassStructRegistration(context, klass, className, gtypeExpr);
+    appendClassStructRegistration(context, klass, targetName, gtypeExpr);
 };
 
 const appendClassStructRegistration = (
     context: ModuleContext,
     klass: GirClass,
-    className: string,
+    targetName: string,
     gtypeExpr: string | undefined,
 ): void => {
     const typeStruct = klass.glibTypeStruct;
@@ -272,8 +336,8 @@ const appendClassStructRegistration = (
     const structName = sanitizeTypeIdentifier(resolved.value.name);
     context.addRuntimeImport("registerClassStruct");
 
-    context.module.appendRegistration(`registerClassStruct(${className}, ${structName});`, [
-        className,
+    context.collectRegistration(`registerClassStruct(${targetName}, ${structName});`, [
+        targetName,
         structName,
     ]);
 };
@@ -445,9 +509,16 @@ const renderExtendsClause = (
 const resolveParent = (context: ModuleContext, klass: GirClass): string | undefined => {
     const parent = getParentRef(klass);
 
-    return parent === undefined
-        ? undefined
-        : context.qualify(parent.namespaceName ?? context.namespace.name, sanitizeTypeIdentifier(parent.typeName));
+    if (parent === undefined) {
+        return undefined;
+    }
+
+    const qualified = context.qualify(
+        parent.namespaceName ?? context.namespace.name,
+        sanitizeTypeIdentifier(parent.typeName),
+    );
+
+    return context.isTreeShaken ? context.hoistBaseRef(qualified) : qualified;
 };
 
 export { generateClass };

package/src/store/gi/constructor-props.ts

@@ -96,7 +96,8 @@ const renderTranslatingConstructor = (context: ModuleContext, props: GirProperty
     context.addRuntimeImport("t");
     context.addRuntimeImport("registerConstructProperties");
     const bindings = renderConstructBindings(context, props);
-    context.module.appendRegistration(`registerConstructProperties(${className}, ${bindings});`, [className]);
+    const target = context.isTreeShaken ? `_${className}` : className;
+    context.collectRegistration(`registerConstructProperties(${target}, ${bindings});`, [className]);
 
     return renderBlock(`constructor(props: ${className}ConstructorProps = {})`, "super(props);");
 };

package/src/store/gi/enum.ts

@@ -3,7 +3,7 @@ import type { EnumMember, GirEnum } from "../../gir/enum.js";
 import type { ModuleContext } from "../../writer/context.js";
 import { hasAnnotations } from "../../gir/annotations.js";
 import { isEmittableEntity } from "../../gir/emittable.js";
-import { indent } from "../../writer/emit.js";
+import { indent, pure } from "../../writer/emit.js";
 import { getDoc } from "./doc-spec.js";
 
 type KeyedMember = EnumMember & { key: string };
@@ -58,11 +58,11 @@ const appendErrorDomain = (
         owner: enumeration.name,
     });
 
+    const domain = pure(`createErrorDomain(${quarkExpression}, { ${memberEntries.join(", ")} })`);
+
     context.declare({
         name,
-        code:
-            `${doc}export const ${name}: ErrorDomain<${shape}> = ` +
-            `createErrorDomain(${quarkExpression}, { ${memberEntries.join(", ")} });`,
+        code: `${doc}export const ${name}: ErrorDomain<${shape}> = ${domain};`,
     });
 };
 

package/src/store/gi/folded.ts

@@ -0,0 +1,57 @@
+import { sourceStringLiteral } from "@gtkx/utils";
+import type { ModuleContext } from "../../writer/context.js";
+import { indent } from "../../writer/emit.js";
+
+type FoldedClassOptions = {
+    context: ModuleContext;
+    className: string;
+    doc: string;
+    owner: string;
+    localDeclaration: string;
+    registrations: string[];
+    hasInstanceInterface: boolean;
+};
+
+const localClassName = (className: string): string => `_${className}`;
+
+const renderNameStatement = (className: string): string =>
+    `globalThis.Object.defineProperty(${localClassName(className)}, "name", ` +
+    `{ value: ${sourceStringLiteral(className)}, configurable: true });`;
+
+const declareFoldedClass = (options: FoldedClassOptions): void => {
+    const { context, className, doc, owner, localDeclaration, registrations, hasInstanceInterface } = options;
+    const localName = localClassName(className);
+    context.module.appendDeclaration({ name: localName, code: localDeclaration, isLocal: true });
+
+    const body = [renderNameStatement(className), ...registrations, `return ${localName};`]
+        .map((statement) => indent(statement, 1))
+        .join("\n");
+
+    if (!hasInstanceInterface) {
+        context.declare({
+            name: className,
+            code: `${doc}export const ${className}: typeof ${localName} = /* @__PURE__ */ (() => {\n${body}\n})();`,
+            owner,
+        });
+
+        return;
+    }
+
+    context.declare({
+        name: className,
+        code: `export interface ${className} extends ${localName} {}`,
+    });
+
+    context.addRuntimeTypeImport("WrapperClass");
+    const constType = `WrapperClass<typeof ${localName}, ${className}>`;
+
+    context.declare({
+        name: className,
+        code:
+            `${doc}export const ${className}: ${constType} = ` +
+            `/* @__PURE__ */ (() => {\n${body}\n})() as ${constType};`,
+        owner,
+    });
+};
+
+export { declareFoldedClass, localClassName };