@gtkx/codegen 1.1.0 → 1.2.1

package/src/store/gi/record.ts

@@ -12,6 +12,14 @@ import { computeRecordFieldSlots } from "./record-layout.js";
 import { appendWrapperClassRegistration } from "./registration.js";
 import { isConstructibleRecord } from "./value-marshalable.js";
 
+type RecordMembersOptions = {
+    context: ModuleContext;
+    record: GirRecord;
+    className: string;
+    callables: Callables;
+    gtypeExpr: string | undefined;
+};
+
 const isGErrorRecord = (context: ModuleContext, record: GirRecord): boolean =>
     context.namespace.name === "GLib" && record.glibGetType === "g_error_get_type";
 
@@ -30,7 +38,8 @@ const generateRecord = (context: ModuleContext, record: GirRecord): void => {
     };
 
     generateBindings(context, callables);
-    const members = renderRecordMembers(context, record, className, callables);
+    const gtypeExpr = renderSourceGtype(context, record);
+    const members = renderRecordMembers({ context, record, className, callables, gtypeExpr });
     const body = indentMembers(members);
     const heritage = isErrorSubclass ? " extends globalThis.Error" : "";
     const doc = getDoc(record);
@@ -50,29 +59,16 @@ const generateRecord = (context: ModuleContext, record: GirRecord): void => {
         });
     }
 
-    const gtypeExpr = renderSourceGtype(context, record);
-
     appendWrapperClassRegistration(context, {
         className,
         gtypeExpr,
     });
 };
 
