@gtkx/ffi 0.5.2 → 0.6.1

package/dist/codegen/ffi-generator.js

@@ -51,46 +51,15 @@ const RESERVED_WORDS = new Set([
     "eval",
     "arguments",
 ]);
+const CLASS_RENAMES = new Map([["Error", "GError"]]);
 const METHOD_RENAMES = new Map([
-    [
-        "IconView",
-        new Map([
-            ["setCursor", "setCursorPath"],
-            ["getCursor", "getCursorPath"],
-        ]),
-    ],
-    [
-        "TreeView",
-        new Map([
-            ["setCursor", "setCursorPath"],
-            ["getCursor", "getCursorPath"],
-        ]),
-    ],
-    ["HSV", new Map([["getColor", "getHsvColor"]])],
-    ["Layout", new Map([["getSize", "getLayoutSize"]])],
-    ["Table", new Map([["getSize", "getTableSize"]])],
-    ["MenuItem", new Map([["activate", "activateItem"]])],
-    ["FunctionInfo", new Map([["invoke", "invokeFunction"]])],
-    ["VFuncInfo", new Map([["invoke", "invokeVFunc"]])],
-    ["SignalGroup", new Map([["connect", "connectSignal"]])],
-    [
-        "MenuButton",
-        new Map([
-            ["getDirection", "getArrowDirection"],
-            ["setDirection", "setArrowDirection"],
-        ]),
-    ],
-    ["PrintUnixDialog", new Map([["getSettings", "getPrintSettings"]])],
-    ["Gdk.AppLaunchContext", new Map([["getDisplay", "getGdkDisplay"]])],
     ["SocketClient", new Map([["connect", "connectTo"]])],
     ["SocketConnection", new Map([["connect", "connectTo"]])],
     ["Socket", new Map([["connect", "connectTo"]])],
     ["Cancellable", new Map([["connect", "connectCallback"]])],
-    ["GutterRenderer", new Map([["activate", "activateRenderer"]])],
-    ["GutterRendererText", new Map([["measure", "measureText"]])],
+    ["SignalGroup", new Map([["connect", "connectSignal"]])],
 ]);
