@gtkx/runtime 1.2.2 → 1.3.0

package/dist/register-class.d.ts

@@ -1,5 +1,6 @@
 import { type AnyClass } from "@gtkx/utils";
 import { type PropertySpec } from "./properties.js";
+import { type TypedClass } from "./type.js";
 /**
  * A generated interface value, such as `Gio.ListModel`, in the form {@link registerClass} takes it.
  * `__impl__` exists only in the type system: it carries the interface's `Impl` type, of which a class
@@ -31,13 +32,48 @@ type Camelized<TName extends string> = TName extends `${infer THead}-${infer TTa
  * type and names nothing, because a name only known as `string` addresses no member in particular.
  */
 type InstalledNames<TProperties> = string extends keyof TProperties ? never : Camelized<Dashed<keyof TProperties & string>>;
+/**
+ * The base names the signal surface takes for the signals `RegisterClassOptions.signals` declares:
+ * each name as written, plus its canonical spelling with underscores turned into dashes, which
+ * GObject knows the signal by too.
+ */
+type DeclaredSignalBase<TSignals> = (keyof TSignals & string) | Dashed<keyof TSignals & string>;
+/**
+ * The names `connect` and `emit` take for one of the signals `RegisterClassOptions.signals`
+ * declares: each spelling of each name, plus its detailed form for a signal emitted with a
+ * `::detail` suffix.
+ */
+type DeclaredSignalName<TSignals> = DeclaredSignalBase<TSignals> | `${DeclaredSignalBase<TSignals>}::${string}`;
+/**
+ * The `connect` and `emit` signatures instances gain for the signals
+ * `RegisterClassOptions.signals` declares, widening the inherited ones, which take only the names
+ * introspection knows. A class declaring no signals gains nothing, since no name reaches the
+ * added signatures.
+ */
+type DeclaredSignalMethods<TSignals> = {
+    /**
+     * Type-level map from declared signal name to handler signature, feeding the hooks that
+     * address a signal by name, such as `useSignal` from `@gtkx/react`; no value ever carries it.
+     */
+    __signals__?: Record<DeclaredSignalBase<TSignals>, (...args: never[]) => unknown>;
+    /** Connects a handler to a signal `RegisterClassOptions.signals` declared. */
+    connect(signal: DeclaredSignalName<TSignals>, handler: (...args: never[]) => unknown, isAfter?: boolean): number;
+    /** Emits a signal `RegisterClassOptions.signals` declared. */
+    emit(sigName: DeclaredSignalName<TSignals>, ...args: unknown[]): unknown;
+    /** Connects a handler to a signal `RegisterClassOptions.signals` declared, for `off` to take off. */
+    on(sigName: DeclaredSignalName<TSignals>, callback: (...args: unknown[]) => unknown, isAfter?: boolean): unknown;
+    /** Connects a handler to a signal `RegisterClassOptions.signals` declared for one emission. */
+    once(sigName: DeclaredSignalName<TSignals>, callback: (...args: unknown[]) => unknown, isAfter?: boolean): unknown;
+    /** Disconnects a handler `on` or `once` connected to a signal `RegisterClassOptions.signals` declared. */
+    off(sigName: DeclaredSignalName<TSignals>, callback: (...args: unknown[]) => unknown): unknown;
+};
 /**
  * An instance of a registered class: everything the class itself declares, plus the property map the
  * hooks that address a property by name, such as `useProperty` from `@gtkx/react`, read the installed
  * names off. Each name is typed with the value type the class declares for the member of that name,
  * so a property the class does not `declare` contributes nothing.
  */
