@gtkx/codegen 1.5.0 → 1.6.0

package/src/store/gi/interface.ts

@@ -21,6 +21,7 @@ import {
     renderStaticHead,
 } from "./callables.js";
 import { annotationSpec, getDoc } from "./doc-spec.js";
+import { declareFoldedClass, localClassName } from "./folded.js";
 import { gtypeMemberDeclaration, renderSourceGtype } from "./gtype-binding.js";
 import { methodExportName } from "./method.js";
 import {
@@ -89,8 +90,15 @@ const generateInterface = (context: ModuleContext, iface: GirClass): void => {
     generateBindings(context, callables);
     const gtypeExpr = renderSourceGtype(context, iface);
     const implRef = appendInterfaceTypes(context, iface, className, callables) ?? "unknown";
+
+    if (gtypeExpr !== undefined && context.isTreeShaken) {
+        declareTreeShakenInterface(context, { iface, className, callables, gtypeExpr, implRef });
+
+        return;
+    }
+
     const classCode = renderInterfaceClass(context, { iface, className, callables, gtypeExpr, implRef });
-    context.declare({ name: className, code: classCode, owner: iface.name });
+    context.declare({ name: className, code: `${getDoc(iface)}${classCode}`, owner: iface.name });
 
     for (const declaration of renderSignalDeclarations(context, iface, className, true)) {
         context.declare(declaration);
@@ -109,6 +117,53 @@ const generateInterface = (context: ModuleContext, iface: GirClass): void => {
     });
 };
 
+const declareTreeShakenInterface = (
+    context: ModuleContext,
+    options: Omit<InterfaceClassOptions, "gtypeExpr"> & { gtypeExpr: string },
+): void => {
+    const { iface, className, callables } = options;
+
+    for (const declaration of renderSignalDeclarations(context, iface, className, true)) {
+        context.declare(declaration);
+    }
+
+    context.declare({
+        name: makerName(className),
+        code: renderInterfaceMaker(context, iface, className, callables),
+    });
+
+    generateFoldedInterface(context, options);
+};
+
+const generateFoldedInterface = (
+    context: ModuleContext,
+    options: Omit<InterfaceClassOptions, "gtypeExpr"> & { gtypeExpr: string },
+): void => {
+    const { iface, className, callables, gtypeExpr, implRef } = options;
+    const localName = localClassName(className);
+    context.beginRegistrations();
+
+    appendInterfaceRegistration(context, {
+        className: localName,
+        makerName: makerName(className),
+        gtypeExpr,
+        layout: renderInterfaceLayout(context, iface, callables),
+    });
+
+    const registrations = context.takeRegistrations();
+    const classCode = renderInterfaceClass(context, { iface, className, callables, gtypeExpr, implRef }, localName);
+
+    declareFoldedClass({
+        context,
+        className,
+        doc: getDoc(iface),
+        owner: iface.name,
+        localDeclaration: classCode,
+        registrations,
+        hasInstanceInterface: false,
+    });
+};
+
 const makerName = (className: string): string => `make${className}`;
 
 const renderInterfaceLayout = (
@@ -373,8 +428,12 @@ const renderInterfaceTypeMembers = (context: ModuleContext, iface: GirClass, cal
     ...interfaceVfuncMembers(context, iface, "signature"),
 ];
 
-const renderInterfaceClass = (context: ModuleContext, options: InterfaceClassOptions): string => {
-    const { iface, className, callables, gtypeExpr, implRef } = options;
+const renderInterfaceClass = (
+    context: ModuleContext,
+    options: InterfaceClassOptions,
+    localName?: string,
+): string => {
+    const { className, callables, gtypeExpr, implRef } = options;
     const members: string[] = [];
 
     if (gtypeExpr !== undefined) {
@@ -382,11 +441,9 @@ const renderInterfaceClass = (context: ModuleContext, options: InterfaceClassOpt
     }
 
     members.push(...renderStaticHead(context, callables, className), renderInterfaceBrand(context, implRef));
+    const head = localName === undefined ? `export abstract class ${className}` : `abstract class ${localName}`;
 
-    return `${getDoc(iface)}${renderBracedOrEmpty(
-        `export abstract class ${className}`,
-        members.join("\n\n"),
-    )}`;
+    return renderBracedOrEmpty(head, members.join("\n\n"));
 };
 
 const renderInterfaceBrand = (context: ModuleContext, implRef: string): string => {

package/src/store/gi/method.ts

@@ -438,6 +438,7 @@ const renderReturnDescriptor = (context: ModuleContext, fn: GirFunction): Return
         argIndexOffset: instanceOffset,
         argIndexMap: emittedArgIndices(fn, instanceOffset),
         isNewlyCreated: fn.instance === undefined,
+        isReceived: true,
     });
 
     return {
@@ -568,6 +569,7 @@ const planOutParam = (
         ...argIndex,
         cursor: parameter.cursor,
         hasOutIndirection: true,
+        isReceived: true,
     });
 
     return {

package/src/store/gi/pipeline.ts

@@ -7,6 +7,7 @@ import { getParentRef } from "../../gir/ancestry.js";
 import { isEmittableEntity } from "../../gir/emittable.js";
 import { PRIMITIVE_TS_TYPE, primitiveCategory } from "../../gir/primitives.js";
 import { ModuleContext } from "../../writer/context.js";
+import { renderBootstrapModule } from "./bootstrap.js";
 import { generateCallback } from "./callback.js";
 import { generateClass } from "./class.js";
 import { generateConstant } from "./constant.js";
@@ -24,7 +25,12 @@ type TopologicalState = {
     result: GirClass[];
 };
 
-const generateNamespaceModule = (namespace: GirNamespace, library: Library): string => {
+type NamespaceModule = {
+    source: string;
+    bootstrapSource: string | undefined;
+};
+
+const generateNamespaceModule = (namespace: GirNamespace, library: Library): NamespaceModule => {
     const context = new ModuleContext(namespace, library);
     context.addGObjectBootstrapImports();
     generateNamespaceTypes(context, namespace);
@@ -38,7 +44,10 @@ const generateNamespaceModule = (namespace: GirNamespace, library: Library): str
         );
     }
 
-    return context.module.toSource();
+    return {
+        source: context.module.toSource(),
+        bootstrapSource: library.isTreeShaken ? renderBootstrapModule(context) : undefined,
+    };
 };
 
 const generateNamespaceTypes = (context: ModuleContext, namespace: GirNamespace): void => {
@@ -50,10 +59,20 @@ const generateNamespaceTypes = (context: ModuleContext, namespace: GirNamespace)
         generateRecord(context, record);
     }
 
+    if (context.isTreeShaken) {
+        generateInterfaces(context, namespace);
+    }
+
     for (const klass of topologicalClassOrder(namespace.classes, namespace.name)) {
         generateClass(context, klass);
     }
 
+    if (!context.isTreeShaken) {
+        generateInterfaces(context, namespace);
+    }
+};
+
+const generateInterfaces = (context: ModuleContext, namespace: GirNamespace): void => {
     for (const iface of namespace.interfaces) {
         generateInterface(context, iface);
     }

package/src/store/gi/property-accessor.ts

@@ -185,7 +185,7 @@ const renderPropertyAccessorSignature = (args: PropertyAccessorArgs): string | u
     withAccessor(args, (accessor) => `${propertyDoc(args.property)}${renderAccessorPairSignature(accessor)}`);
 
 const renderPropertyDescriptor = (context: ModuleContext, property: GirProperty): string =>
-    renderDescriptor(context, property.type, property.transferOwnership);
+    renderDescriptor(context, property.type, property.transferOwnership, { isReceived: true });
 
 const renderGenericGetBody = (context: ModuleContext, property: GirProperty, tsType: string): string => {
     context.addRuntimeImport("getObjectProperty");

package/src/store/gi/record-field-accessor.ts

@@ -285,7 +285,7 @@ const renderRecordFieldAccessor = (
     }
 
     const descriptor = context.hoistDescriptor(
-        renderDescriptor(context, field.type, "none", { isInline: isInlineField(context, field) }),
+        renderDescriptor(context, field.type, "none", { isInline: isInlineField(context, field), isReceived: true }),
     );
 
     const tsType = fieldTsType(context, field.type);
@@ -501,7 +501,7 @@ const visitInlineStructSlot = (
         return;
     }
 
-    const descriptor = context.hoistDescriptor(renderDescriptor(context, field.type, "none"));
+    const descriptor = context.hoistDescriptor(renderDescriptor(context, field.type, "none", { isReceived: true }));
     visitors.leaf({ jsName, descriptor, offset, slot, type: field.type });
 };
 
@@ -778,7 +778,9 @@ const renderInlineArrayAccessor = (context: ModuleContext, target: StructArrayTa
         context,
         jsName,
         tsType: renderTsType(context, field.type, false),
-        descriptor: context.hoistDescriptor(renderDescriptor(context, resolution.element, "none", { isInline: true })),
+        descriptor: context.hoistDescriptor(
+            renderDescriptor(context, resolution.element, "none", { isInline: true, isReceived: true }),
+        ),
         offset: slot.byteOffset,
         resolution,
     };

package/src/store/gi/record.ts

@@ -5,6 +5,7 @@ import { isEmittableEntity } from "../../gir/emittable.js";
 import { indentMembers } from "../../writer/emit.js";
 import { type Callables, dedupeCallables, generateBindings, renderPlainTypeMembers } from "./callables.js";
 import { getDoc } from "./doc-spec.js";
+import { declareFoldedClass, localClassName } from "./folded.js";
 import { renderSourceGtype } from "./gtype-binding.js";
 import { renderRecordConstructor, renderRecordConstructorPropsInterface } from "./record-constructor.js";
 import { renderRecordFieldAccessor } from "./record-field-accessor.js";
@@ -12,9 +13,52 @@ import { computeRecordFieldSlots } from "./record-layout.js";
 import { appendWrapperClassRegistration } from "./registration.js";
 import { isConstructibleRecord } from "./value-marshalable.js";
 
+type FoldedRecordOptions = {
+    record: GirRecord;
+    className: string;
+    doc: string;
+    modifier: string;
+    heritage: string;
+    body: string;
+    gtypeExpr: string;
+};
+
 const isGErrorRecord = (context: ModuleContext, record: GirRecord): boolean =>
     context.namespace.name === "GLib" && record.glibGetType === "g_error_get_type";
 
+const recordHeritage = (context: ModuleContext, isErrorSubclass: boolean): string => {
+    if (!isErrorSubclass) {
+        return "";
+    }
+
+    const base = context.isTreeShaken ? context.hoistBaseRef("globalThis.Error") : "globalThis.Error";
+
+    return ` extends ${base}`;
+};
+
+const recordModifier = (isConstructible: boolean): string => (isConstructible ? "" : "abstract ");
+
+const declareFoldedRecord = (context: ModuleContext, options: FoldedRecordOptions): void => {
+    const { record, className, doc, modifier, heritage, body, gtypeExpr } = options;
+    const localName = localClassName(className);
+    context.beginRegistrations();
+
+    appendWrapperClassRegistration(context, {
+        className: localName,
+        gtypeExpr,
+    });
+
+    declareFoldedClass({
+        context,
+        className,
+        doc,
+        owner: record.name,
+        localDeclaration: `${modifier}class ${localName}${heritage} {\n${body}\n}`,
+        registrations: context.takeRegistrations(),
+        hasInstanceInterface: true,
+    });
+};
+
 const generateRecord = (context: ModuleContext, record: GirRecord): void => {
     if (!isEmittableEntity(record)) {
         return;
@@ -32,16 +76,26 @@ const generateRecord = (context: ModuleContext, record: GirRecord): void => {
     generateBindings(context, callables);
     const members = renderRecordMembers(context, record, className, callables);
     const body = indentMembers(members);
-    const heritage = isErrorSubclass ? " extends globalThis.Error" : "";
+    const heritage = recordHeritage(context, isErrorSubclass);
     const doc = getDoc(record);
     const isConstructible = isConstructibleRecord(context, context.namespace.name, record);
-    const modifier = isConstructible ? "" : "abstract ";
+    const modifier = recordModifier(isConstructible);
+    const gtypeExpr = renderSourceGtype(context, record);
 
-    context.declare({
-        name: className,
-        code: `${doc}export ${modifier}class ${className}${heritage} {\n${body}\n}`,
-        owner: record.name,
-    });
+    if (gtypeExpr !== undefined && context.isTreeShaken) {
+        declareFoldedRecord(context, { record, className, doc, modifier, heritage, body, gtypeExpr });
+    } else {
+        context.declare({
+            name: className,
+            code: `${doc}export ${modifier}class ${className}${heritage} {\n${body}\n}`,
+            owner: record.name,
+        });
+
+        appendWrapperClassRegistration(context, {
+            className,
+            gtypeExpr,
+        });
+    }
 
     if (isConstructible) {
         context.declare({
@@ -49,13 +103,6 @@ const generateRecord = (context: ModuleContext, record: GirRecord): void => {
             code: renderRecordConstructorPropsInterface(context, record, className),
         });
     }
-
-    const gtypeExpr = renderSourceGtype(context, record);
-
-    appendWrapperClassRegistration(context, {
-        className,
-        gtypeExpr,
-    });
 };
 
 const renderRecordMembers = (

package/src/store/gi/registration.ts

@@ -25,7 +25,7 @@ const appendWrapperClassRegistration = (
 
     context.addRuntimeImport("registerWrapperClass");
     const args = vfuncs === undefined ? gtypeExpr : `${gtypeExpr}, ${vfuncs}`;
-    context.module.appendRegistration(`registerWrapperClass(${className}, ${args});`, [className]);
+    context.collectRegistration(`registerWrapperClass(${className}, ${args});`, [className]);
 };
 
 const appendInterfaceRegistration = (context: ModuleContext, registration: InterfaceRegistration): void => {
@@ -38,7 +38,7 @@ const appendInterfaceRegistration = (context: ModuleContext, registration: Inter
     context.addRuntimeImport("registerInterface");
     const base = `${className}, ${gtypeExpr}, ${makerName}`;
     const args = layout === undefined ? base : `${base}, ${layout}`;
-    context.module.appendRegistration(`registerInterface(${args});`, [className, makerName]);
+    context.collectRegistration(`registerInterface(${args});`, [className, makerName]);
 };
 
 export { appendWrapperClassRegistration, appendInterfaceRegistration };

package/src/store/gi/return-wrap.ts

@@ -69,7 +69,7 @@ const wrapAlias = (
 
 const wrapValue = (context: ModuleContext, ref: TypeId, valueExpression: string): string => {
     context.addRuntimeImport("fromNative");
-    const descriptor = context.hoistDescriptor(renderDescriptor(context, ref, "none"));
+    const descriptor = context.hoistDescriptor(renderDescriptor(context, ref, "none", { isReceived: true }));
 
     return `(fromNative(${descriptor}, ${valueExpression}) as ${renderTsType(context, ref, false)})`;
 };

package/src/store/gi/signal.ts

@@ -318,7 +318,7 @@ const renderEmitReturnArg = (context: ModuleContext, returnValue: GirReturnValue
         return "";
     }
 
-    return `, ${renderDescriptor(context, returnValue.type, returnValue.transferOwnership)}`;
+    return `, ${renderDescriptor(context, returnValue.type, returnValue.transferOwnership, { isReceived: true })}`;
 };
 
 const renderEmitCase = (context: ModuleContext, signal: GirCallable): string => {
@@ -332,7 +332,10 @@ const renderEmitCase = (context: ModuleContext, signal: GirCallable): string =>
     let argIndex = 0;
 
     const argLiterals = params.map((parameter) => {
-        const descriptor = renderDescriptor(context, parameter.type, parameter.transferOwnership);
+        const descriptor = renderDescriptor(context, parameter.type, parameter.transferOwnership, {
+            isReceived: true,
+        });
+
         const rendered = renderEmitArgLiteral({ context, parameter, descriptor, argIndex });
         argIndex = rendered.nextArgIndex;
 
@@ -366,7 +369,9 @@ const renderCallback = (context: ModuleContext, signal: GirCallable): string =>
 
     return tCallback({
         argTypes: callbackArgs,
-        returns: renderDescriptor(context, signal.returnValue.type, signal.returnValue.transferOwnership),
+        returns: renderDescriptor(context, signal.returnValue.type, signal.returnValue.transferOwnership, {
+            isReceived: true,
+        }),
         options: [
             "hasDestroy: true",
             "destroyKind: \"closureNotify\"",

package/src/store/gi/vtable.ts

@@ -627,6 +627,7 @@ const renderVtableSlotDescriptor = (context: ModuleContext, vtable: Vtable, slot
         context,
         callback.returnValue.type,
         callback.returnValue.transferOwnership,
+        { isReceived: true },
     );
 
     const lines = [

package/src/store/gi-store.ts

@@ -14,6 +14,7 @@ import { buildManifest, namespaceBarrel, type StoreOptions, subpathExport, write
 type GiNamespaceInput = {
     directory: string;
     rawSource: string;
+    rawBootstrapSource?: string | undefined;
     girFile: string;
 };
 
@@ -29,6 +30,7 @@ type GiStoreRecords = {
 };
 
 const OVERRIDES_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "overrides");
+const TREE_SHAKEN_SIDE_EFFECTS = ["**/bootstrap.js", "**/overrides/*.js", "**/index.js"];
 
 const overrideFiles = (directory: string): SourceModule[] => {
     const dir = join(OVERRIDES_ROOT, directory);
@@ -48,21 +50,25 @@ const overrideModule = (fileName: string, overridePath: string): SourceModule =>
     origin: overridePath,
 });
 
-const barrelFile = (directory: string, girFile: string): SourceModule => {
+const barrelFile = (directory: string, girFile: string, hasBootstrap: boolean): SourceModule => {
     const barrel = namespaceBarrel(directory);
     const overrideIndex = join(OVERRIDES_ROOT, directory, "index.ts.ejs");
 
-    if (!existsSync(overrideIndex)) {
-        return { ...barrel, origin: girFile };
+    const file = existsSync(overrideIndex)
+        ? overrideModule(barrel.fileName, overrideIndex)
+        : { ...barrel, origin: girFile };
+
+    if (!hasBootstrap) {
+        return file;
     }
 
-    return overrideModule(barrel.fileName, overrideIndex);
+    return { ...file, source: `import "./bootstrap.js";\n${file.source}` };
 };
 
 const externalShimModule = ({ directory, packageName, girFile }: GiExternalNamespaceInput): SourceModule => ({
     fileName: `${directory}/index.ts`,
     source:
-        `/** @deprecated Import from "${packageName}" instead; this alias is removed in GTKX 2.0. */\n` +
+        `/** @deprecated Since 1.3. Import from "${packageName}" instead. Removed in v2. */\n` +
         `export * from "${packageName}";\n`,
     origin: girFile,
 });
@@ -74,13 +80,17 @@ const collectStoreSources = (
     const exportsMap: Record<string, unknown> = {};
     const collected: SourceModule[] = [];
 
-    for (const { directory, rawSource, girFile } of namespaces) {
+    for (const { directory, rawSource, rawBootstrapSource, girFile } of namespaces) {
         collected.push(
             { fileName: `${directory}/${directory}.ts`, source: rawSource, origin: girFile },
             ...overrideFiles(directory),
-            barrelFile(directory, girFile),
+            barrelFile(directory, girFile, rawBootstrapSource !== undefined),
         );
 
+        if (rawBootstrapSource !== undefined) {
+            collected.push({ fileName: `${directory}/bootstrap.ts`, source: rawBootstrapSource, origin: girFile });
+        }
+
         exportsMap[`./${directory}`] = subpathExport(`${directory}/index`);
     }
 
@@ -107,6 +117,7 @@ const writeGiStore = (
     records: GiStoreRecords,
 ): void => {
     const { collected, exportsMap } = collectStoreSources(namespaces, externalNamespaces);
+    const isTreeShaken = namespaces.some((namespace) => namespace.rawBootstrapSource !== undefined);
 
     writeStore({
         storeDir: options.storeDir,
@@ -116,6 +127,7 @@ const writeGiStore = (
             name: "@gtkx/gi",
             version: options.version,
             exports: exportsMap,
+            sideEffects: isTreeShaken ? TREE_SHAKEN_SIDE_EFFECTS : true,
             peerDependencies: storePeerDependencies(externalNamespaces),
         }),
         rawFiles: [

package/src/store/jsx/element-components.ts

@@ -1,8 +1,9 @@
-import { sourceStringLiteral } from "@gtkx/utils";
+import { sanitizeTypeIdentifier, sourceStringLiteral } from "@gtkx/utils";
 import type { Library } from "../../gir/library.js";
 import type { GirNamespace } from "../../gir/namespace.js";
 import type { ImportsBuilder } from "../../writer/imports.js";
 import type { LazyElementSpec } from "./element-prop-types.js";
+import { externalPackageFor } from "../../gir/external-namespaces.js";
 import { getDoc } from "../gi/doc-spec.js";
 import { ancestorGlibNames, type GlibNamedClass } from "./intrinsic-elements.js";
 
@@ -23,6 +24,13 @@ type CandidateExportOptions = {
     components: Record<string, ElementComponent>;
 };
 
+type LazyMetadataOptions = {
+    isTreeShaken: boolean;
+    intrinsicNames: Set<string>;
+};
+
+const METADATA_ALIAS = "Metadata$";
+
 const generateElementComponentsSection = (
     targetNamespace: GirNamespace,
     library: Library,
@@ -45,7 +53,11 @@ const generateElementComponentsSection = (
         components: options.components,
     });
 
-    collectLazyElementExports(collector, lazyElements);
+    collectLazyElementExports(collector, lazyElements, {
+        isTreeShaken: library.isTreeShaken,
+        intrinsicNames: new Set(options.intrinsicElements.map((entry) => entry.glibName)),
+    });
+
     const source = collector.exportLines.join("\n\n");
 
     return { source, exportedNames: collector.exportedNames };
@@ -81,18 +93,75 @@ const collectCandidateExports = (collector: ExportCollector, options: CandidateE
     }
 };
 
-const collectLazyElementExports = (collector: ExportCollector, lazyElements: LazyElementSpec[]): void => {
+const collectLazyElementExports = (
+    collector: ExportCollector,
+    lazyElements: LazyElementSpec[],
+    options: LazyMetadataOptions,
+): void => {
     for (const spec of lazyElements) {
         collector.imports.addNamed("@gtkx/react/internal", "createElementComponent", false);
         collector.imports.addNamed("react", "ReactNode", true);
-        collector.exportLines.push(renderLazyElementExport(spec));
+
+        const refs = {
+            classRef: lazyClassRef(collector, spec, options),
+            metadataRef: lazyMetadataRef(collector, spec, options),
+        };
+
+        collector.exportLines.push(renderLazyElementExport(spec, refs, options));
         collector.exportedNames.add(spec.element);
     }
 };
 
-const renderLazyElementExport = (spec: LazyElementSpec): string => {
+const lazyMetadataRef = (
+    collector: ExportCollector,
+    spec: LazyElementSpec,
+    options: LazyMetadataOptions,
+): string | undefined => {
+    if (!options.isTreeShaken || !options.intrinsicNames.has(spec.element)) {
+        return undefined;
+    }
+
+    collector.imports.addNamespace("../metadata.js", METADATA_ALIAS, false);
+
+    return `${METADATA_ALIAS}.${spec.element}`;
+};
+
+const lazyClassRef = (
+    collector: ExportCollector,
+    spec: LazyElementSpec,
+    options: LazyMetadataOptions,
+): string | undefined => {
+    if (!options.isTreeShaken) {
+        return undefined;
+    }
+
+    const alias = `${spec.namespaceName}$`;
+    const specifier = externalPackageFor(spec.namespaceName) ?? `@gtkx/gi/${spec.namespaceName.toLowerCase()}`;
+    collector.imports.addNamespace(specifier, alias, false);
+
+    return `${alias}.${sanitizeTypeIdentifier(spec.className)}`;
+};
+
+const renderLazyElementExport = (
+    spec: LazyElementSpec,
+    refs: { classRef: string | undefined; metadataRef: string | undefined },
+    options: LazyMetadataOptions,
+): string => {
     const doc = getDoc(spec);
-    const factory = `createElementComponent(${sourceStringLiteral(spec.element)})`;
+    const args = [sourceStringLiteral(spec.element)];
+
+    if (refs.classRef !== undefined) {
+        args.push(refs.classRef);
+    } else if (refs.metadataRef !== undefined) {
+        args.push("undefined");
+    }
+
+    if (refs.metadataRef !== undefined) {
+        args.push(refs.metadataRef);
+    }
+
+    const pure = options.isTreeShaken ? "/* @__PURE__ */ " : "";
+    const factory = `${pure}createElementComponent(${args.join(", ")})`;
     const component = `${doc}export const ${spec.element}: (props: ${spec.typeName}) => ReactNode = ${factory};`;
 
     return `${doc}${spec.typeSource}\n\n${component}`;
@@ -114,9 +183,21 @@ const renderCandidateExport = (
         imports.addNamed(component.module, component.export, false);
     }
 
+    let classRef: string | undefined;
+    let metadataRef: string | undefined;
+
+    if (library.isTreeShaken) {
+        const alias = `${namespace.name}$`;
+        const specifier = externalPackageFor(namespace.name) ?? `@gtkx/gi/${namespace.name.toLowerCase()}`;
+        imports.addNamespace(specifier, alias, false);
+        imports.addNamespace("../metadata.js", METADATA_ALIAS, false);
+        classRef = `${alias}.${sanitizeTypeIdentifier(klass.name)}`;
+        metadataRef = `${METADATA_ALIAS}.${glibName}`;
+    }
+
     const doc = getDoc(klass);
 
-    return `${doc}${renderElementComponentExport(glibName, component)}`;
+    return `${doc}${renderElementComponentExport(glibName, component, classRef, metadataRef)}`;
 };
 
 const resolveElementComponent = (
@@ -134,16 +215,32 @@ const resolveElementComponent = (
     return undefined;
 };
 
-const renderElementComponentExport = (glibName: string, component: ElementComponent | undefined): string => {
+const renderElementComponentExport = (
+    glibName: string,
+    component: ElementComponent | undefined,
+    classRef: string | undefined,
+    metadataRef: string | undefined,
+): string => {
     const propsType = `${glibName}Props`;
     const annotation = `(props: ${propsType}) => ReactNode`;
-    const factoryCall = `createElementComponent(${sourceStringLiteral(glibName)})`;
+    const args = [sourceStringLiteral(glibName)];
+
+    if (classRef !== undefined) {
+        args.push(classRef);
+    }
+
+    if (metadataRef !== undefined) {
+        args.push(metadataRef);
+    }
+
+    const pure = classRef === undefined ? "" : "/* @__PURE__ */ ";
+    const factoryCall = `${pure}createElementComponent(${args.join(", ")})`;
 
     if (component === undefined) {
         return `export const ${glibName}: ${annotation} = ${factoryCall};`;
     }
 
-    return `export const ${glibName}: ${annotation} = ${component.export}(${factoryCall});`;
+    return `export const ${glibName}: ${annotation} = ${pure}${component.export}(${factoryCall});`;
 };
 
 export { generateElementComponentsSection, type ElementComponentOverrides };

package/src/store/jsx/element-prop-types.ts

@@ -10,6 +10,8 @@ type LazyElementSpec = {
     typeSource: string;
     doc: string | undefined;
     annotations: GirAnnotations;
+    namespaceName: string;
+    className: string;
 };
 
 const appendConstructOnlyNames = (klass: GirClass, names: string[]): void => {
@@ -43,6 +45,8 @@ const createLazyElementSpec = (context: GirIndex, element: string, entry: GirTyp
         typeSource: `export type ${typeName} = ${base} & { children?: ReactNode };`,
         doc: entry.klass.doc,
         annotations: entry.klass.annotations,
+        namespaceName: entry.namespace.name,
+        className: entry.klass.name,
     };
 };