@gtkx/codegen 1.0.0 → 1.1.0

package/src/runner.ts

@@ -2,12 +2,13 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import type { ModuleExport } from "./react/element-config.js";
 import type { OmittedProps } from "./store/jsx/omitted-props.js";
-import type { StoreOptions } from "./store/store-fs.js";
 import { checkModules } from "./compile.js";
 import { isGiStoreFresh } from "./fingerprint.js";
 import { runGiCodegen } from "./gi.js";
 import { Library } from "./gir/library.js";
 import { generateGlModules, type GlGenerationReport } from "./khronos/pipeline.js";
+import { sweepStagingDirs } from "./staging.js";
+import { ensureStoreLink, type StoreOptions } from "./store/store-fs.js";
 
 type GlCodegenOptions = {
     registryPath: string;
@@ -64,6 +65,10 @@ type StoreResult = {
  * store or the React element config changed, unless `options.isForced` is set. Pass the spread of
  * `resolveStore(projectRoot)` for everything but `libraries` and `girPath`.
  *
+ * Every store already on disk is linked at its `linkDir` before anything is generated, so a link an install
+ * pruned out of `node_modules` is restored without regenerating the store, and the gi store is reachable
+ * under its own specifier while the jsx store is type checked.
+ *
  * @param options What to generate and where to write it.
  * @returns A summary of what was regenerated and how long the run took.
  * @throws If `girPath` is empty, which would otherwise generate nothing and report success.
@@ -167,6 +172,17 @@ const emitStoresWithConfig = async (config: {
     return emitJsxStore({ options, jsx, gi, loadLibrary, isGiRegenerated, namespaces });
 };
 
+const prepareStores = (stores: (StoreOptions | undefined)[]): void => {
+    for (const store of stores) {
+        if (store === undefined) {
+            continue;
+        }
+
+        sweepStagingDirs(store.storeDir);
+        ensureStoreLink(store);
+    }
+};
+
 const emitStores = async (options: CodegenRunnerOptions): Promise<StoreResult> => {
     const { gi, jsx, libraries, girPath } = options;
 
@@ -174,6 +190,8 @@ const emitStores = async (options: CodegenRunnerOptions): Promise<StoreResult> =
         throw new Error("codegen needs at least one GIR search path; pass the result of resolveGirPath");
     }
 
+    prepareStores([gi, jsx]);
+
     return emitStoresWithConfig({ options, gi, jsx, libraries, girPath });
 };
 

package/src/staging.ts

@@ -0,0 +1,69 @@
+import { mkdirSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+
+const STAGING_SUFFIX = ".tmp-";
+const OWNER_PATTERN = /^(?<pid>\d+)-/;
+
+const errorCode = (error: unknown): string | undefined =>
+    error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : undefined;
+
+const isOwnerRunning = (pid: number): boolean => {
+    if (!Number.isSafeInteger(pid) || pid <= 0) {
+        return false;
+    }
+
+    try {
+        process.kill(pid, 0);
+
+        return true;
+    } catch (error) {
+        return errorCode(error) === "EPERM";
+    }
+};
+
+const isStranded = (entry: string, prefix: string): boolean => {
+    if (!entry.startsWith(prefix)) {
+        return false;
+    }
+
+    const owner = OWNER_PATTERN.exec(entry.slice(prefix.length))?.groups?.pid;
+
+    return owner === undefined || !isOwnerRunning(Number(owner));
+};
+
+const readEntries = (parentDir: string): string[] => {
+    try {
+        return readdirSync(parentDir);
+    } catch {
+        return [];
+    }
+};
+
+const removeStrandedDir = (path: string): void => {
+    try {
+        rmSync(path, { recursive: true, force: true });
+    } catch {
+        return;
+    }
+};
+
+const sweepStrandedDirs = (parentDir: string, prefix: string): void => {
+    for (const entry of readEntries(parentDir)) {
+        if (isStranded(entry, prefix)) {
+            removeStrandedDir(join(parentDir, entry));
+        }
+    }
+};
+
+const sweepStagingDirs = (target: string): void => {
+    sweepStrandedDirs(dirname(target), `${basename(target)}${STAGING_SUFFIX}`);
+};
+
+const createStagingDir = (target: string): string => {
+    mkdirSync(dirname(target), { recursive: true });
+    sweepStagingDirs(target);
+
+    return mkdtempSync(`${target}${STAGING_SUFFIX}${String(process.pid)}-`);
+};
+
+export { createStagingDir, sweepStagingDirs, sweepStrandedDirs };

package/src/store/compile-store.ts

@@ -1,6 +1,6 @@
 import { rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { compileProject, type SourceModule } from "../compile.js";
+import { compileProject, type ProjectFile, type SourceModule } from "../compile.js";
 
 type CompileStoreParams = {
     storeDir: string;
@@ -29,16 +29,18 @@ const writeEnvReference = (storeDir: string): (() => void) => {
 };
 
 const compileStore = (params: CompileStoreParams): void => {
-    const fileNames = params.files.map((file) => file.fileName);
-
     const removeEnvReference = params.requiresEnvReference === true
         ? writeEnvReference(params.storeDir)
         : (): void => undefined;
 
+    const files: ProjectFile[] = params.requiresEnvReference === true
+        ? [{ fileName: ENV_REFERENCE_FILE }, ...params.files]
+        : params.files;
+
     try {
         compileProject({
             projectDir: params.storeDir,
-            fileNames: params.requiresEnvReference === true ? [ENV_REFERENCE_FILE, ...fileNames] : fileNames,
+            files,
             compilerOptions: EMIT_OPTIONS,
             label: `the generated ${params.packageName} store`,
         });

package/src/store/gi/callables.ts

@@ -1,4 +1,4 @@
-import { camelCase, toCamelIdentifier, uniqBy } from "@gtkx/utils";
+import { toCamelIdentifier, uniqBy } from "@gtkx/utils";
 import type { GirFunction } from "../../gir/function.js";
 import type { ModuleContext } from "../../writer/context.js";
 import type { JsDocSpec } from "../../writer/doc.js";
@@ -10,6 +10,7 @@ import { renderFnExpression } from "./function.js";
 import { gtypeMemberDeclaration } from "./gtype-binding.js";
 import {
     finishCallExpression,
+    memberName,
     methodExportName,
     renderMethodBody,
     renderMethodReturnType,
@@ -49,6 +50,11 @@ type ResolvedInstanceMember = {
     finishFn: GirFunction | undefined;
 };
 
+type StaticMember = {
+    callable: GirFunction;
+    name: string;
+};
+
 type InstanceMemberRenderer = (
     context: ModuleContext,
     callable: GirFunction,
@@ -99,15 +105,14 @@ const dedupeCallables = (callables: GirFunction[]): GirFunction[] =>
         (callable) => callable.cIdentifier,
     );
 
+const getEmittableCIdentifier = (context: ModuleContext, callable: GirFunction): string | undefined =>
+    isEmittableCallable(context, callable) ? callable.cIdentifier : undefined;
+
 const renderBinding = (
     context: ModuleContext,
     callable: GirFunction,
 ): { text: string; cIdentifier: string } | undefined => {
-    if (!isEmittableCallable(context, callable)) {
-        return undefined;
-    }
-
-    const cIdentifier = callable.cIdentifier;
+    const cIdentifier = getEmittableCIdentifier(context, callable);
 
     if (cIdentifier === undefined) {
         return undefined;
@@ -139,11 +144,7 @@ const resolveCallableMember = (
     callable: GirFunction,
     resolveName: (callable: GirFunction) => string | undefined,
 ): { cIdentifier: string; name: string } | undefined => {
-    if (!isEmittableCallable(context, callable)) {
-        return undefined;
-    }
-
-    const cIdentifier = callable.cIdentifier;
+    const cIdentifier = getEmittableCIdentifier(context, callable);
 
     if (cIdentifier === undefined) {
         return undefined;
@@ -151,7 +152,7 @@ const resolveCallableMember = (
 
     const name = resolveName(callable);
 
-    if (name === undefined || name === "constructor") {
+    if (name === undefined || !isEmittableMemberName(name)) {
         return undefined;
     }
 
@@ -218,7 +219,7 @@ const renderStaticEntry = (
     if (finishFn !== undefined) {
         const name = options.resolveName(callable);
 
-        if (name === undefined || name === "constructor") {
+        if (name === undefined || !isEmittableMemberName(name)) {
             return undefined;
         }
 
@@ -247,6 +248,8 @@ const renderInstanceMethod = (
         canUseRuntimeOverride: true,
     });
 
+const isEmittableMemberName = (name: string): boolean => name !== "constructor" && name.length > 0;
+
 const resolveInstanceMember = (
     context: ModuleContext,
     callable: GirFunction,
@@ -259,7 +262,7 @@ const resolveInstanceMember = (
 
     const name = nameOverride ?? methodExportName(callable);
 
-    if (name === "constructor") {
+    if (!isEmittableMemberName(name)) {
         return undefined;
     }
 
@@ -373,13 +376,9 @@ const isEmittableCallable = (context: ModuleContext, callable: GirFunction): boo
     !hasUnmarshalableParam(context, callable);
 
 const constructorMemberName = (girName: string): string | undefined => {
-    const camel = camelCase(girName);
+    const camel = memberName(girName);
 
-    if (camel === "constructor") {
-        return undefined;
-    }
-
-    return camel;
+    return isEmittableMemberName(camel) ? camel : undefined;
 };
 
 const renderStaticSignature = (
@@ -409,24 +408,32 @@ const renderStaticSignature = (
     };
 };
 
-const classConstructorMemberNames = (context: ModuleContext, callables: Callables): string[] => {
-    const names: string[] = [];
-
-    for (const callable of callables.constructors) {
-        if (!isEmittableCallable(context, callable)) {
-            continue;
-        }
+const collectStaticMembers = (
+    context: ModuleContext,
+    group: GirFunction[],
+    resolveName: (girName: string) => string | undefined,
+): StaticMember[] => {
+    const members: StaticMember[] = [];
 
-        const member = constructorMemberName(callable.name);
+    for (const callable of group) {
+        const name = isEmittableCallable(context, callable) ? resolveName(callable.name) : undefined;
 
-        if (member !== undefined) {
-            names.push(member);
+        if (name !== undefined) {
+            members.push({ callable, name });
         }
     }
 
-    return names;
+    return members;
 };
 
+const staticMembers = (context: ModuleContext, callables: Callables): StaticMember[] => [
+    ...collectStaticMembers(context, callables.constructors, constructorMemberName),
+    ...collectStaticMembers(context, callables.functions, memberName),
+];
+
+const constructorMemberNames = (context: ModuleContext, constructors: GirFunction[]): string[] =>
+    collectStaticMembers(context, constructors, constructorMemberName).map((member) => member.name);
+
 const collectStaticEntries = (
     context: ModuleContext,
     group: GirFunction[],
@@ -456,7 +463,7 @@ const renderStaticHead = (context: ModuleContext, callables: Callables, ownerCla
             returnTypeOverride: ownerClassName,
         }),
         ...collectStaticEntries(context, callables.functions, siblings, {
-            resolveName: (member) => camelCase(member.name),
+            resolveName: (member) => memberName(member.name),
             ownerName: ownerClassName,
         }),
     ];
@@ -509,9 +516,10 @@ export {
     indexMethodsByName,
     isEmittableCallable,
     renderStaticSignature,
-    classConstructorMemberNames,
+    constructorMemberNames,
     renderStaticHead,
     renderPlainTypeMembers,
+    staticMembers,
     type Callables,
     type InstanceMemberRenderer,
     type InstanceScope,

package/src/store/gi/callback.ts

@@ -1,25 +1,25 @@
+import { sanitizeTypeIdentifier } from "@gtkx/utils";
 import type { ModuleContext } from "../../writer/context.js";
 import { callbackAsFunction, type GirCallback } from "../../gir/callback.js";
+import { isEmittableEntity } from "../../gir/emittable.js";
 import { callableDoc } from "./callable-doc.js";
 import { renderMethodReturnType, renderMethodSignature } from "./method.js";
 
 const generateCallback = (context: ModuleContext, callback: GirCallback): void => {
-    if (!callback.introspectable) {
-        return;
-    }
-
-    if (callback.name.length === 0) {
+    if (!isEmittableEntity(callback)) {
         return;
     }
 
     const fn = callbackAsFunction(callback);
     const signature = renderMethodSignature(context, fn);
     const returnType = renderMethodReturnType(context, fn);
+    const name = sanitizeTypeIdentifier(callback.name);
 
-    context.module.appendDeclaration(
-        `${callableDoc(context, fn)}export type ${callback.name} = (${signature}) => ${returnType};`,
-        context.declaredType(callback.name),
-    );
+    context.declare({
+        name,
+        code: `${callableDoc(context, fn)}export type ${name} = (${signature}) => ${returnType};`,
+        owner: callback.name,
+    });
 };
 
 export { generateCallback };

package/src/store/gi/class.ts

@@ -1,20 +1,28 @@
-import { pascalCase, toCamelIdentifier } from "@gtkx/utils";
+import { sanitizeTypeIdentifier, toCamelIdentifier } from "@gtkx/utils";
 import type { GirClass } from "../../gir/class.js";
 import type { GirFunction } from "../../gir/function.js";
 import type { ModuleContext } from "../../writer/context.js";
 import {
+    ancestorClassMethodNames,
     collectInheritedMethods,
     collectInheritedPropertyTypes,
     collectInterfaceMergeOmissions,
     conflictRename,
     type InheritedMethods,
 } from "../../analysis/inheritance.js";
-import { ancestorChain, type ResolvedAncestor } from "../../gir/ancestry.js";
-import { splitOptionalNamespace } from "../../gir/type-ref.js";
+import {
+    type ClaimedMembers,
+    claimInterfaceMembers,
+    inheritedMembers,
+    interfaceConflicts,
+    omittedTypeRef,
+} from "../../analysis/interface-conflicts.js";
+import { ancestorChain, getParentRef, type ResolvedAncestor } from "../../gir/ancestry.js";
+import { isEmittableEntity } from "../../gir/emittable.js";
 import { indentMembers } from "../../writer/emit.js";
 import {
     type Callables,
-    classConstructorMemberNames,
+    constructorMemberNames,
     dedupeCallables,
     generateBindings,
     type InstanceScope,
@@ -37,6 +45,7 @@ type ImplementedRef = {
     makerRef: string;
     interfaceKlass: GirClass;
     interfaceNamespace: string;
+    conflicts: string[];
 };
 
 type MemberDeclarationsOptions = {
@@ -49,6 +58,14 @@ type MemberDeclarationsOptions = {
 
 type ClassMembers = { members: string[]; accessors: ResolvedAccessor[] };
 
+type ImplementedRefOptions = {
+    context: ModuleContext;
+    klass: GirClass;
+    name: string;
+    inherited: Set<string>;
+    claimed: ClaimedMembers;
+};
+
 type AppendInstanceMethodsOptions = {
     context: ModuleContext;
     methods: GirFunction[];
@@ -60,15 +77,11 @@ type AppendInstanceMethodsOptions = {
 };
 
 const generateClass = (context: ModuleContext, klass: GirClass): void => {
-    if (!klass.introspectable) {
-        return;
-    }
-
-    if (klass.name.length === 0) {
+    if (!isEmittableEntity(klass)) {
         return;
     }
 
-    const className = pascalCase(klass.name);
+    const className = sanitizeTypeIdentifier(klass.name);
 
     const callables: Callables = {
         constructors: dedupeCallables(klass.constructors),
@@ -80,18 +93,24 @@ const generateClass = (context: ModuleContext, klass: GirClass): void => {
     const parentExpression = resolveParent(context, klass);
     const extendsClause = renderExtendsClause(context, parentExpression, callables);
     const implemented = resolveImplementedRefs(context, klass);
-    const typeRefs = implemented.map((ref) => ref.typeRef);
+    const typeRefs = implemented.map((ref) => omittedTypeRef(ref.typeRef, ref.conflicts));
     const implementsClause = typeRefs.length === 0 ? "" : ` implements ${typeRefs.join(", ")}`;
     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,
+    });
 
-    context.module.appendDeclaration(
-        `${doc}export class ${className}${extendsClause}${implementsClause} {\n${body}\n}`,
-        context.declaredType(className),
-    );
+    context.declare({
+        name: `${className}ConstructorProps`,
+        code: renderConstructorPropsInterface(context, klass, className),
+    });
 
-    context.module.appendDeclaration(renderConstructorPropsInterface(context, klass, className));
     appendMemberDeclarations({ context, klass, className, accessors, implemented });
     appendInstallMixins(context, className, implemented);
     appendClassRegistrations(context, klass, className);
@@ -101,11 +120,11 @@ const appendMemberDeclarations = (options: MemberDeclarationsOptions): void => {
     const { context, klass, className, accessors, implemented } = options;
 
     for (const declaration of renderPropertyDeclarations(context, klass, className, accessors)) {
-        context.module.appendDeclaration(declaration);
+        context.declare(declaration);
     }
 
     for (const declaration of renderSignalDeclarations(context, klass, className, false)) {
-        context.module.appendDeclaration(declaration);
+        context.declare(declaration);
     }
 
     appendInterfaceMerge(context, klass, className, implemented);
@@ -122,7 +141,11 @@ const appendInterfaceMerge = (
     }
 
     const mergeRefs = implemented.map((ref) => interfaceMergeRef(context, klass, ref));
-    context.module.appendDeclaration(`export interface ${className} extends ${mergeRefs.join(", ")} {}`);
+
+    context.declare({
+        name: className,
+        code: `export interface ${className} extends ${mergeRefs.join(", ")} {}`,
+    });
 };
 
 const renderClassMembers = (
@@ -131,7 +154,7 @@ const renderClassMembers = (
     callables: Callables,
     hasParent: boolean,
 ): ClassMembers => {
-    const className = pascalCase(klass.name);
+    const className = sanitizeTypeIdentifier(klass.name);
     const members: string[] = [gtypeMemberDeclaration(context)];
     const constructorBlock = renderClassConstructor(context, klass, className, hasParent);
 
@@ -156,17 +179,19 @@ const renderClassMembers = (
 
     members.push(...renderVfuncMembers({ context, klass, mode: "implementation" }));
     const inheritedPropertyTypes = collectInheritedPropertyTypes(context, klass);
+    const inheritedNames = ancestorClassMethodNames(context, klass);
     const accessors: ResolvedAccessor[] = [];
 
     for (const property of klass.properties) {
-        const inheritedType = inheritedPropertyTypes.get(toCamelIdentifier(property.name));
+        const inheritedTypes = inheritedPropertyTypes.get(toCamelIdentifier(property.name));
 
         const accessor = resolveAccessor({
             context,
             property,
             claimedNames,
             methodByName: scope.methodByName,
-            inheritedType,
+            inheritedTypes,
+            inheritedNames,
         });
 
         if (accessor === undefined) {
@@ -204,8 +229,13 @@ const appendInstallMixins = (context: ModuleContext, className: string, implemen
     }
 
     context.addRuntimeImport("installMixins");
-    const makers = implemented.map((ref) => ref.makerRef).join(", ");
-    context.module.appendRegistration(`installMixins(${className}, [${makers}]);`);
+    const makerRefs = implemented.map((ref) => ref.makerRef);
+    const localRefs = makerRefs.filter((ref) => !ref.includes("."));
+
+    context.module.appendRegistration(`installMixins(${className}, [${makerRefs.join(", ")}]);`, [
+        className,
+        ...localRefs,
+    ]);
 };
 
 const appendClassRegistrations = (context: ModuleContext, klass: GirClass, className: string): void => {
@@ -254,23 +284,14 @@ const interfaceMergeRef = (context: ModuleContext, klass: GirClass, ref: Impleme
         namespaceName: ref.interfaceNamespace,
     });
 
-    if (omissions.length === 0) {
-        return ref.typeRef;
-    }
-
-    const keys = omissions.map((name) => JSON.stringify(name)).join(" | ");
-
-    return `Omit<${ref.typeRef}, ${keys}>`;
+    return omittedTypeRef(ref.typeRef, [...omissions, ...ref.conflicts]);
 };
 
-const implementedRefFor = (
-    context: ModuleContext,
-    name: string,
-    inherited: Set<string>,
-): ImplementedRef | undefined => {
+const implementedRefFor = (options: ImplementedRefOptions): ImplementedRef | undefined => {
+    const { context, klass, name, inherited } = options;
     const resolved = context.library.resolveType(context.namespace.name, name);
 
-    if (resolved?.kind !== "interface") {
+    if (resolved?.kind !== "interface" || !isEmittableEntity(resolved.value)) {
         return undefined;
     }
 
@@ -278,22 +299,34 @@ const implementedRefFor = (
         return undefined;
     }
 
-    const pascal = pascalCase(resolved.value.name);
+    const typeName = sanitizeTypeIdentifier(resolved.value.name);
+
+    const conflictOptions = {
+        context,
+        klass,
+        iface: resolved.value,
+        ifaceNamespace: resolved.namespace.name,
+    };
+
+    const conflicts = interfaceConflicts(conflictOptions, options.claimed);
+    claimInterfaceMembers(conflictOptions, options.claimed);
 
     return {
-        typeRef: context.qualify(resolved.namespace.name, pascal),
-        makerRef: context.qualify(resolved.namespace.name, `make${pascal}`),
+        typeRef: context.qualify(resolved.namespace.name, typeName),
+        makerRef: context.qualify(resolved.namespace.name, `make${typeName}`),
         interfaceKlass: resolved.value,
         interfaceNamespace: resolved.namespace.name,
+        conflicts,
     };
 };
 
 const resolveImplementedRefs = (context: ModuleContext, klass: GirClass): ImplementedRef[] => {
     const inherited = inheritedInterfaceKeys(context, klass);
+    const claimed = inheritedMembers(context, klass);
     const refs: ImplementedRef[] = [];
 
     for (const name of klass.implements) {
-        const ref = implementedRefFor(context, name, inherited);
+        const ref = implementedRefFor({ context, klass, name, inherited, claimed });
 
         if (ref !== undefined) {
             refs.push(ref);
@@ -312,7 +345,7 @@ const renderExtendsClause = (
         return "";
     }
 
-    const constructorNames = classConstructorMemberNames(context, callables);
+    const constructorNames = constructorMemberNames(context, callables.constructors);
 
     if (constructorNames.length === 0) {
         return ` extends ${parentExpression}`;
@@ -325,13 +358,11 @@ const renderExtendsClause = (
 };
 
 const resolveParent = (context: ModuleContext, klass: GirClass): string | undefined => {
-    if (klass.parent === undefined) {
-        return undefined;
-    }
-
-    const [namespace, typeName] = splitOptionalNamespace(klass.parent);
+    const parent = getParentRef(klass);
 
-    return context.qualify(namespace ?? context.namespace.name, pascalCase(typeName));
+    return parent === undefined
+        ? undefined
+        : context.qualify(parent.namespaceName ?? context.namespace.name, sanitizeTypeIdentifier(parent.typeName));
 };
 
 export { generateClass };

package/src/store/gi/companion.ts

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

package/src/store/gi/constant.ts

@@ -1,16 +1,26 @@
-import { sourceStringLiteral } from "@gtkx/utils";
+import { sanitizeIdentifier, sourceStringLiteral } from "@gtkx/utils";
 import type { GirConstant } from "../../gir/namespace.js";
 import type { PrimitiveCategory } from "../../gir/primitives.js";
 import type { TypeId } from "../../gir/type-id.js";
 import type { ModuleContext } from "../../writer/context.js";
+import { isEmittableEntity } from "../../gir/emittable.js";
 import { getDoc } from "./doc-spec.js";
 
 const TRUE_VALUES: Set<string> = new Set(["true", "1"]);
 const BIGINT_CATEGORIES: Set<PrimitiveCategory> = new Set(["bigint64", "biguint64", "gtype"]);
 
 const generateConstant = (context: ModuleContext, constant: GirConstant): void => {
+    if (!isEmittableEntity(constant)) {
+        return;
+    }
+
     const doc = getDoc(constant);
-    context.module.appendDeclaration(`${doc}export const ${constant.name} = ${constantLiteral(context, constant)};`);
+    const name = sanitizeIdentifier(constant.name);
+
+    context.declare({
+        name,
+        code: `${doc}export const ${name} = ${constantLiteral(context, constant)};`,
+    });
 };
 
 const constantLiteral = (context: ModuleContext, constant: GirConstant): string => {