-const renderRecordMembers = (
-    context: ModuleContext,
-    record: GirRecord,
-    className: string,
-    callables: Callables,
-): string[] => {
+const renderRecordMembers = (options: RecordMembersOptions): string[] => {
+    const { context, record, className, callables, gtypeExpr } = options;
     const isErrorSubclass = isGErrorRecord(context, record);
-
-    const { members, claimedNames } = renderPlainTypeMembers({
-        context,
-        className,
-        callables,
-        hasGtype: record.glibGetType !== undefined,
-    });
-
+    const { members, claimedNames } = renderPlainTypeMembers({ context, className, callables, gtypeExpr });
     members.unshift(renderRecordConstructor(context, { record, className, callables, isErrorSubclass }));
     const { slots } = computeRecordFieldSlots(context, record.fields, record.isUnion);
 

package/src/store/gi/return-wrap.ts

@@ -10,7 +10,7 @@ type WrapReturnOptions = {
     valueExpression: string;
 };
 
-const BIGINT_CATEGORIES: Set<PrimitiveCategory> = new Set(["gtype", "bigint64", "biguint64"]);
+const BIGINT_CATEGORIES: Set<PrimitiveCategory> = new Set(["gtype", "bigint64", "biguint64", "pointer"]);
 
 const wrapReturnValue = (context: ModuleContext, options: WrapReturnOptions): string => {
     const { ref, isNullable, valueExpression } = options;

package/src/store/gi/signal.ts

@@ -1,5 +1,5 @@
 import { camelCase, sourceStringLiteral } from "@gtkx/utils";
-import type { GirClass } from "../../gir/class.js";
+import type { GirClass, GirSignal } from "../../gir/class.js";
 import type { GirCallable, GirParameter, GirReturnValue } from "../../gir/parameter.js";
 import type { GirProperty } from "../../gir/property.js";
 import type { ModuleContext } from "../../writer/context.js";
@@ -48,6 +48,21 @@ const SIGNAL_HANDLER_TYPE = "(...args: any[]) => any";
 const SIGNALS_SUFFIX = "Signals";
 const SIGNAL_EMIT_SUFFIX = "SignalEmit";
 
+const DEPRECATED_SIGNAL_ALIASES: Map<string, string> = new Map([
+    ["addEventListener", "on"],
+    ["removeEventListener", "off"],
+]);
+
+const deprecatedAliasDoc = (method: string): string => {
+    const replacement = DEPRECATED_SIGNAL_ALIASES.get(method);
+
+    if (replacement === undefined) {
+        return "";
+    }
+
+    return `/** @deprecated Since 1.2. Use \`${replacement}\` instead. Removed in v2. */\n`;
+};
+
 const renderSignalMembers = (context: ModuleContext, klass: GirClass): string[] => {
     if (klass.glibGetType === undefined) {
         return [];
@@ -68,7 +83,7 @@ const renderSignalMembers = (context: ModuleContext, klass: GirClass): string[]
 
     const connectDefault = isRootObject
         ? "default:\n    throw new globalThis.Error(\"Unknown signal '\" + signal + \"'\");"
-        : "default:\n    return super.connect(signal, handler, isAfter);";
+        : "default:\n    return super.connect(signal as never, handler as never, isAfter);";
 
     const emitDefault = isRootObject
         ? "default:\n    throw new globalThis.Error(\"Unknown signal '\" + sigName + \"'\");"
@@ -124,10 +139,18 @@ const renderSignalMap = (spec: SignalMapSpec): string => {
     const { context, klass, className, isParentlessObjectSubclass, suffix, renderEntry } = spec;
     const extendsRefs = signalMapParentRefs(context, klass, isParentlessObjectSubclass, suffix);
     const extendsClause = extendsRefs.length === 0 ? "" : ` extends ${extendsRefs.join(", ")}`;
+    const signals = collectClassSignals(context, klass);
 
-    const signalEntries = collectClassSignals(context, klass).map(
-        (signal) => `${signalDoc(signal)}${sourceStringLiteral(signal.name)}: ${renderEntry(context, signal)};`,
-    );
+    const signalEntries = signals.flatMap((signal) => {
+        const value = renderEntry(context, signal);
+        const entry = `${signalDoc(signal)}${sourceStringLiteral(signal.name)}: ${value};`;
+
+        if (!signal.isDetailed) {
+            return [entry];
+        }
+
+        return [entry, `[detail: \`${signal.name}::\${string}\`]: ${value};`];
+    });
 
     const entries = [...signalEntries, ...renderNotifyDetailEntries(context, klass, suffix)];
 
@@ -191,17 +214,17 @@ const renderSignalConnectInterface = (className: string, isRootObject: boolean):
     const lines = [
         `__signals__?: ${map};`,
         `connect<K extends keyof ${map}>(signal: K, handler: ${map}[K], isAfter?: boolean): number;`,
-        `connect(signal: string, handler: ${SIGNAL_HANDLER_TYPE}, isAfter?: boolean): number;`,
         `emit<K extends keyof ${emitMap}>(sigName: K, ...args: ${emitMap}[K]["args"]): ${emitMap}[K]["result"];`,
-        "emit(sigName: string, ...args: unknown[]): unknown;",
     ];
 
-    if (!isRootObject) {
+    if (isRootObject) {
+        lines.push("emit(sigName: string, ...args: unknown[]): unknown;");
+    } else {
         const chainable = (methods: string[], trailing: string): void => {
             for (const method of methods) {
                 lines.push(
+                    deprecatedAliasDoc(method) +
                     `${method}<K extends keyof ${map}>(signal: K, handler: ${map}[K]${trailing}): this;`,
-                    `${method}(signal: string, handler: ${SIGNAL_HANDLER_TYPE}${trailing}): this;`,
                 );
             }
         };
@@ -356,7 +379,7 @@ const renderCallback = (context: ModuleContext, signal: GirCallable): string =>
 const forEachInterfaceSignal = (
     context: ModuleContext,
     klass: GirClass,
-    consider: (signal: GirCallable) => void,
+    consider: (signal: GirSignal) => void,
 ): void => {
     for (const iface of resolveInterfaces(context.library, context.namespace.name, klass.implements)) {
         for (const signal of iface.klass.signals) {
@@ -365,12 +388,12 @@ const forEachInterfaceSignal = (
     }
 };
 
-const collectClassSignals = (context: ModuleContext, klass: GirClass): GirCallable[] => {
+const collectClassSignals = (context: ModuleContext, klass: GirClass): GirSignal[] => {
     const inheritedNames = collectInheritedSignalNames(context, klass);
     const seen: Set<string> = new Set();
-    const result: GirCallable[] = [];
+    const result: GirSignal[] = [];
 
-    const consider = (signal: GirCallable): void => {
+    const consider = (signal: GirSignal): void => {
         const name = camelCase(signal.name);
 
         if (!signal.introspectable || inheritedNames.has(name) || seen.has(name)) {

package/src/store/jsx-store.ts

@@ -30,7 +30,6 @@ const writeJsxStore = (
             peerDependencies: { "@gtkx/gi": "*", "@gtkx/react": "*", react: "*" },
         }),
         rawFiles,
-        requiresEnvReference: true,
     });
 };
 

package/src/store/resolve-store.ts

@@ -28,6 +28,7 @@ const STORE_CONSUMERS: string[] = [
     "@gtkx/components",
     "@gtkx/css",
     "@gtkx/react",
+    "@gtkx/runtime",
     "@gtkx/testing",
 ];
 

package/src/store/store-fs.ts

@@ -50,7 +50,6 @@ type WriteStoreParams = {
     files: SourceModule[];
     manifest: Manifest;
     rawFiles?: RawFile[];
-    requiresEnvReference?: boolean;
 };
 
 const STORE_DIR_MODE = 0o755;
@@ -98,18 +97,13 @@ const writeStore = (params: WriteStoreParams): void => {
 };
 
 const buildTempStore = (tmp: string, params: WriteStoreParams): void => {
+    writePackageJson(tmp, params.manifest);
+
     for (const file of params.files) {
         writeSourceFile(tmp, file.fileName, file.source);
     }
 
-    compileStore({
-        storeDir: tmp,
-        files: params.files,
-        packageName: params.manifest.name,
-        ...(params.requiresEnvReference !== undefined && { requiresEnvReference: params.requiresEnvReference }),
-    });
-
-    writePackageJson(tmp, params.manifest);
+    compileStore({ storeDir: tmp, files: params.files, packageName: params.manifest.name });
     const rawFiles = params.rawFiles ?? [];
 
     for (const raw of rawFiles) {

package/src/xml.ts

@@ -7,8 +7,12 @@ type XmlFileInput = {
     parser: XMLParser;
     label: string;
     path: string;
+    malformedRemedy?: string;
 };
 
+const HIGHEST_CONTROL_CODE = 0x1F;
+const LEGAL_CONTROL_CODES: Set<number> = new Set([0x09, 0x0A, 0x0D]);
+
 const createXmlParser = (options: Partial<X2jOptions>): XMLParser =>
     new XMLParser({
         ignoreAttributes: false,
@@ -46,13 +50,51 @@ const positionSuffix = (error: unknown): string => {
     return ` (line ${String(line)}, column ${String(col)})`;
 };
 
+const isIllegalControlCode = (code: number): boolean =>
+    code <= HIGHEST_CONTROL_CODE && !LEGAL_CONTROL_CODES.has(code);
+
+const escapedCode = (code: number): string => `[U+${code.toString(16).toUpperCase().padStart(4, "0")}]`;
+
+const escapeControlCodes = (text: string): string => {
+    let escaped = "";
+
+    for (const character of text) {
+        const code = character.codePointAt(0) ?? 0;
+        escaped += isIllegalControlCode(code) ? escapedCode(code) : character;
+    }
+
+    return escaped;
+};
+
+const offendingLine = (xml: string, error: unknown): string => {
+    const line = isRecord(error) ? error.line : undefined;
+
+    if (typeof line !== "number") {
+        return "";
+    }
+
+    const text = xml.split("\n")[line - 1];
+
+    if (text === undefined) {
+        return "";
+    }
+
+    return `\n    ${escapeControlCodes(text.replace(/^[ \t]+/, "").replace(/\r$/, ""))}`;
+};
+
+const remedySuffix = (input: XmlFileInput, xml: string, error: unknown): string => {
+    const remedy = input.malformedRemedy;
+
+    return remedy === undefined ? "" : `${offendingLine(xml, error)}\n${remedy}`;
+};
+
 const assertWellFormed = (input: XmlFileInput, xml: string): void => {
     try {
         SyntaxValidator.validate(xml);
     } catch (error) {
         throw new Error(
             `The ${input.label} at ${input.path} is not well-formed XML: ` +
-            `${errorMessage(error)}${positionSuffix(error)}`,
+            `${errorMessage(error)}${positionSuffix(error)}${remedySuffix(input, xml, error)}`,
             { cause: error },
         );
     }