@gtkx/codegen 1.4.0 → 1.6.0

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,
     };
 };
 

package/src/store/jsx/metadata.ts

@@ -8,6 +8,7 @@ import type { GirType } from "../../gir/type.js";
 import { inputParameters } from "../../analysis/param-structure.js";
 import { type GirProperty, isConstructableProperty } from "../../gir/property.js";
 import {
+    ancestorGlibNames,
     implementedInterfaces,
     isIntrinsicElementClass,
     iterateClassesWithGlibName,
@@ -18,6 +19,7 @@ type IntrinsicElementEntry = {
     glibName: string;
     signals: [string, string][];
     properties: [string, string][];
+    ancestors: string[];
 };
 
 const READABLE = 1;
@@ -35,6 +37,10 @@ const FLOAT_PATTERN = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
 const generateMetadata = (library: Library): string => {
     const intrinsicElements = collectIntrinsicElements(library);
 
+    if (library.isTreeShaken) {
+        return generateEntryMetadata(intrinsicElements);
+    }
+
     const signalsEntries = intrinsicElements.map(
         ({ glibName, signals }) => `    "${glibName}": ${renderSignalsObject(signals)},`,
     );
@@ -51,6 +57,40 @@ const generateMetadata = (library: Library): string => {
     ].join("\n\n")}\n`;
 };
 
+const entryAncestorsInSet = (entry: IntrinsicElementEntry, names: Set<string>): string[] =>
+    entry.ancestors.filter((name) => name !== entry.glibName && names.has(name));
+
+const compareEntriesByDepth = (
+    names: Set<string>,
+): ((first: IntrinsicElementEntry, second: IntrinsicElementEntry) => number) =>
+    (first, second) =>
+        entryAncestorsInSet(first, names).length - entryAncestorsInSet(second, names).length ||
+        first.glibName.localeCompare(second.glibName);
+
+const renderEntryExport = (entry: IntrinsicElementEntry, names: Set<string>): string => {
+    const parent = entryAncestorsInSet(entry, names)[0] ?? "undefined";
+    const literal = sourceStringLiteral(entry.glibName);
+    const ownSignals = renderSignalsObject(entry.signals);
+    const ownProperties = renderPropertiesObject(entry.properties);
+    const call = `registerElementMetadata(${literal}, ${parent}, ${ownSignals}, ${ownProperties})`;
+
+    return `export const ${entry.glibName}: string = /* @__PURE__ */ ${call};`;
+};
+
+const generateEntryMetadata = (intrinsicElements: IntrinsicElementEntry[]): string => {
+    const names = new Set(intrinsicElements.map((entry) => entry.glibName));
+    const ordered = intrinsicElements.toSorted(compareEntriesByDepth(names));
+    const lines = ordered.map((entry) => renderEntryExport(entry, names));
+
+    return `${[
+        "import { registerElementMetadata } from \"@gtkx/runtime/internal\";",
+        PROPERTY_ENTRY_TYPE,
+        "export const signals: Record<string, Record<string, string>> = {};",
+        "export const properties: Record<string, Record<string, PropertyEntry>> = {};",
+        lines.join("\n\n"),
+    ].join("\n\n")}\n`;
+};
+
 const collectIntrinsicElements = (library: Library): IntrinsicElementEntry[] => {
     const entries: IntrinsicElementEntry[] = [];
     const seen: Set<string> = new Set();
@@ -71,6 +111,7 @@ const collectIntrinsicElements = (library: Library): IntrinsicElementEntry[] =>
             glibName,
             signals: collectSignals(sources),
             properties: collectProperties(library, sources),
+            ancestors: ancestorGlibNames(klass, namespace, library),
         });
     }
 

package/src/store/jsx-store.ts

@@ -9,12 +9,17 @@ type WriteJsxStoreParams = {
     metadata: string;
     externalPackages: string[];
     rawFiles: RawFile[];
+    isTreeShaken?: boolean;
 };
 
-const jsxPeerDependencies = (externalPackages: string[]): Record<string, string> =>
-    Object.fromEntries(
-        sortStrings(["@gtkx/gi", "@gtkx/react", "react", ...externalPackages]).map((name) => [name, "*"]),
+const jsxPeerDependencies = (externalPackages: string[], isTreeShaken: boolean): Record<string, string> => {
+    const runtime = isTreeShaken ? ["@gtkx/runtime"] : [];
+
+    return Object.fromEntries(
+        sortStrings(["@gtkx/gi", "@gtkx/react", "react", ...runtime, ...externalPackages])
+            .map((name) => [name, "*"]),
     );
+};
 
 const writeJsxStore = (params: WriteJsxStoreParams): void => {
     const { options, namespaces, metadata, externalPackages, rawFiles } = params;
@@ -43,7 +48,8 @@ const writeJsxStore = (params: WriteJsxStoreParams): void => {
             name: "@gtkx/jsx",
             version: options.version,
             exports: exportsMap,
-            peerDependencies: jsxPeerDependencies(externalPackages),
+            sideEffects: params.isTreeShaken !== true,
+            peerDependencies: jsxPeerDependencies(externalPackages, params.isTreeShaken === true),
         }),
         rawFiles,
     });

package/src/store/resolve-store.ts

@@ -28,6 +28,8 @@ const STORE_CONSUMERS: string[] = [
     "@gtkx/cli",
     "@gtkx/components",
     "@gtkx/css",
+    "@gtkx/forms",
+    "@gtkx/i18n",
     "@gtkx/navigation",
     "@gtkx/react",
     "@gtkx/runtime",

package/src/store/store-fs.ts

@@ -31,7 +31,7 @@ type Manifest = {
     name: string;
     type: "module";
     version: string;
-    sideEffects: true;
+    sideEffects: boolean | string[];
     exports: Record<string, unknown>;
     peerDependencies?: Record<string, string>;
 };
@@ -40,6 +40,7 @@ type ManifestInput = {
     name: string;
     version: string;
     exports: Record<string, unknown>;
+    sideEffects?: boolean | string[];
     peerDependencies?: Record<string, string>;
 };
 
@@ -71,7 +72,7 @@ const buildManifest = (input: ManifestInput): Manifest => {
         name: input.name,
         type: "module",
         version: input.version,
-        sideEffects: true,
+        sideEffects: input.sideEffects ?? true,
         exports: { "./package.json": "./package.json", ...input.exports },
     };
 

package/src/writer/context.ts

@@ -3,16 +3,56 @@ import type { GirNamespace } from "../gir/namespace.js";
 import { externalPackageFor } from "../gir/external-namespaces.js";
 import { type Declaration, ModuleBuilder } from "./module.js";
 
+type BootstrapCallOptions = {
+    moduleExports?: string[];
+    runtimeImports?: string[];
+};
+
+const addExternalNamespaceImport = (context: ModuleContext, packageName: string, namespaceName: string): void => {
+    if (context.isTreeShaken) {
+        context.externalDependencies.add(packageName);
+    } else {
+        context.module.imports.addSideEffect(packageName);
+    }
+
+    context.module.imports.addNamespace(packageName, namespaceName);
+};
+
+const addInternalNamespaceImport = (context: ModuleContext, namespaceName: string): void => {
+    const directory = namespaceName.toLowerCase();
+    const isFoundational = directory === "gobject" || directory === "glib";
+    const path = isFoundational ? `../${directory}/${directory}.js` : `../${directory}/index.js`;
+
+    if (context.isTreeShaken) {
+        context.dependencies.add(directory);
+    } else if (!isFoundational) {
+        context.module.imports.addSideEffect(path);
+    }
+
+    context.module.imports.addNamespace(path, namespaceName);
+};
+
 class ModuleContext {
+    private registrationSink: string[] | undefined;
+    private readonly hoistedBases: Map<string, string> = new Map();
     public module: ModuleBuilder = new ModuleBuilder();
     public namespace: GirNamespace;
     public library: Library;
+    public dependencies: Set<string> = new Set();
+    public externalDependencies: Set<string> = new Set();
+    public bootstrapCalls: string[] = [];
+    public bootstrapModuleExports: Set<string> = new Set();
+    public bootstrapRuntimeImports: Set<string> = new Set();
 
     constructor(namespace: GirNamespace, library: Library) {
         this.namespace = namespace;
         this.library = library;
     }
 
+    get isTreeShaken(): boolean {
+        return this.library.isTreeShaken;
+    }
+
     addRuntimeImport(name: string): void {
         this.module.imports.addNamed("@gtkx/runtime", name);
     }
@@ -25,7 +65,47 @@ class ModuleContext {
         return this.module.hoistDescriptor(expression);
     }
 
+    beginRegistrations(): void {
+        this.registrationSink = [];
+    }
+
+    takeRegistrations(): string[] {
+        const collected = this.registrationSink ?? [];
+        this.registrationSink = undefined;
+
+        return collected;
+    }
+
+    collectRegistration(code: string, requires: string[] = []): void {
+        if (this.registrationSink === undefined) {
+            this.module.appendRegistration(code, requires);
+
+            return;
+        }
+
+        this.registrationSink.push(code);
+    }
+
+    addBootstrapCall(code: string, options: BootstrapCallOptions = {}): void {
+        const moduleExports = options.moduleExports ?? [];
+        const runtimeImports = options.runtimeImports ?? [];
+
+        for (const name of moduleExports) {
+            this.bootstrapModuleExports.add(name);
+        }
+
+        for (const name of runtimeImports) {
+            this.bootstrapRuntimeImports.add(name);
+        }
+
+        this.bootstrapCalls.push(code);
+    }
+
     addGObjectBootstrapImports(): void {
+        if (this.isTreeShaken) {
+            return;
+        }
+
         if (this.namespace.name === "GObject") {
             return;
         }
@@ -46,33 +126,23 @@ class ModuleContext {
 
         const packageName = externalPackageFor(namespaceName);
 
-        if (packageName !== undefined) {
-            this.module.imports.addSideEffect(packageName);
-            this.module.imports.addNamespace(packageName, namespaceName);
-
-            return namespaceName;
-        }
-
-        const directory = namespaceName.toLowerCase();
-        const isFoundational = directory === "gobject" || directory === "glib";
-        const path = isFoundational ? `../${directory}/${directory}.js` : `../${directory}/index.js`;
-
-        if (!isFoundational) {
-            this.module.imports.addSideEffect(path);
+        if (packageName === undefined) {
+            addInternalNamespaceImport(this, namespaceName);
+        } else {
+            addExternalNamespaceImport(this, packageName, namespaceName);
         }
 
-        this.module.imports.addNamespace(path, namespaceName);
-
         return namespaceName;
     }
 
     declare(declaration: Declaration): void {
-        const { name, code, owner } = declaration;
+        const { name, code, owner, isLocal } = declaration;
 
         this.module.appendDeclaration({
             name,
             code,
             owner: owner === undefined ? undefined : `${this.namespace.name}.${owner}`,
+            isLocal,
         });
     }
 
@@ -83,6 +153,29 @@ class ModuleContext {
 
         return `${this.addCrossNamespaceImport(namespaceName)}.${name}`;
     }
+
+    hoistBaseRef(expression: string): string {
+        if (!expression.includes(".")) {
+            return expression;
+        }
+
+        const existing = this.hoistedBases.get(expression);
+
+        if (existing !== undefined) {
+            return existing;
+        }
+
+        const local = `_${expression.replaceAll(".", "_")}`;
+        this.hoistedBases.set(expression, local);
+
+        this.module.appendDeclaration({
+            name: local,
+            code: `const ${local}: typeof ${expression} = ${expression};`,
+            isLocal: true,
+        });
+
+        return local;
+    }
 }
 
 export { ModuleContext };

package/src/writer/emit.ts

@@ -32,4 +32,6 @@ const arrayLiteral = (elements: string[]): string => {
     return `[\n${lines.join("\n")}\n]`;
 };
 
-export { indent, renderBlock, renderBraced, renderBracedOrEmpty, indentMembers, joinArgs, arrayLiteral };
+const pure = (expression: string): string => `/* @__PURE__ */ ${expression}`;
+
+export { indent, renderBlock, renderBraced, renderBracedOrEmpty, indentMembers, joinArgs, arrayLiteral, pure };

package/src/writer/imports.ts

@@ -62,8 +62,16 @@ class ImportsBuilder {
     }
 
     addNamespace(specifier: string, alias: string, isType = false): void {
-        if (!this.namespaces.has(specifier)) {
+        const existing = this.namespaces.get(specifier);
+
+        if (existing === undefined) {
             this.namespaces.set(specifier, { alias, isType });
+
+            return;
+        }
+
+        if (!isType && existing.isType) {
+            existing.isType = false;
         }
     }
 

package/src/writer/module.ts

@@ -1,9 +1,11 @@
+import { pure } from "./emit.js";
 import { ImportsBuilder } from "./imports.js";
 
 type Declaration = {
     name: string;
     code: string;
     owner?: string | undefined;
+    isLocal?: boolean | undefined;
 };
 
 type ExportedDeclaration = {
@@ -127,12 +129,18 @@ class ModuleBuilder {
 
         const name = `_desc${String(this.hoistedDescriptors.size)}`;
         this.hoistedDescriptors.set(expression, name);
-        this.appendBinding(`const ${name} = ${expression};`, name);
+        this.appendBinding(`const ${name} = ${pure(expression)};`, name);
 
         return name;
     }
 
     appendDeclaration(declaration: Declaration): void {
+        if (declaration.isLocal === true) {
+            this.declarations.push(declaration.code);
+
+            return;
+        }
+
         this.claimExportedName(declaration);
         this.claimTypeName(declaration);
         this.declaredNames.add(declaration.name);