@gtkx/codegen 0.21.0 → 1.0.0-rc.1

package/src/store/gi/callables.ts

@@ -0,0 +1,309 @@
+import { toCamelCase, toCamelIdentifier, uniqBy } from "@gtkx/utils";
+import { hasCallerAllocatedArrayLength } from "../../analysis/param-structure.js";
+import type { GirFunction } from "../../gir/function.js";
+import type { ModuleContext } from "../../writer/context.js";
+import { renderJsDoc } from "../../writer/doc.js";
+import { renderBlock } from "../../writer/emit.js";
+import { matchAsyncFinish } from "./async.js";
+import { callableReferencesClassStruct } from "./class-struct-record.js";
+import { renderFnExpression } from "./function.js";
+import { gtypeMemberDeclaration } from "./gtype-binding.js";
+import {
+    boundFinishExpression,
+    methodExportName,
+    renderMethodBody,
+    renderMethodReturnType,
+    renderMethodSignature,
+    renderPromisifiedBody,
+    renderPromisifiedSignature,
+} from "./method.js";
+import { renderRuntimeOverride } from "./runtime-override.js";
+
+export type Callables = {
+    constructors: GirFunction[];
+    functions: GirFunction[];
+    methods: GirFunction[];
+};
+
+export const dedupeCallables = (callables: GirFunction[]): GirFunction[] =>
+    uniqBy(
+        callables.filter(
+            (callable): callable is GirFunction & { cIdentifier: string } => callable.cIdentifier !== undefined,
+        ),
+        (callable) => callable.cIdentifier,
+    );
+
+export const generateBindings = (context: ModuleContext, callables: Callables): void => {
+    const all = [...callables.constructors, ...callables.functions, ...callables.methods];
+    for (const callable of all) {
+        if (!callable.introspectable) continue;
+        if (callable.shadowedBy !== undefined) continue;
+        if (callable.cIdentifier === undefined) continue;
+        if (callableReferencesClassStruct(context, callable)) continue;
+        const expression = renderFnExpression(context, callable);
+        if (expression === undefined) continue;
+        context.module.appendBinding(
+            `const ${toCamelIdentifier(callable.cIdentifier)} = ${expression};`,
+            callable.cIdentifier,
+        );
+    }
+};
+
+type CallableMemberOptions = {
+    resolveName: (callable: GirFunction) => string | undefined;
+    isStatic: boolean;
+    returnTypeOverride?: string | undefined;
+    allowRuntimeOverride?: boolean;
+};
+
+const renderCallableMember = (
+    context: ModuleContext,
+    callable: GirFunction,
+    options: CallableMemberOptions,
+): string | undefined => {
+    if (!isEmittableCallable(context, callable)) return undefined;
+    const cIdentifier = callable.cIdentifier;
+    if (cIdentifier === undefined) return undefined;
+    const name = options.resolveName(callable);
+    if (name === undefined || name === "constructor") return undefined;
+    const doc = renderJsDoc(callable.doc);
+    if (options.allowRuntimeOverride === true) {
+        const override = renderRuntimeOverride(callable, name);
+        if (override !== undefined) return `${doc}${override}`;
+    }
+    const signature = renderMethodSignature(context, callable);
+    const returnType = options.returnTypeOverride ?? renderMethodReturnType(context, callable);
+    const bindingExpression = toCamelIdentifier(cIdentifier);
+    const body = renderMethodBody(context, callable, {
+        bindingExpression,
+        returnTypeOverride: options.returnTypeOverride,
+    });
+    return `${doc}${renderBlock(`${options.isStatic ? "static " : ""}${name}(${signature}): ${returnType}`, body)}`;
+};
+
+type StaticEntryOptions = {
+    resolveName: (callable: GirFunction) => string | undefined;
+    returnTypeOverride?: string | undefined;
+};
+
+const renderStaticEntry = (
+    context: ModuleContext,
+    callable: GirFunction,
+    siblings: GirFunction[],
+    options: StaticEntryOptions,
+): string | undefined => {
+    const finishFn = matchStaticFinishFunction(context, callable, siblings);
+    if (finishFn !== undefined) {
+        const name = options.resolveName(callable);
+        if (name === undefined || name === "constructor") return undefined;
+        return renderPromisifiedCallable(context, callable, finishFn, { name, isStatic: true });
+    }
+    return renderCallableMember(context, callable, {
+        resolveName: options.resolveName,
+        isStatic: true,
+        returnTypeOverride: options.returnTypeOverride,
+    });
+};
+
+const renderInstanceMethod = (
+    context: ModuleContext,
+    callable: GirFunction,
+    nameOverride?: string,
+): string | undefined =>
+    renderCallableMember(context, callable, {
+        resolveName: (member) => nameOverride ?? methodExportName(member),
+        isStatic: false,
+        allowRuntimeOverride: true,
+    });
+
+type ResolvedInstanceMember = {
+    name: string;
+    finishFn: GirFunction | undefined;
+};
+
+const resolveInstanceMember = (
+    context: ModuleContext,
+    callable: GirFunction,
+    siblings: Map<string, GirFunction>,
+    nameOverride?: string,
+): ResolvedInstanceMember | undefined => {
+    if (!isEmittableCallable(context, callable)) return undefined;
+    const name = nameOverride ?? methodExportName(callable);
+    if (name === "constructor") return undefined;
+    const finishFn = matchFinishFunction(context, callable, siblings);
+    if (finishFn !== undefined && !isEmittableCallable(context, finishFn)) return undefined;
+    return { name, finishFn };
+};
+
+type InstanceMemberRenderer = (
+    context: ModuleContext,
+    callable: GirFunction,
+    siblings: Map<string, GirFunction>,
+    nameOverride?: string,
+) => string | undefined;
+
+const instanceMemberRenderer =
+    (
+        render: (context: ModuleContext, callable: GirFunction, member: ResolvedInstanceMember) => string | undefined,
+    ): InstanceMemberRenderer =>
+    (context, callable, siblings, nameOverride) => {
+        const member = resolveInstanceMember(context, callable, siblings, nameOverride);
+        return member === undefined ? undefined : render(context, callable, member);
+    };
+
+export const renderInstanceMethodSignature: InstanceMemberRenderer = instanceMemberRenderer(
+    (context, callable, { name, finishFn }) => {
+        const doc = renderJsDoc(callable.doc);
+        if (finishFn !== undefined) {
+            const { signature, returnType } = renderPromisifiedSignature(context, callable, finishFn);
+            return `${doc}${name}(${signature}): ${returnType};`;
+        }
+        const signature = renderMethodSignature(context, callable);
+        const returnType = renderMethodReturnType(context, callable);
+        return `${doc}${name}(${signature}): ${returnType};`;
+    },
+);
+
+export const renderClassInstanceMember: InstanceMemberRenderer = instanceMemberRenderer(
+    (context, callable, { name, finishFn }) =>
+        finishFn !== undefined
+            ? renderPromisifiedCallable(context, callable, finishFn, { name, isStatic: false })
+            : renderInstanceMethod(context, callable, name),
+);
+
+const matchFinishFunction = (
+    context: ModuleContext,
+    callable: GirFunction,
+    siblings: Map<string, GirFunction>,
+): GirFunction | undefined => matchAsyncFinish(context.library, callable, [...siblings.values()]);
+
+export const matchStaticFinishFunction = (
+    context: ModuleContext,
+    callable: GirFunction,
+    siblings: GirFunction[],
+): GirFunction | undefined => {
+    if (!isEmittableCallable(context, callable)) return undefined;
+    const finishFn = matchAsyncFinish(context.library, callable, siblings);
+    if (finishFn === undefined || !isEmittableCallable(context, finishFn)) return undefined;
+    return finishFn;
+};
+
+const renderPromisifiedCallable = (
+    context: ModuleContext,
+    callable: GirFunction,
+    finishFn: GirFunction,
+    member: { name: string; isStatic: boolean },
+): string | undefined => {
+    const cIdentifier = callable.cIdentifier;
+    if (cIdentifier === undefined) return undefined;
+    const { signature, returnType } = renderPromisifiedSignature(context, callable, finishFn);
+    const body = renderPromisifiedBody(
+        context,
+        callable,
+        boundFinishExpression(finishFn),
+        toCamelIdentifier(cIdentifier),
+    );
+    const prefix = member.isStatic ? "static " : "";
+    return `${renderJsDoc(callable.doc)}${renderBlock(`${prefix}${member.name}(${signature}): ${returnType}`, body)}`;
+};
+
+export const indexMethodsByName = (methods: GirFunction[]): Map<string, GirFunction> => {
+    const map = new Map<string, GirFunction>();
+    for (const callable of methods) map.set(callable.name, callable);
+    return map;
+};
+
+export const isEmittableCallable = (context: ModuleContext, callable: GirFunction): boolean =>
+    callable.introspectable &&
+    callable.shadowedBy === undefined &&
+    callable.cIdentifier !== undefined &&
+    !callableReferencesClassStruct(context, callable) &&
+    !hasCallerAllocatedArrayLength(context.library, callable);
+
+const constructorMemberName = (girName: string): string | undefined => {
+    const camel = toCamelCase(girName);
+    if (camel === "constructor") return undefined;
+    return camel;
+};
+
+export const renderStaticSignature = (
+    context: ModuleContext,
+    callable: GirFunction,
+    options?: { returnTypeOverride?: string | undefined; siblings?: GirFunction[] | undefined },
+): { name: string; signature: string } | undefined => {
+    if (!isEmittableCallable(context, callable)) return undefined;
+    const name = constructorMemberName(callable.name);
+    if (name === undefined) return undefined;
+    const finishFn =
+        options?.siblings === undefined ? undefined : matchStaticFinishFunction(context, callable, options.siblings);
+    if (finishFn !== undefined) {
+        const { signature, returnType } = renderPromisifiedSignature(context, callable, finishFn);
+        return { name, signature: `${name}(${signature}): ${returnType}` };
+    }
+    const parameters = renderMethodSignature(context, callable);
+    const returnType = options?.returnTypeOverride ?? renderMethodReturnType(context, callable);
+    return { name, signature: `${name}(${parameters}): ${returnType}` };
+};
+
+export const classConstructorMemberNames = (context: ModuleContext, callables: Callables): string[] => {
+    const names: string[] = [];
+    for (const callable of callables.constructors) {
+        if (!isEmittableCallable(context, callable)) continue;
+        const member = constructorMemberName(callable.name);
+        if (member !== undefined) names.push(member);
+    }
+    return names;
+};
+
+export const renderStaticHead = (context: ModuleContext, callables: Callables, ownerClassName: string): string[] => {
+    const siblings = [...callables.constructors, ...callables.functions];
+    const blocks: string[] = [];
+    for (const callable of callables.constructors) {
+        const block = renderStaticEntry(context, callable, siblings, {
+            resolveName: (member) => constructorMemberName(member.name),
+            returnTypeOverride: ownerClassName,
+        });
+        if (block !== undefined) blocks.push(block);
+    }
+    for (const callable of callables.functions) {
+        const block = renderStaticEntry(context, callable, siblings, {
+            resolveName: (member) => toCamelCase(member.name),
+        });
+        if (block !== undefined) blocks.push(block);
+    }
+    return blocks;
+};
+
+const renderPlainInstanceMethods = (
+    context: ModuleContext,
+    methods: GirFunction[],
+    claimedNames: Set<string>,
+): string[] => {
+    const blocks: string[] = [];
+    for (const callable of methods) {
+        const block = renderInstanceMethod(context, callable);
+        if (block === undefined) continue;
+        blocks.push(block);
+        claimedNames.add(methodExportName(callable));
+    }
+    return blocks;
+};
+
+type PlainTypeMembersOptions = {
+    context: ModuleContext;
+    className: string;
+    callables: Callables;
+    hasGtype: boolean;
+};
+
+export const renderPlainTypeMembers = (
+    options: PlainTypeMembersOptions,
+): { members: string[]; claimedNames: Set<string> } => {
+    const { context, className, callables, hasGtype } = options;
+    const members: string[] = [];
+    if (hasGtype) members.push(gtypeMemberDeclaration(context));
+    const claimedNames = new Set<string>();
+    members.push(...renderStaticHead(context, callables, className));
+    members.push(...renderPlainInstanceMethods(context, callables.methods, claimedNames));
+    return { members, claimedNames };
+};