-type RegisteredInstance<TInstance, TProperties> = TInstance & {
+type RegisteredInstance<TInstance, TProperties, TSignals> = TInstance & DeclaredSignalMethods<TSignals> & {
     /** Type-level map from installed property name to value type; no value ever carries it. */
     __properties__: Pick<TInstance, InstalledNames<TProperties> & keyof TInstance>;
 };
@@ -50,16 +86,79 @@ type RegisteredConstructor<TClass, TArgs extends unknown[], TInstance> = {
     /** Object the class's instances inherit from. */
     prototype: TInstance;
 } & (TClass extends new (...args: never) => unknown ? new (...args: TArgs) => TInstance : abstract new (...args: TArgs) => TInstance);
+/** The statics a registered class keeps from the class it was, joined with {@link RegisteredConstructor}. */
+type RegisteredParts<TClass, TArgs extends unknown[], TInstance> = Omit<TClass, "prototype"> & RegisteredConstructor<TClass, TArgs, TInstance>;
 /**
  * The class {@link registerClass} hands back: the same class, with the same statics, whose instances
- * carry the properties `RegisterClassOptions.properties` installed. Binding the call to a name, rather
- * than discarding it, is what carries those names into the type system.
+ * carry the properties `RegisterClassOptions.properties` installed and take the signals
+ * `RegisterClassOptions.signals` declares by name. Binding the call to a name, rather than
+ * discarding it, is what carries those names into the type system.
+ */
+type RegisteredClass<TClass extends AnyClass, TProperties, TSignals> = TClass extends abstract new (...args: infer TArgs) => infer TInstance ? RegisteredParts<TClass, TArgs, RegisteredInstance<TInstance, TProperties, TSignals>> : never;
+/**
+ * A GType in the form `RegisterClassOptions.signals` takes one: the numeric GType itself, such as
+ * `TYPE_STRING` from `@gtkx/gi/gobject`, or a class carrying one, which is any generated wrapper
+ * class and any class an earlier {@link registerClass} call registered.
+ */
+type SignalGType = bigint | AnyClass<TypedClass>;
+/**
+ * One signal `RegisterClassOptions.signals` creates on the new type, sitting under the signal's
+ * name. Every part is optional: `{}` declares a signal with no arguments and no return value that
+ * runs its handlers in the default `RUN_FIRST` stage.
  */
-type RegisteredClass<TClass extends AnyClass, TProperties> = TClass extends abstract new (...args: infer TArgs) => infer TInstance ? Omit<TClass, "prototype"> & RegisteredConstructor<TClass, TArgs, RegisteredInstance<TInstance, TProperties>> : never;
+type SignalSpec = {
+    /**
+     * `GObject.SignalFlags` bit mask for the signal, defaulting to `RUN_FIRST`. `DETAILED` lets
+     * handlers connect to and emissions name a `::detail` suffix.
+     */
+    flags?: number;
+    /** GType of each argument an emission carries, defaulting to none. */
+    paramTypes?: SignalGType[];
+    /** GType of the value an emission returns, defaulting to none. */
+    returnType?: SignalGType;
+    /**
+     * How the emission combines what its handlers return, limited to the two accumulators GObject
+     * ships: `"first-wins"` stops the emission at the first handler and keeps its result, and
+     * `"true-handled"` runs handlers until one returns `true`, which requires a boolean
+     * `returnType`. Without one, every handler runs and the last result stands.
+     */
+    accumulator?: "first-wins" | "true-handled";
+};
 /** What {@link registerClass} adds to the new GType beyond the vtable slots it discovers on the class. */
-type RegisterClassOptions<TInstance extends object, TProperties extends Record<string, PropertySpec>> = {
-    /** Name to register the new GType under, defaulting to the class's own name. */
+type RegisterClassOptions<TInstance extends object, TProperties extends Record<string, PropertySpec>, TSignals extends Record<string, SignalSpec>> = {
+    /**
+     * Name to register the new GType under, defaulting to the class's own name. Either way the
+     * name has to be a valid GType name: at least three characters, starting with a letter or
+     * underscore, the rest letters, digits, `-`, `_` or `+`. Any other name throws a `TypeError`.
+     */
     typeName?: string;
+    /**
+     * Registers the new GType abstract, the way `G_TYPE_FLAG_ABSTRACT` marks a C type: the class
+     * still serves as a parent for further registered subclasses, which instantiate as usual, but
+     * constructing it directly throws, whether from JavaScript or from a native caller.
+     */
+    abstract?: boolean;
+    /**
+     * Name instances of the new type carry in CSS, applied through `gtk_widget_class_set_css_name`
+     * from inside the type's `class_init`, so every instance is born with it, wherever it is
+     * created from. Requires the class to extend `Gtk.Widget`; registering a non-widget with a
+     * `cssName` throws.
+     */
+    cssName?: string;
+    /**
+     * Hook run once, synchronously, while `registerClass` registers the type, after its
+     * `class_init` has installed the vfuncs, properties and signals declared here. It receives the
+     * new type's class struct wrapped in its generated GTypeStruct wrapper, so class-level setup
+     * calls such as `Gtk.WidgetClass.installAction`, `Gtk.WidgetClass.addShortcut` and
+     * `Gtk.WidgetClass.setLayoutManagerType` have somewhere to land. The wrapper serves the
+     * members of every struct in the parent chain on one object: a widget subclass sees
+     * `Gtk.WidgetClass` and `GObject.ObjectClass` members alike, so the parameter can be declared
+     * as whichever of those types the hook needs. The class struct belongs to the type system for
+     * the life of the process, so keeping the wrapper around past the hook is safe, if rarely
+     * useful. An exception the hook throws propagates out of `registerClass`, with the type
+     * already registered: GObject offers no way to unregister a static type.
+     */
+    classInit?(typeStruct: object): void;
     /**
      * Interfaces the new type implements on top of the ones it inherits, given as the interface values
      * themselves, such as `Gio.ListModel`. Their vtable slots are filled from the `vfunc`-prefixed methods on
@@ -123,6 +222,28 @@ type RegisterClassOptions<TInstance extends object, TProperties extends Record<s
      * and write it rather than the generated storage.
      */
     properties?: TProperties;
+    /**
+     * Signals to create on the new type, keyed by signal name and valued with the
+     * {@link SignalSpec} describing each one. A name has to start with a letter, continue in
+     * letters, digits, `-` and `_`, and be new to the type: one an ancestor type or a listed
+     * interface already carries throws. The two word separators spell the same signal, so a
+     * signal declared as `data_changed` is connected to and emitted as `data-changed` too.
+     *
+     * Instances connect and emit by name through the same `connect`, `on`, `once`, `off` and
+     * `emit` surface inherited signals use: `registerClass` wraps `connect` and `emit` on the
+     * class's prototype to serve the declared names, unless the class defines the member itself,
+     * and hands every other name to the inherited implementation. A handler receives the
+     * emission's arguments without the leading emitter, matching a generated signal, and what it
+     * returns becomes the emission's return value when the signal declares one.
+     *
+     * The declared parameter GTypes rule the emission: `emit` takes exactly one argument per
+     * declared parameter, throwing a `TypeError` for any other count, and converts each argument
+     * into a `GValue` of the declared type, throwing for a value that type cannot hold. The signals
+     * are created with no class closure of their own, but a method named `on<SignalName>`
+     * becomes the signal's default handler, the way every `on`-prefixed method that names a
+     * signal the type carries does; see {@link registerClass}.
+     */
+    signals?: TSignals;
 };
 /**
  * Registers a subclass of a wrapper class as a new GType, wiring up any class and interface
@@ -130,10 +251,19 @@ type RegisterClassOptions<TInstance extends object, TProperties extends Record<s
  * `RegisterClassOptions.implements` names.
  *
  * Throws when the class does not extend a registered wrapper class, when it has no derivable type
- * name, when an entry in `RegisterClassOptions.implements` is not a registered interface, when a
+ * name or the name is not a valid GType name, when an entry in
+ * `RegisterClassOptions.implements` is not a registered interface, when a
  * listed interface has a prerequisite that neither the parent type nor another listed interface meets,
- * and when an entry in `RegisterClassOptions.properties` names its `GObject.ParamSpec` something other
- * than the canonical spelling of the key it sits under.
+ * when the list names `Gio.AsyncInitable` as an interface the parent type does not already
+ * implement and no method on the chain fills `vfuncInitAsync`, since the default `init_async`
+ * would run `vfuncInit` on a worker thread, when an entry in
+ * `RegisterClassOptions.properties` names its `GObject.ParamSpec` something other than the canonical
+ * spelling of the key it sits under, when an entry in
+ * `RegisterClassOptions.signals` carries an invalid name, a name the type already knows, a GType
+ * that cannot hold a value, or an accumulator the spec does not admit, and when
+ * `RegisterClassOptions.cssName` is
+ * given for a class that does not extend `Gtk.Widget`. An exception thrown by
+ * `RegisterClassOptions.classInit` also propagates, after the type has already been registered.
  *
  * A slot is filled from the `vfunc`-prefixed methods on the class's prototype chain, up to but not
  * including the registered ancestor the class extends, so a method an intermediate base class
@@ -143,6 +273,19 @@ type RegisterClassOptions<TInstance extends object, TProperties extends Record<s
  * Declare every slot as a method: a class field holding a function, such as `vfuncGetNItems = () => 1`,
  * is assigned to each instance after registration and never reaches the vtable.
  *
+ * A method named `on<SignalName>` — the signal's name in camelCase after the `on`, so `onClicked`
+ * for `clicked` and `onItemsChanged` for `items-changed` — becomes that signal's default handler
+ * when the type carries the signal, whether an ancestor type or an implemented interface brings it
+ * or `RegisterClassOptions.signals` declares it. The method is installed as a class-closure
+ * override, so it runs on every emission, on the instances a native caller creates included, in
+ * the stage the signal's flags name rather than alongside connected handlers. It receives the
+ * emission's arguments without the leading emitter, with `this` bound to the emitter, and what it
+ * returns becomes the emission's result when the signal declares one. The same discovery walks the
+ * prototype chain vfunc discovery walks, and a subclass registering its own `on<SignalName>`
+ * replaces the handler for its instances, where `super.on<SignalName>()` reaches the replaced one.
+ * An `on`-prefixed method naming no signal the type carries is left alone as the ordinary method
+ * it is.
+ *
  * An override of `vfuncConstructed` runs from inside the base constructor, before JavaScript
  * installs the subclass's field initializers and runs its constructor body, so a field still
  * reads `undefined` there and reading a `#private` field throws. Declare state the override
@@ -155,6 +298,6 @@ type RegisterClassOptions<TInstance extends object, TProperties extends Record<s
  * @param options What the new GType gains beyond the vtable slots the class overrides.
  * @returns The same class, now registered, with every name in `options.properties` in its property map.
  */
-declare function registerClass<T extends AnyClass, TProperties extends Record<string, PropertySpec> = Record<never, PropertySpec>>(klass: T, options?: RegisterClassOptions<T["prototype"], TProperties>): RegisteredClass<T, TProperties>;
-export { type Interface, registerClass };
+declare function registerClass<T extends AnyClass, TProperties extends Record<string, PropertySpec> = Record<never, PropertySpec>, TSignals extends Record<string, SignalSpec> = Record<never, SignalSpec>>(klass: T, options?: RegisterClassOptions<T["prototype"], TProperties, TSignals>): RegisteredClass<T, TProperties, TSignals>;
+export { type Interface, registerClass, type SignalGType, type SignalSpec };
 //# sourceMappingURL=register-class.d.ts.map

package/dist/register-class.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"register-class.d.ts","sourceRoot":"","sources":["../src/register-class.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"register-class.d.ts","sourceRoot":"","sources":["../src/register-class.ts"],"names":[],"mappings":"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"}

package/dist/register-class.js

@@ -1,32 +1,37 @@
 import { registerClass as nativeRegisterClass, } from "@gtkx/native";
-import { getParentClass, walkClassChain } from "@gtkx/utils";
+import { getParentClass, kebabCase, walkClassChain } from "@gtkx/utils";
 import { wrapCallback } from "./callback.js";
 import { insertMixinLayer } from "./mixin.js";
 import { buildPropertyDispatch, GET_PROPERTY_VFUNC, makeGetProperty, makeSetProperty, SET_PROPERTY_VFUNC, toNativeProperties, } from "./properties.js";
-import { getClassType, getInterfaceMixin, markDerivedClass, registerClassType, } from "./registry.js";
-import { TYPE_INTERFACE, TYPE_INVALID, typeFundamental, typeInterfaces, typeIsA } from "./type.js";
+import { getClassStructClass, getClassType, getInterfaceMixin, getTypeClassHandle, markDerivedClass, registerClassType, wrapHandle, } from "./registry.js";
+import { connectClosureSignal, emitDeclaredSignal, getSignalBaseName, overrideSignalClassClosure, } from "./signal.js";
+import { TYPE_INTERFACE, TYPE_INVALID, TYPE_NONE, typeFundamental, typeInterfaces, typeIsA, typeName, } from "./type.js";
 import { findClassVfuncDescriptor, findInterfaceVfuncDescriptor } from "./vfunc.js";
 const INSTANCE_ARG_INDEX = 0;
 const VALUE_ARG_INDEX = 2;
 const TEARDOWN_VFUNC_NAMES = new Set(["dispose", "finalize"]);
+const ASYNC_INITABLE_TYPE_NAME = "GAsyncInitable";
+const INIT_ASYNC_METHOD_NAME = "vfuncInitAsync";
 const PROPERTY_VFUNC_SPECS = [
     { methodName: GET_PROPERTY_VFUNC, isValueOut: true, makeDispatch: makeGetProperty },
     { methodName: SET_PROPERTY_VFUNC, isValueOut: false, makeDispatch: makeSetProperty },
 ];
 const PROPERTY_VFUNC_NAMES = new Set(PROPERTY_VFUNC_SPECS.map((spec) => spec.methodName));
+const TYPE_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9\-_+]{2,}$/;
+const SIGNAL_OVERRIDE_PATTERN = /^on[A-Z]/;
 function registerClass(klass, options = {}) {
     const parentType = resolveParentType(klass);
     if (parentType === TYPE_INVALID) {
         throw new TypeError(`registerClass: ${klass.name} must extend a registered wrapper class`);
     }
-    const name = options.typeName ?? klass.name;
-    if (!name) {
-        throw new Error("registerClass: cannot derive a GType name (anonymous class with no typeName option)");
-    }
+    const name = resolveTypeName(klass, options);
     const declaredTypes = resolveInterfaceTypes(klass, options.implements ?? []);
     const adoptedTypes = declaredTypes.filter((gtype) => !typeIsA(parentType, gtype));
     const properties = options.properties ?? {};
-    const { methods, inheritedNames } = collectInstanceMembers(klass);
+    const signals = resolveDeclaredSignals(klass, options.signals ?? {});
+    const members = collectInstanceMembers(klass);
+    const { methods, inheritedNames } = members;
+    checkAsyncInitable(klass, adoptedTypes, methods);
     const dispatch = buildPropertyDispatch({ klass, properties, adoptedTypes });
     const classVfuncs = [
         ...discoverClassVfuncs(klass, methods),
@@ -34,13 +39,37 @@ function registerClass(klass, options = {}) {
     ];
     const claimedMethodNames = new Set(classVfuncs.map((vfunc) => vfunc.methodName));
     const interfaceBindings = discoverInterfaceBindings(methods, parentType, declaredTypes, claimedMethodNames);
-    const nativeOptions = toNativeOptions(classVfuncs, interfaceBindings, properties);
+    const nativeOptions = withNativeSignals(toNativeOptions(classVfuncs, interfaceBindings, properties, options), signals.native);
     const newType = nativeRegisterClass(name, parentType, nativeOptions);
     registerClassType(klass, newType);
     markDerivedClass(klass);
+    installSignalOverrides(newType, methods);
     applyInterfaceMixins(klass, adoptedTypes, inheritedNames);
+    installDeclaredSignalMethods(klass, signals.table, members.names);
+    invokeClassInit(options, newType);
     return klass;
 }
+function invokeClassInit(options, newType) {
+    if (options.classInit === undefined) {
+        return;
+    }
+    const structClass = getClassStructClass(newType);
+    if (structClass === undefined) {
+        throw new Error("registerClass: no ancestor of the new type registers a class struct wrapper");
+    }
+    options.classInit(wrapHandle(getTypeClassHandle(newType), structClass));
+}
+function resolveTypeName(klass, options) {
+    const name = options.typeName ?? klass.name;
+    if (!name) {
+        throw new TypeError("registerClass: cannot derive a GType name (anonymous class with no typeName option)");
+    }
+    if (!TYPE_NAME_PATTERN.test(name)) {
+        throw new TypeError(`registerClass: '${name}' is not a valid GType name (a letter or underscore, then at ` +
+            "least two more characters, all from A-Z, a-z, 0-9, '-', '_' and '+')");
+    }
+    return name;
+}
 function resolveInterfaceType(klass, entry) {
     const gtype = getClassType(entry);
     if (typeFundamental(gtype) !== TYPE_INTERFACE) {
@@ -52,6 +81,13 @@ function resolveInterfaceType(klass, entry) {
 function resolveInterfaceTypes(klass, entries) {
     return [...new Set(entries.map((entry) => resolveInterfaceType(klass, entry)))];
 }
+function checkAsyncInitable(klass, adoptedTypes, methods) {
+    const isAsyncInitable = adoptedTypes.some((gtype) => typeName(gtype) === ASYNC_INITABLE_TYPE_NAME);
+    if (isAsyncInitable && !methods.has(INIT_ASYNC_METHOD_NAME)) {
+        throw new TypeError(`registerClass: ${klass.name} implements Gio.AsyncInitable without overriding 'vfuncInitAsync'; ` +
+            "the default 'init_async' would run 'vfuncInit' on a worker thread");
+    }
+}
 function applyInterfaceMixins(klass, adoptedTypes, inheritedNames) {
     for (const gtype of adoptedTypes) {
         const mixin = getInterfaceMixin(gtype);
@@ -187,6 +223,99 @@ function buildPropertyVfunc(klass, methodName, fn, isValueOut) {
         fn: wrapVfunc(fn, argDescriptors, descriptor),
     };
 }
+const canonicalSignalName = (name) => name.replaceAll("_", "-");
+function installSignalOverrides(newType, methods) {
+    for (const [methodName, fn] of methods) {
+        if (!SIGNAL_OVERRIDE_PATTERN.test(methodName)) {
+            continue;
+        }
+        const handler = fn;
+        overrideSignalClassClosure(newType, kebabCase(methodName.slice(2)), (...args) => handler.apply(args[0], args.slice(1)));
+    }
+}
+function resolveSignalGType(klass, signalName, role, entry) {
+    if (typeof entry === "bigint") {
+        return entry;
+    }
+    const gtype = getClassType(entry);
+    if (gtype === TYPE_INVALID) {
+        throw new TypeError(`registerClass: signal '${signalName}' of ${klass.name} names a class with no registered ` +
+            `GType as its ${role}`);
+    }
+    return gtype;
+}
+function resolveSignalReturnType(klass, name, spec) {
+    if (spec.returnType === undefined) {
+        return undefined;
+    }
+    const returnType = resolveSignalGType(klass, name, "return type", spec.returnType);
+    return returnType === TYPE_NONE ? undefined : returnType;
+}
+function resolveDeclaredSignal(klass, name, spec) {
+    const paramTypes = (spec.paramTypes ?? []).map((entry, index) => resolveSignalGType(klass, name, `parameter ${String(index)}`, entry));
+    const returnType = resolveSignalReturnType(klass, name, spec);
+    const native = { name, paramTypes };
+    const declared = { paramTypes };
+    if (spec.flags !== undefined) {
+        native.flags = spec.flags;
+    }
+    if (spec.accumulator !== undefined) {
+        native.accumulator = spec.accumulator;
+    }
+    if (returnType !== undefined) {
+        native.returnType = returnType;
+        declared.returnType = returnType;
+    }
+    return { native, declared };
+}
+function resolveDeclaredSignals(klass, signals) {
+    const native = [];
+    const table = new Map();
+    for (const [name, spec] of Object.entries(signals)) {
+        const resolved = resolveDeclaredSignal(klass, name, spec);
+        native.push(resolved.native);
+        table.set(canonicalSignalName(name), resolved.declared);
+    }
+    return { native, table };
+}
+function inheritedSignalMethod(inherited, signal) {
+    if (inherited === undefined) {
+        throw new Error(`Unknown signal '${signal}'`);
+    }
+    return inherited;
+}
+function installDeclaredConnect(proto, findDeclared) {
+    const inheritedConnect = proto.connect;
+    proto.connect = function connect(signal, handler, isAfter) {
+        if (findDeclared(signal) === undefined) {
+            return inheritedSignalMethod(inheritedConnect, signal).call(this, signal, handler, isAfter);
+        }
+        return connectClosureSignal(this, signal, handler, isAfter ?? false);
+    };
+}
+function installDeclaredEmit(proto, findDeclared) {
+    const inheritedEmit = proto.emit;
+    proto.emit = function emit(sigName, ...args) {
+        const declared = findDeclared(sigName);
+        if (declared === undefined) {
+            return inheritedSignalMethod(inheritedEmit, sigName).call(this, sigName, ...args);
+        }
+        return emitDeclaredSignal(this, sigName, declared, args);
+    };
+}
+function installDeclaredSignalMethods(klass, table, definedNames) {
+    if (table.size === 0) {
+        return;
+    }
+    const proto = klass.prototype;
+    const findDeclared = (signal) => table.get(canonicalSignalName(getSignalBaseName(signal)));
+    if (!definedNames.has("connect")) {
+        installDeclaredConnect(proto, findDeclared);
+    }
+    if (!definedNames.has("emit")) {
+        installDeclaredEmit(proto, findDeclared);
+    }
+}
 function toNativeInterface(binding) {
     const nativeInterface = {
         type: binding.gtype,
@@ -198,24 +327,33 @@ function toNativeInterface(binding) {
     }
     return nativeInterface;
 }
-function toNativeOptions(classVfuncs, interfaceBindings, properties) {
-    const hasInterfaces = interfaceBindings.length > 0;
-    const hasClassVfuncs = classVfuncs.length > 0;
-    const hasProperties = Object.keys(properties).length > 0;
-    if (!hasClassVfuncs && !hasInterfaces && !hasProperties) {
-        return undefined;
+function withNativeSignals(options, signals) {
+    if (signals.length === 0) {
+        return options;
+    }
+    return { ...options, signals };
+}
+function applyNativeTypeOptions(options, source) {
+    if (source.abstract ?? false) {
+        options.abstract = true;
+    }
+    if (source.cssName !== undefined) {
+        options.cssName = source.cssName;
     }
+}
+function toNativeOptions(classVfuncs, interfaceBindings, properties, source) {
     const options = {};
-    if (hasProperties) {
+    applyNativeTypeOptions(options, source);
+    if (Object.keys(properties).length > 0) {
         options.properties = toNativeProperties(properties);
     }
-    if (hasClassVfuncs) {
+    if (classVfuncs.length > 0) {
         options.vfuncs = [...classVfuncs];
     }
-    if (hasInterfaces) {
+    if (interfaceBindings.length > 0) {
         options.interfaces = interfaceBindings.map((binding) => toNativeInterface(binding));
     }
-    return options;
+    return Object.keys(options).length > 0 ? options : undefined;
 }
 export { registerClass };
 //# sourceMappingURL=register-class.js.map