@gtkx/codegen 1.5.0 → 1.6.0

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/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);