package/src/store/gi/callback.ts

@@ -0,0 +1,15 @@
+import { callbackAsFunction, type GirCallback } from "../../gir/callback.js";
+import type { ModuleContext } from "../../writer/context.js";
+import { renderJsDoc } from "../../writer/doc.js";
+import { renderMethodReturnType, renderMethodSignature } from "./method.js";
+
+export const generateCallback = (context: ModuleContext, callback: GirCallback): void => {
+    if (!callback.introspectable) return;
+    if (callback.name.length === 0) return;
+    const fn = callbackAsFunction(callback);
+    const signature = renderMethodSignature(context, fn);
+    const returnType = renderMethodReturnType(context, fn);
+    context.module.appendDeclaration(
+        `${renderJsDoc(callback.doc)}export type ${callback.name} = (${signature}) => ${returnType};`,
+    );
+};

package/src/store/gi/class-struct-record.ts

@@ -0,0 +1,40 @@
+import type { GirFunction } from "../../gir/function.js";
+import type { Library } from "../../gir/library.js";
+import type { GirRecord } from "../../gir/record.js";
+import type { TypeId } from "../../gir/type-id.js";
+import type { ModuleContext } from "../../writer/context.js";
+
+const TYPE_STRUCT_ROOTS = new Set(["GObject.TypeClass", "GObject.TypeInterface"]);
+
+const EXPLICIT_CLASS_STRUCTS = new Set(["Pango.AttrClass"]);
+
+const qualify = (namespaceName: string, name: string): string => `${namespaceName}.${name}`;
+
+export const isClassStructRecord = (library: Library, namespaceName: string, record: GirRecord): boolean => {
+    const qualified = qualify(namespaceName, record.name);
+    if (TYPE_STRUCT_ROOTS.has(qualified) || EXPLICIT_CLASS_STRUCTS.has(qualified)) return true;
+    const first = record.fields[0];
+    if (first === undefined || first.type === undefined) return false;
+    const name = library.nameOf(first.type);
+    if (name === undefined) return false;
+    return TYPE_STRUCT_ROOTS.has(qualify(name.namespaceName, name.typeName));
+};
+
+export const refIsClassStruct = (context: ModuleContext, ref: TypeId | undefined): boolean => {
+    if (ref === undefined) return false;
+    const type = context.library.typeOf(ref);
+    if (type === undefined) return false;
+    switch (type.kind) {
+        case "record":
+            return isClassStructRecord(context.library, type.namespace.name, type.value);
+        case "carray":
+        case "list":
+            return refIsClassStruct(context, type.element);
+        default:
+            return false;
+    }
+};
+
+export const callableReferencesClassStruct = (context: ModuleContext, fn: GirFunction): boolean =>
+    refIsClassStruct(context, fn.returnValue.type) ||
+    fn.parameters.some((parameter) => refIsClassStruct(context, parameter.type));