-const CLASS_RENAMES = new Map([["Error", "GError"]]);
-const getRenamedMethod = (namespace, className, methodName) => {
+const getStaticRenamedMethod = (namespace, className, methodName) => {
     const nsRenames = METHOD_RENAMES.get(`${namespace}.${className}`);
     if (nsRenames?.has(methodName)) {
         return nsRenames.get(methodName);
@@ -160,24 +129,24 @@ const toValidIdentifier = (str) => {
         result = `_${result}`;
     return result;
 };
-const normalizeClassName = (name) => {
+const normalizeClassName = (name, namespace) => {
     const pascalName = toPascalCase(name);
     if (CLASS_RENAMES.has(pascalName)) {
         return CLASS_RENAMES.get(pascalName);
     }
-    if (pascalName === "Object") {
-        return "GObject";
+    if (pascalName === "Object" && namespace) {
+        return namespace === "GObject" ? "GObject" : `${namespace}Object`;
     }
     return pascalName;
 };
-const parseParentReference = (parent, classMap) => {
+const parseParentReference = (parent, classMap, currentNamespace) => {
     if (!parent) {
         return { hasParent: false, isCrossNamespace: false, className: "", extendsClause: "" };
     }
     if (parent.includes(".")) {
         const [ns, className] = parent.split(".", 2);
         if (ns && className) {
-            const normalizedClass = normalizeClassName(className);
+            const normalizedClass = normalizeClassName(className, ns);
             const nsLower = ns.toLowerCase();
             return {
                 hasParent: true,
@@ -190,7 +159,7 @@ const parseParentReference = (parent, classMap) => {
         }
     }
     if (classMap.has(parent)) {
-        const normalizedClass = normalizeClassName(parent);
+        const normalizedClass = normalizeClassName(parent, currentNamespace);
         return {
             hasParent: true,
             isCrossNamespace: false,
@@ -228,6 +197,7 @@ export class CodeGenerator {
     typeMapper;
     usesRef = false;
     usesCall = false;
+    usesInstantiating = false;
     addGioImport = false;
     usesType = false;
     usesRead = false;
@@ -242,11 +212,12 @@ export class CodeGenerator {
     usedExternalTypes = new Map();
     usedSameNamespaceClasses = new Map();
     usedInterfaces = new Map();
-    signalClasses = new Set();
+    signalClasses = new Map();
     recordNameToFile = new Map();
     interfaceNameToFile = new Map();
     currentSharedLibrary = "";
     cyclicReturnTypes = new Set();
+    methodRenames = new Map();
     /**
      * Creates a new code generator with the given options.
      * @param options - Generator configuration
@@ -305,7 +276,7 @@ export class CodeGenerator {
     registerRecords(namespace) {
         for (const record of namespace.records) {
             if (this.shouldGenerateRecord(record)) {
-                const normalizedName = normalizeClassName(record.name);
+                const normalizedName = normalizeClassName(record.name, this.options.namespace);
                 this.typeMapper.registerRecord(record.name, normalizedName, record.glibTypeName);
                 this.recordNameToFile.set(normalizedName, record.name);
             }
@@ -350,6 +321,7 @@ export class CodeGenerator {
     resetState() {
         this.usesRef = false;
         this.usesCall = false;
+        this.usesInstantiating = false;
         this.addGioImport = false;
         this.usesType = false;
         this.usesRead = false;
@@ -388,11 +360,38 @@ export class CodeGenerator {
             }
         }
         const parentMethodNames = this.collectParentMethodNames(cls, classMap, interfaceMap);
-        const filteredClassMethods = cls.methods.filter((m) => !parentMethodNames.has(m.name));
         const classMethodNames = new Set(cls.methods.map((m) => m.name));
-        const interfaceMethods = cls.implements
-            .flatMap((ifaceName) => interfaceMap.get(ifaceName)?.methods ?? [])
-            .filter((m) => !classMethodNames.has(m.name) && !parentMethodNames.has(m.name));
+        const className = normalizeClassName(cls.name, this.options.namespace);
+        const filteredClassMethods = cls.methods.filter((m) => {
+            if (!parentMethodNames.has(m.name))
+                return true;
+            const camelMethodName = toCamelCase(m.name);
+            const renamedMethod = `${camelMethodName}${className}`;
+            this.methodRenames.set(m.cIdentifier, renamedMethod);
+            return true;
+        });
+        const seenInterfaceMethodNames = new Set();
+        const interfaceMethods = [];
+        for (const ifaceName of cls.implements) {
+            const iface = interfaceMap.get(ifaceName);
+            if (!iface)
+                continue;
+            for (const method of iface.methods) {
+                if (classMethodNames.has(method.name) || parentMethodNames.has(method.name))
+                    continue;
+                if (seenInterfaceMethodNames.has(method.name)) {
+                    const camelMethodName = toCamelCase(method.name);
+                    const ifaceShortName = toPascalCase(iface.name);
+                    const renamedMethod = `${camelMethodName}${ifaceShortName}`;
+                    this.methodRenames.set(method.cIdentifier, renamedMethod);
+                    interfaceMethods.push(method);
+                }
+                else {
+                    seenInterfaceMethodNames.add(method.name);
+                    interfaceMethods.push(method);
+                }
+            }
+        }
         const syncMethods = filteredClassMethods.filter((m) => !asyncMethods.has(m.name) && !finishMethods.has(m.name));
         const syncInterfaceMethods = interfaceMethods.filter((m) => !asyncMethods.has(m.name) && !finishMethods.has(m.name));
         this.usesRef =
@@ -414,8 +413,7 @@ export class CodeGenerator {
                 hasGObjectNewConstructor ||
                 hasStaticFactoryMethods ||
                 hasSignalConnect;
-        const className = normalizeClassName(cls.name);
-        const parentInfo = parseParentReference(cls.parent, classMap);
+        const parentInfo = parseParentReference(cls.parent, classMap, this.options.namespace);
         const implementsClause = "";
         const sections = [];
         if (parentInfo.importStatement && !parentInfo.isCrossNamespace) {
@@ -495,7 +493,7 @@ export class CodeGenerator {
             const returnTypeName = method.returnType.name;
             if (returnTypeName && classMap.has(returnTypeName)) {
                 if (this.wouldCreateCycle(cls.name, returnTypeName, classMap)) {
-                    cyclic.add(normalizeClassName(returnTypeName));
+                    cyclic.add(normalizeClassName(returnTypeName, this.options.namespace));
                 }
             }
         }
@@ -503,7 +501,7 @@ export class CodeGenerator {
             const returnTypeName = func.returnType.name;
             if (returnTypeName && classMap.has(returnTypeName)) {
                 if (this.wouldCreateCycle(cls.name, returnTypeName, classMap)) {
-                    cyclic.add(normalizeClassName(returnTypeName));
+                    cyclic.add(normalizeClassName(returnTypeName, this.options.namespace));
                 }
             }
         }
@@ -561,20 +559,49 @@ export class CodeGenerator {
     }
     collectParentMethodNames(cls, classMap, interfaceMap) {
         const names = new Set();
-        let current = cls.parent ? classMap.get(cls.parent) : undefined;
-        while (current) {
+        const visited = new Set();
+        let parentRef = cls.parent;
+        let currentClassMap = classMap;
+        let currentInterfaceMap = interfaceMap;
+        while (parentRef && !visited.has(parentRef)) {
+            visited.add(parentRef);
+            let current;
+            if (parentRef.includes(".")) {
+                const [ns, className] = parentRef.split(".", 2);
+                const parentNs = this.options.allNamespaces?.get(ns ?? "");
+                if (parentNs && className) {
+                    current = parentNs.classes.find((c) => c.name === className);
+                    currentClassMap = new Map(parentNs.classes.map((c) => [c.name, c]));
+                    currentInterfaceMap = new Map(parentNs.interfaces.map((i) => [i.name, i]));
+                }
+            }
+            else {
+                current = currentClassMap.get(parentRef);
+            }
+            if (!current)
+                break;
             for (const method of current.methods) {
                 names.add(method.name);
             }
             for (const ifaceName of current.implements) {
-                const iface = interfaceMap.get(ifaceName);
+                let iface;
+                if (ifaceName.includes(".")) {
+                    const [ns, ifaceClassName] = ifaceName.split(".", 2);
+                    const ifaceNs = this.options.allNamespaces?.get(ns ?? "");
+                    if (ifaceNs && ifaceClassName) {
+                        iface = ifaceNs.interfaces.find((i) => i.name === ifaceClassName);
+                    }
+                }
+                else {
+                    iface = currentInterfaceMap.get(ifaceName);
+                }
                 if (iface) {
                     for (const method of iface.methods) {
                         names.add(method.name);
                     }
                 }
             }
-            current = current.parent ? classMap.get(current.parent) : undefined;
+            parentRef = current.parent;
         }
         return names;
     }
@@ -603,7 +630,7 @@ export class CodeGenerator {
         const mainConstructor = cls.constructors.find((c) => !c.parameters.some(isVararg));
         const sections = [];
         if (mainConstructor && hasParent) {
-            sections.push(this.generateConstructor(mainConstructor, sharedLibrary));
+            sections.push(this.generateConstructorWithFlag(mainConstructor, sharedLibrary));
             for (const ctor of cls.constructors) {
                 if (ctor !== mainConstructor) {
                     sections.push(this.generateStaticFactoryMethod(ctor, cls.name, sharedLibrary));
@@ -615,85 +642,71 @@ export class CodeGenerator {
                 sections.push(this.generateStaticFactoryMethod(ctor, cls.name, sharedLibrary));
             }
             if (hasParent && cls.glibGetType && !cls.abstract) {
-                sections.push(this.generateGObjectNewConstructor(cls.glibGetType, sharedLibrary));
+                sections.push(this.generateGObjectNewConstructorWithFlag(cls.glibGetType, sharedLibrary));
             }
             else if (hasParent) {
                 sections.push(`  constructor() {\n    super();\n  }\n`);
             }
             else {
-                sections.push(`  constructor() {}\n`);
+                sections.push(`  constructor() {\n    this.create();\n  }\n`);
+                sections.push(`  protected create() {}\n`);
             }
         }
         return sections.join("\n");
     }
-    generateGObjectNewConstructor(getTypeFunc, sharedLibrary) {
-        return `  constructor() {
-    super();
-    const gtype = call(
-      "${sharedLibrary}",
-      "${getTypeFunc}",
-      [],
-      { type: "int", size: 64, unsigned: true }
-    );
-    this.id = call(
-      "libgobject-2.0.so.0",
-      "g_object_new",
-      [
-        { type: { type: "int", size: 64, unsigned: true }, value: gtype },
-        { type: { type: "null" }, value: null },
-      ],
-      { type: "gobject", borrowed: true }
-    );
-  }
-`;
-    }
-    generateConstructor(ctor, sharedLibrary) {
+    generateConstructorWithFlag(ctor, sharedLibrary) {
+        this.usesInstantiating = true;
         const ctorDoc = formatMethodDoc(ctor.doc, ctor.parameters);
-        const filteredParams = ctor.parameters.filter((p, i) => !isVararg(p) && !this.typeMapper.isClosureTarget(i, ctor.parameters));
-        const typedParams = this.generateParameterList(ctor.parameters, true);
-        const callArgs = this.generateCallArguments(ctor.parameters);
-        const borrowed = ctor.returnType.transferOwnership !== "full";
-        if (filteredParams.length === 0) {
-            return `${ctorDoc}  constructor() {
-    super();
-    this.id = call(
-      "${sharedLibrary}",
-      "${ctor.cIdentifier}",
-      [],
-      { type: "gobject", borrowed: ${borrowed} }
-    );
-  }
-`;
-        }
-        const firstParam = filteredParams[0];
-        const firstParamName = toValidIdentifier(toCamelCase(firstParam?.name ?? ""));
-        const firstParamNullable = firstParam ? this.typeMapper.isNullable(firstParam) : false;
-        if (firstParamNullable) {
-            return `${ctorDoc}  constructor(${typedParams}) {
-    super();
-    this.id = call(
-      "${sharedLibrary}",
-      "${ctor.cIdentifier}",
-      [
-${callArgs}
-      ],
-      { type: "gobject", borrowed: ${borrowed} }
-    );
-  }
-`;
-        }
-        return `${ctorDoc}  constructor(${typedParams}) {
-    super();
-
-    if (${firstParamName} !== undefined) {
+        const params = this.generateParameterList(ctor.parameters);
+        const args = this.generateCallArguments(ctor.parameters);
+        const docComment = ctorDoc ? `${ctorDoc.trimEnd()}\n` : "";
+        return `${docComment}  constructor(${params}) {
+    if (!isInstantiating) {
+      setInstantiating(true);
+      // @ts-ignore
+      super();
+      setInstantiating(false);
       this.id = call(
         "${sharedLibrary}",
         "${ctor.cIdentifier}",
         [
-${callArgs}
+${args ? `${args},` : ""}
         ],
-        { type: "gobject", borrowed: ${borrowed} }
+        { type: "gobject", borrowed: true }
       );
+    } else {
+      // @ts-ignore
+      super();
+    }
+  }
+`;
+    }
+    generateGObjectNewConstructorWithFlag(getTypeFunc, sharedLibrary) {
+        this.usesInstantiating = true;
+        return `  constructor() {
+    if (!isInstantiating) {
+      setInstantiating(true);
+      // @ts-ignore
+      super();
+      setInstantiating(false);
+      const gtype = call(
+        "${sharedLibrary}",
+        "${getTypeFunc}",
+        [],
+        { type: "int", size: 64, unsigned: true }
+      );
+      this.id = call(
+        "libgobject-2.0.so.0",
+        "g_object_new",
+        [
+          { type: { type: "int", size: 64, unsigned: true }, value: gtype },
+          { type: { type: "null" }, value: null },
+        ],
+        { type: "gobject", borrowed: true }
+      );
+    } else {
+      // @ts-ignore
+      super();
     }
   }
 `;
@@ -856,12 +869,12 @@ ${allArgs ? `${allArgs},` : ""}
         if (hasRequiredAfterOptional) {
             return null;
         }
-        let methodName = toCamelCase(method.name);
-        if (className) {
-            const renamed = getRenamedMethod(this.options.namespace, className, methodName);
-            if (renamed)
-                methodName = renamed;
-        }
+        const dynamicRename = this.methodRenames.get(method.cIdentifier);
+        const camelName = toCamelCase(method.name);
+        const staticRename = className
+            ? getStaticRenamedMethod(this.options.namespace, className, camelName)
+            : undefined;
+        const methodName = dynamicRename ?? staticRename ?? camelName;
         const params = paramsWithoutCallback
             .map((p) => {
             const mapped = this.typeMapper.mapParameter(p);
@@ -1063,13 +1076,12 @@ ${allArgs ? `${allArgs},` : ""}
             .join(",\n");
     }
     generateMethod(method, sharedLibrary, className, isRecord = false) {
-        let methodName = toCamelCase(method.name);
-        if (className) {
-            const renamed = getRenamedMethod(this.options.namespace, className, methodName);
-            if (renamed) {
-                methodName = renamed;
-            }
-        }
+        const dynamicRename = this.methodRenames.get(method.cIdentifier);
+        const camelName = toCamelCase(method.name);
+        const staticRename = className
+            ? getStaticRenamedMethod(this.options.namespace, className, camelName)
+            : undefined;
+        const methodName = dynamicRename ?? staticRename ?? camelName;
         const params = this.generateParameterList(method.parameters);
         const returnTypeMapping = this.typeMapper.mapType(method.returnType, true);
         const isNullable = method.returnType.nullable === true;
@@ -1199,15 +1211,15 @@ ${allArgs ? `${allArgs},` : ""}
                     return undefined;
                 }
             }
-            const normalizedName = normalizeClassName(className);
+            const normalizedName = normalizeClassName(className, ns);
             if (ns === this.options.namespace) {
-                return normalizedName;
+                return { transformedName: normalizedName, originalName: className };
             }
-            return `${ns}.${normalizedName}`;
+            return { transformedName: `${ns}.${normalizedName}`, originalName: className };
         }
-        const normalizedName = normalizeClassName(typeName);
+        const normalizedName = normalizeClassName(typeName, this.options.namespace);
         if (classMap.has(typeName) || classMap.has(normalizedName)) {
-            return normalizedName;
+            return { transformedName: normalizedName, originalName: typeName };
         }
         return undefined;
     }
@@ -1224,21 +1236,22 @@ ${allArgs ? `${allArgs},` : ""}
                 const ffiType = JSON.stringify(this.typeMapper.mapParameter(param).ffi);
                 const signalParamClass = this.extractSignalParamClass(param, classMap);
                 if (signalParamClass) {
-                    const dotIndex = signalParamClass.indexOf(".");
+                    const { transformedName, originalName } = signalParamClass;
+                    const dotIndex = transformedName.indexOf(".");
                     if (dotIndex !== -1) {
-                        const ns = signalParamClass.slice(0, dotIndex);
-                        const clsName = signalParamClass.slice(dotIndex + 1);
-                        this.usedExternalTypes.set(signalParamClass, {
+                        const ns = transformedName.slice(0, dotIndex);
+                        const clsName = transformedName.slice(dotIndex + 1);
+                        this.usedExternalTypes.set(transformedName, {
                             namespace: ns,
-                            name: clsName,
+                            name: originalName,
                             transformedName: clsName,
                             kind: "class",
                         });
                     }
                     else {
-                        this.signalClasses.add(signalParamClass);
+                        this.signalClasses.set(transformedName, originalName);
                     }
-                    return `{ type: ${ffiType}, getCls: () => ${signalParamClass} }`;
+                    return `{ type: ${ffiType}, getCls: () => ${transformedName} }`;
                 }
                 return `{ type: ${ffiType} }`;
             });
@@ -1263,7 +1276,7 @@ ${allArgs ? `${allArgs},` : ""}
             for (const param of signalParams) {
                 const paramName = toValidIdentifier(toCamelCase(param.name));
                 const signalParamClass = this.extractSignalParamClass(param, classMap);
-                const paramType = signalParamClass ?? this.typeMapper.mapType(param.type).ts;
+                const paramType = signalParamClass?.transformedName ?? this.typeMapper.mapType(param.type).ts;
                 handlerParams.push(`${paramName}: ${paramType}`);
             }
             const returnType = signal.returnType ? this.typeMapper.mapType(signal.returnType).ts : "void";
@@ -1372,7 +1385,7 @@ ${allArgs ? `${allArgs},` : ""}
         if (hasReadableFields) {
             this.usesRead = true;
         }
-        const recordName = normalizeClassName(record.name);
+        const recordName = normalizeClassName(record.name, this.options.namespace);
         const sections = [];
         const initInterface = this.generateRecordInitInterface(record);
         if (initInterface) {
@@ -1405,11 +1418,11 @@ ${allArgs ? `${allArgs},` : ""}
         const initFields = this.getWritableFields(record.fields);
         if (initFields.length === 0)
             return null;
-        const recordName = normalizeClassName(record.name);
+        const recordName = normalizeClassName(record.name, this.options.namespace);
         return this.generateFieldInitInterface(recordName, initFields);
     }
     generateRecordConstructors(record, sharedLibrary) {
-        const recordName = normalizeClassName(record.name);
+        const recordName = normalizeClassName(record.name, this.options.namespace);
         const sections = [];
         const mainConstructor = record.constructors.find((c) => !c.parameters.some(isVararg));
         if (mainConstructor) {
@@ -1463,14 +1476,16 @@ ${allArgs ? `${allArgs},` : ""}
     }
     generateFieldInitInterface(recordName, fields) {
         const properties = fields.map((field) => {
-            const fieldName = toValidIdentifier(toCamelCase(field.name));
+            let fieldName = toValidIdentifier(toCamelCase(field.name));
+            if (fieldName === "id")
+                fieldName = "id_";
             const typeMapping = this.typeMapper.mapType(field.type);
             return `  ${fieldName}?: ${typeMapping.ts};`;
         });
         return `export interface ${recordName}Init {\n${properties.join("\n")}\n}\n\n`;
     }
     generateRecordCreatePtr(record, sharedLibrary) {
-        const recordName = normalizeClassName(record.name);
+        const recordName = normalizeClassName(record.name, this.options.namespace);
         const mainConstructor = record.constructors.find((c) => !c.parameters.some(isVararg));
         if (!mainConstructor) {
             if (record.glibTypeName && record.fields.length > 0) {
@@ -1524,7 +1539,9 @@ ${args}
             const alignment = this.getFieldAlignment(field.type);
             currentOffset = Math.ceil(currentOffset / alignment) * alignment;
             if (field.writable !== false && this.isWritableType(field.type)) {
-                const fieldName = toValidIdentifier(toCamelCase(field.name));
+                let fieldName = toValidIdentifier(toCamelCase(field.name));
+                if (fieldName === "id")
+                    fieldName = "id_";
                 const typeMapping = this.typeMapper.mapType(field.type);
                 writes.push(`    if (init.${fieldName} !== undefined) write(ptr, ${this.generateTypeDescriptor(typeMapping.ffi)}, ${currentOffset}, init.${fieldName});`);
             }
@@ -1594,9 +1611,11 @@ ${args}
             const isWritable = field.writable !== false;
             if (!isReadable && !isWritable)
                 continue;
-            const fieldName = toValidIdentifier(toCamelCase(field.name));
+            let fieldName = toValidIdentifier(toCamelCase(field.name));
             if (methodNames.has(fieldName))
                 continue;
+            if (fieldName === "id")
+                fieldName = "id_";
             const typeMapping = this.typeMapper.mapType(field.type);
             if (field.doc) {
                 sections.push(formatDoc(field.doc, "  ").trimEnd());
@@ -1922,6 +1941,8 @@ ${indent}  }`;
             ffiImports.push("NativeError");
         if (this.usesGetObject)
             ffiImports.push("getObject");
+        if (this.usesInstantiating)
+            ffiImports.push("isInstantiating", "setInstantiating");
         if (this.usesRegisterType)
             ffiImports.push("registerType");
         if (ffiImports.length > 0) {
@@ -1935,8 +1956,12 @@ ${indent}  }`;
             lines.push(`import { ${enumList} } from "./enums.js";`);
         }
         for (const normalizedRecordName of Array.from(this.usedRecords).sort()) {
-            const normalizedCurrentClass = currentClassName ? normalizeClassName(currentClassName) : "";
-            const normalizedParentClass = parentClassName ? normalizeClassName(parentClassName) : "";
+            const normalizedCurrentClass = currentClassName
+                ? normalizeClassName(currentClassName, this.options.namespace)
+                : "";
+            const normalizedParentClass = parentClassName
+                ? normalizeClassName(parentClassName, this.options.namespace)
+                : "";
             if (normalizedRecordName !== normalizedCurrentClass && normalizedRecordName !== normalizedParentClass) {
                 const originalName = this.recordNameToFile.get(normalizedRecordName) ?? normalizedRecordName;
                 lines.push(`import { ${normalizedRecordName} } from "./${toKebabCase(originalName)}.js";`);
@@ -1947,8 +1972,12 @@ ${indent}  }`;
             lines.push(`import { ${interfaceName} } from "./${toKebabCase(originalFileName)}.js";`);
         }
         for (const [className, originalName] of Array.from(this.usedSameNamespaceClasses.entries()).sort((a, b) => a[0].localeCompare(b[0]))) {
-            const normalizedCurrentClass = currentClassName ? normalizeClassName(currentClassName) : "";
-            const normalizedParentClass = parentClassName ? normalizeClassName(parentClassName) : "";
+            const normalizedCurrentClass = currentClassName
+                ? normalizeClassName(currentClassName, this.options.namespace)
+                : "";
+            const normalizedParentClass = parentClassName
+                ? normalizeClassName(parentClassName, this.options.namespace)
+                : "";
             if (className !== normalizedCurrentClass &&
                 className !== normalizedParentClass &&
                 !this.signalClasses.has(className) &&
@@ -1961,9 +1990,9 @@ ${indent}  }`;
                 }
             }
         }
-        for (const className of Array.from(this.signalClasses).sort()) {
+        for (const [className, originalName] of Array.from(this.signalClasses.entries()).sort((a, b) => a[0].localeCompare(b[0]))) {
             if (className !== currentClassName && className !== parentClassName) {
-                lines.push(`import { ${className} } from "./${toKebabCase(className)}.js";`);
+                lines.push(`import { ${className} } from "./${toKebabCase(originalName)}.js";`);
             }
         }
         const externalNamespaces = new Set();