package/src/store/gi/class.ts

@@ -0,0 +1,212 @@
+import { toCamelIdentifier, toPascalCase } from "@gtkx/utils";
+import {
+    collectInheritedMethods,
+    collectInheritedPropertyTypes,
+    collectInterfaceMergeOmissions,
+    conflictRename,
+    type InheritedMethods,
+} from "../../analysis/inheritance.js";
+import { ancestorChain } from "../../gir/ancestry.js";
+import type { GirClass } from "../../gir/class.js";
+import type { GirFunction } from "../../gir/function.js";
+import { splitOptionalNamespace } from "../../gir/type-ref.js";
+import type { ModuleContext } from "../../writer/context.js";
+import { renderJsDoc } from "../../writer/doc.js";
+import { indentMembers } from "../../writer/emit.js";
+import {
+    type Callables,
+    classConstructorMemberNames,
+    dedupeCallables,
+    generateBindings,
+    indexMethodsByName,
+    renderClassInstanceMember,
+    renderStaticHead,
+} from "./callables.js";
+import { renderClassConstructor, renderConstructorPropsInterface } from "./constructor-props.js";
+import { gtypeExprFor, gtypeMemberDeclaration } from "./gtype-binding.js";
+import { methodExportName } from "./method.js";
+import { renderPropertyDeclarations } from "./properties.js";
+import { type ResolvedAccessor, renderResolvedPropertyAccessor, resolveAccessor } from "./property-accessor.js";
+import { appendWrapperClassRegistration } from "./registration.js";
+import { renderSignalDeclarations, renderSignalMembers } from "./signal.js";
+import { renderVfuncMetadata } from "./vtable.js";
+
+type ImplementedRef = {
+    typeRef: string;
+    makerRef: string;
+    interfaceKlass: GirClass;
+    interfaceNamespace: string;
+};
+
+export const generateClass = (context: ModuleContext, klass: GirClass): void => {
+    if (!klass.introspectable) return;
+    if (klass.name.length === 0) return;
+    const className = toPascalCase(klass.name);
+    const callables: Callables = {
+        constructors: dedupeCallables(klass.constructors),
+        functions: dedupeCallables(klass.functions),
+        methods: dedupeCallables(klass.methods),
+    };
+    generateBindings(context, callables);
+
+    const parentExpression = resolveParent(context, klass);
+    const extendsClause = renderExtendsClause(context, parentExpression, callables);
+    const implemented = resolveImplementedRefs(context, klass);
+    const typeRefs = implemented.map((ref) => ref.typeRef);
+    const implementsClause = typeRefs.length === 0 ? "" : ` implements ${typeRefs.join(", ")}`;
+    const { members, accessors } = renderClassMembers(context, klass, callables, parentExpression !== undefined);
+    const body = indentMembers(members);
+    context.module.appendDeclaration(
+        `${renderJsDoc(klass.doc)}export class ${className}${extendsClause}${implementsClause} {\n${body}\n}`,
+    );
+    context.module.appendDeclaration(renderConstructorPropsInterface(context, klass, className));
+    for (const declaration of renderPropertyDeclarations(context, klass, className, accessors)) {
+        context.module.appendDeclaration(declaration);
+    }
+    for (const declaration of renderSignalDeclarations(context, klass, className, false)) {
+        context.module.appendDeclaration(declaration);
+    }
+    if (typeRefs.length > 0) {
+        const mergeRefs = implemented.map((ref) => interfaceMergeRef(context, klass, ref));
+        context.module.appendDeclaration(`export interface ${className} extends ${mergeRefs.join(", ")} {}`);
+    }
+
+    appendInstallMixins(context, className, implemented);
+    appendClassRegistrations(context, klass, className);
+};
+
+type ClassMembers = { members: string[]; accessors: ResolvedAccessor[] };
+
+const renderClassMembers = (
+    context: ModuleContext,
+    klass: GirClass,
+    callables: Callables,
+    hasParent: boolean,
+): ClassMembers => {
+    const className = toPascalCase(klass.name);
+    const members: string[] = [gtypeMemberDeclaration(context)];
+    const constructorBlock = renderClassConstructor(context, klass, className, hasParent);
+    if (constructorBlock !== undefined) members.push(constructorBlock);
+    const claimedNames = new Set<string>();
+    members.push(...renderStaticHead(context, callables, className));
+    const inherited = collectInheritedMethods(context, klass);
+    const methodByName = indexMethodsByName(callables.methods);
+    appendInstanceMethods({
+        context,
+        methods: callables.methods,
+        methodByName,
+        inherited,
+        members,
+        claimedNames,
+        className,
+    });
+    const inheritedPropertyTypes = collectInheritedPropertyTypes(context, klass);
+    const accessors: ResolvedAccessor[] = [];
+    for (const property of klass.properties) {
+        const inheritedType = inheritedPropertyTypes.get(toCamelIdentifier(property.name));
+        const accessor = resolveAccessor({ context, property, claimedNames, methodByName, inheritedType });
+        if (accessor === undefined) continue;
+        accessors.push(accessor);
+        members.push(renderResolvedPropertyAccessor(context, property, accessor));
+    }
+    members.push(...renderSignalMembers(context, klass));
+    return { members, accessors };
+};
+
+type AppendInstanceMethodsOptions = {
+    context: ModuleContext;
+    methods: GirFunction[];
+    methodByName: Map<string, GirFunction>;
+    inherited: InheritedMethods;
+    members: string[];
+    claimedNames: Set<string>;
+    className: string;
+};
+
+const appendInstanceMethods = (options: AppendInstanceMethodsOptions): void => {
+    const { context, methods, methodByName, inherited, members, claimedNames, className } = options;
+    for (const callable of methods) {
+        const rename = conflictRename(context, callable, inherited, className);
+        const block = renderClassInstanceMember(context, callable, methodByName, rename);
+        if (block === undefined) continue;
+        members.push(block);
+        claimedNames.add(rename ?? methodExportName(callable));
+    }
+};
+
+const appendInstallMixins = (context: ModuleContext, className: string, implemented: ImplementedRef[]): void => {
+    if (implemented.length === 0) return;
+    context.addRuntimeImport("installMixins");
+    const makers = implemented.map((ref) => ref.makerRef).join(", ");
+    context.module.appendRegistration(`installMixins(${className}, [${makers}]);`);
+};
+
+const appendClassRegistrations = (context: ModuleContext, klass: GirClass, className: string): void => {
+    const gtypeExpr = gtypeExprFor(context, klass);
+    appendWrapperClassRegistration(context, {
+        className,
+        gtypeExpr,
+        vfuncs: renderVfuncMetadata(context, klass),
+    });
+};
+
+const inheritedInterfaceKeys = (context: ModuleContext, klass: GirClass): Set<string> => {
+    const keys = new Set<string>();
+    if (klass.parent === undefined) return keys;
+    const parent = context.library.resolveType(context.namespace.name, klass.parent);
+    if (parent === undefined || parent.kind !== "class") return keys;
+    for (const ancestor of ancestorChain(context.library, parent.value, parent.namespace.name)) {
+        for (const name of ancestor.klass.implements) {
+            const resolved = context.library.resolveType(ancestor.namespaceName, name);
+            if (resolved?.kind === "interface") keys.add(`${resolved.namespace.name}.${resolved.value.name}`);
+        }
+    }
+    return keys;
+};
+
+const interfaceMergeRef = (context: ModuleContext, klass: GirClass, ref: ImplementedRef): string => {
+    const omissions = collectInterfaceMergeOmissions(context, klass, {
+        klass: ref.interfaceKlass,
+        namespaceName: ref.interfaceNamespace,
+    });
+    if (omissions.length === 0) return ref.typeRef;
+    const keys = omissions.map((name) => JSON.stringify(name)).join(" | ");
+    return `Omit<${ref.typeRef}, ${keys}>`;
+};
+
+const resolveImplementedRefs = (context: ModuleContext, klass: GirClass): ImplementedRef[] => {
+    const inherited = inheritedInterfaceKeys(context, klass);
+    const refs: ImplementedRef[] = [];
+    for (const name of klass.implements) {
+        const resolved = context.library.resolveType(context.namespace.name, name);
+        if (resolved === undefined || resolved.kind !== "interface") continue;
+        if (inherited.has(`${resolved.namespace.name}.${resolved.value.name}`)) continue;
+        const pascal = toPascalCase(resolved.value.name);
+        refs.push({
+            typeRef: context.qualify(resolved.namespace.name, pascal),
+            makerRef: context.qualify(resolved.namespace.name, `make${pascal}`),
+            interfaceKlass: resolved.value,
+            interfaceNamespace: resolved.namespace.name,
+        });
+    }
+    return refs;
+};
+
+const renderExtendsClause = (
+    context: ModuleContext,
+    parentExpression: string | undefined,
+    callables: Callables,
+): string => {
+    if (parentExpression === undefined) return "";
+    const constructorNames = classConstructorMemberNames(context, callables);
+    if (constructorNames.length === 0) return ` extends ${parentExpression}`;
+    context.addRuntimeTypeImport("StaticBase");
+    const omitted = constructorNames.map((name) => JSON.stringify(name)).join(" | ");
+    return ` extends (${parentExpression} as StaticBase<typeof ${parentExpression}, ${omitted}>)`;
+};
+
+const resolveParent = (context: ModuleContext, klass: GirClass): string | undefined => {
+    if (klass.parent === undefined) return undefined;
+    const [namespace, typeName] = splitOptionalNamespace(klass.parent);
+    return context.qualify(namespace ?? context.namespace.name, toPascalCase(typeName));
+};

package/src/store/gi/companion.ts

@@ -0,0 +1,13 @@
+import { toPascalCase } from "@gtkx/utils";
+import type { GirClass } from "../../gir/class.js";
+import { splitOptionalNamespace } from "../../gir/type-ref.js";
+import type { ModuleContext } from "../../writer/context.js";
+
+export const parentCompanionRef = (context: ModuleContext, klass: GirClass, suffix: string): string | undefined => {
+    if (klass.parent === undefined) return undefined;
+    const [parentNamespace, typeName] = splitOptionalNamespace(klass.parent);
+    const namespaceName = parentNamespace ?? context.namespace.name;
+    const name = `${toPascalCase(typeName)}${suffix}`;
+    if (namespaceName === context.namespace.name) return name;
+    return `${context.addCrossNamespaceImport(namespaceName)}.${name}`;
+};

package/src/store/gi/constant.ts

@@ -0,0 +1,24 @@
+import { sourceStringLiteral } from "@gtkx/utils";
+import type { GirConstant } from "../../gir/namespace.js";
+import type { TypeId } from "../../gir/type-id.js";
+import type { ModuleContext } from "../../writer/context.js";
+import { renderJsDoc } from "../../writer/doc.js";
+
+export const generateConstant = (context: ModuleContext, constant: GirConstant): void => {
+    context.module.appendDeclaration(
+        `${renderJsDoc(constant.doc)}export const ${constant.name} = ${constantLiteral(context, constant)};`,
+    );
+};
+
+export const constantLiteral = (context: ModuleContext, constant: GirConstant): string => {
+    if (isStringTyped(context, constant.type)) return sourceStringLiteral(constant.value);
+    return isNumericLiteral(constant.value) ? constant.value : sourceStringLiteral(constant.value);
+};
+
+const isStringTyped = (context: ModuleContext, type: TypeId | undefined): boolean => {
+    if (type === undefined) return false;
+    const resolved = context.library.typeOf(type);
+    return resolved?.kind === "primitive" && resolved.category === "string";
+};
+
+const isNumericLiteral = (value: string): boolean => /^-?(?:\d+|\d*\.\d+)$/.test(value);