@gtkx/runtime 1.6.0 → 2.0.0-beta.2

package/src/registry.ts

@@ -10,7 +10,7 @@ import {
     setWrapper,
 } from "@gtkx/native";
 import { type AnyClass, walkClassChain } from "@gtkx/utils";
-import { copyLayerMembers, installMixins, type Mixin, type MixinReceiver } from "./mixin.js";
+import { copyLayerMembers, createMixinLayer, installMixins, type Mixin, type MixinReceiver } from "./mixin.js";
 import {
     TYPE_INVALID,
     TYPE_OBJECT,
@@ -402,7 +402,7 @@ function registerInterface(cls: AnyClass, type: bigint, mixin: Mixin, layout?: I
  * @param interfaces Registered interface classes to adopt, in order.
  * @throws If an entry is not a registered interface.
  */
-function installInterfaces(cls: AnyClass, interfaces: AnyClass[]): void {
+function installInterfaces(cls: AnyClass, interfaces: AnyClass[], inheritedOverrides: string[] = []): void {
     const mixins = interfaces.map((iface) => {
         const mixin = getInterfaceMixin(getClassType(iface));
 
@@ -413,7 +413,7 @@ function installInterfaces(cls: AnyClass, interfaces: AnyClass[]): void {
         return mixin;
     });
 
-    installMixins(cls, mixins);
+    installMixins(cls, mixins, inheritedOverrides);
 }
 
 /**
@@ -535,7 +535,7 @@ function applyInterfaceMixin(cls: AnyClass, type: bigint, baseType: bigint, appl
 
     applied.add(type);
 
-    return mixin(cls as AnyClass<MixinReceiver>);
+    return createMixinLayer(cls as AnyClass<MixinReceiver>, mixin, new Set());
 }
 
 function createComposedClass(base: AnyClass, runtimeType: bigint): AnyClass {

package/src/signal-brand.ts

@@ -0,0 +1,29 @@
+const naturalSignalMember: unique symbol = Symbol("gtkx.naturalSignalMember");
+const classSignalMember: unique symbol = Symbol("gtkx.classSignalMember");
+const signalMapOverride: unique symbol = Symbol("gtkx.signalMapOverride");
+const signalEmitMapOverride: unique symbol = Symbol("gtkx.signalEmitMapOverride");
+
+type ResolvedSignalMap<T, TFallback> = T extends {
+    [signalMapOverride]?: infer TResolver;
+}
+    ? TResolver extends () => infer TMap
+        ? NonNullable<TMap>
+        : TFallback
+    : TFallback;
+
+type ResolvedSignalEmitMap<T, TFallback> = T extends {
+    [signalEmitMapOverride]?: infer TResolver;
+}
+    ? TResolver extends () => infer TMap
+        ? NonNullable<TMap>
+        : TFallback
+    : TFallback;
+
+export {
+    classSignalMember,
+    naturalSignalMember,
+    signalEmitMapOverride,
+    type ResolvedSignalEmitMap,
+    type ResolvedSignalMap,
+    signalMapOverride,
+};

package/src/signal.ts

@@ -1,9 +1,10 @@
 import type { Descriptor, ExternalObject, Handle } from "@gtkx/native";
-import { getOrInsert, toCamelIdentifier, upperFirst } from "@gtkx/utils";
+import { type AnyClass, toCamelIdentifier, upperFirst } from "@gtkx/utils";
+import type { ResolvedSignalEmitMap, ResolvedSignalMap } from "./signal-brand.js";
 import { type Arg, isCallerAllocatedArg, isInoutArg, isOutputArg } from "./arg.js";
-import { bind, createBindCache } from "./bind.js";
+import { bind } from "./bind.js";
 import { wrapCallback } from "./callback.js";
-import { toClosure } from "./closure.js";
+import { newCCallbackClosure, toClosure } from "./closure.js";
 import {
     arrayT,
     biguint64T,
@@ -19,7 +20,7 @@ import {
     voidT,
 } from "./descriptors.js";
 import { LIB, VALUE_SIZE, VALUE_T } from "./library.js";
-import { getHandle } from "./registry.js";
+import { getClassType, getHandle, getInstanceType } from "./registry.js";
 import { packTupleResult } from "./tuple.js";
 import { TYPE_INVALID, type TypedClass, typeInterfaces, typeParent } from "./type.js";
 import {
@@ -37,6 +38,55 @@ import {
 /** Function invoked when a connected GObject signal is emitted. */
 type SignalHandler = (...args: unknown[]) => unknown;
 
+const isSignalHandler = (value: unknown): value is SignalHandler => typeof value === "function";
+
+type DeclaredSignalMap<T> = T extends { __signals__?: infer TSignals } ? NonNullable<TSignals> : never;
+type SignalMap<T> = ResolvedSignalMap<T, DeclaredSignalMap<T>>;
+type SignalName<T> = Extract<keyof SignalMap<T>, string>;
+type DeclaredSignalEmitMap<T> = T extends { __signalEmit__?: infer TSignals }
+    ? NonNullable<TSignals>
+    : T extends { __signals__?: infer TSignals }
+        ? {
+                [K in keyof NonNullable<TSignals>]: NonNullable<TSignals>[K] extends (
+                    ...args: infer TArgs
+                ) => infer TResult
+                    ? { args: TArgs; result: TResult }
+                    : never;
+            }
+        : never;
+type SignalEmitMap<T> = ResolvedSignalEmitMap<T, DeclaredSignalEmitMap<T>>;
+type SignalEmitName<T> = Extract<keyof SignalEmitMap<T>, string>;
+type SignalEmitArguments<T, K extends SignalEmitName<T>> = SignalEmitMap<T>[K] extends {
+    args: infer TArgs extends unknown[];
+}
+    ? TArgs
+    : never;
+type SignalEmitResult<T, K extends SignalEmitName<T>> = SignalEmitMap<T>[K] extends {
+    result: infer TResult;
+}
+    ? TResult
+    : never;
+
+type SignalConnector = (
+    instance: object,
+    signal: string,
+    handler: SignalHandler,
+    isAfter?: boolean,
+) => number;
+type SignalEmitter = (instance: object, signal: string, args: unknown[]) => unknown;
+type SignalDispatch = {
+    connect: SignalConnector;
+    emit: SignalEmitter;
+};
+type SignalDispatchSpec = {
+    connect: SignalConnector;
+    emit: SignalEmitter;
+};
+type PendingSignalDispatch = {
+    ownerType: bigint;
+    spec: SignalDispatchSpec;
+};
+
 type DeclaredSignalTypes = {
     paramTypes: bigint[];
     returnType?: bigint;
@@ -69,8 +119,9 @@ type EmitArg = Arg & {
     value?: unknown;
 };
 
-const connectCache = createBindCache();
 const connectionTable: WeakMap<object, Map<string, Set<number>>> = new WeakMap();
+const signalDispatchTable: Map<number, SignalDispatch> = new Map();
+const pendingSignalDispatches: Map<string, PendingSignalDispatch[]> = new Map();
 const gQuarkFromString = bind(LIB, "g_quark_from_string", [stringT("borrowed")], uint32T);
 const gSignalLookup = bind(LIB, "g_signal_lookup", [stringT("borrowed"), biguint64T], uint32T);
 const gSignalName = bind(LIB, "g_signal_name", [uint32T], stringT("borrowed"));
@@ -115,6 +166,15 @@ const getSignalBaseName = (signal: string): string => {
     return detailIndex === -1 ? signal : signal.slice(0, detailIndex);
 };
 
+const canonicalSignalName = (signal: string): string => getSignalBaseName(signal).replaceAll("_", "-");
+
+const canonicalDetailedSignalName = (signal: string): string => {
+    const detailIndex = signal.indexOf("::");
+    const base = canonicalSignalName(signal);
+
+    return detailIndex === -1 ? base : `${base}${signal.slice(detailIndex)}`;
+};
+
 function getSignalDetailQuark(signal: string): number {
     const detailIndex = signal.indexOf("::");
 
@@ -129,21 +189,8 @@ const isSignalHandlerConnected = (instance: object, handlerId: number): boolean
     gSignalHandlerIsConnected(getHandle(instance), handlerId) as boolean;
 
 const trackConnection = (instance: object, signal: string, handlerId: number): void => {
-    let bySignal = connectionTable.get(instance);
-
-    if (!bySignal) {
-        bySignal = new Map();
-        connectionTable.set(instance, bySignal);
-    }
-
-    let handlerIds = bySignal.get(signal);
-
-    if (!handlerIds) {
-        handlerIds = new Set();
-        bySignal.set(signal, handlerIds);
-    }
-
-    handlerIds.add(handlerId);
+    const bySignal = connectionTable.getOrInsertComputed(instance, () => new Map<string, Set<number>>());
+    bySignal.getOrInsertComputed(signal, () => new Set<number>()).add(handlerId);
 };
 
 const untrackConnection = (instance: object, handlerId: number): void => {
@@ -194,7 +241,7 @@ function hasSignalListener(instance: object, signals?: string[]): boolean {
     }
 
     const names =
-        signals === undefined ? bySignal.keys().toArray() : signals.map((signal) => getSignalBaseName(signal));
+        signals === undefined ? bySignal.keys().toArray() : signals.map((signal) => canonicalSignalName(signal));
 
     return names.some((name) => {
         const handlerIds = bySignal.get(name);
@@ -238,23 +285,11 @@ const buildSignalNames = (type: bigint): string[] => {
     return [...names];
 };
 
-const signalNamesFor = (type: bigint): string[] => getOrInsert(signalNameCache, type, buildSignalNames);
+const signalNamesFor = (type: bigint): string[] => signalNameCache.getOrInsertComputed(type, buildSignalNames);
 
 const getSignalId = (instance: object, signal: string): number =>
     signalIdFor((instance as TypedClass).__type__, signal);
 
-function connectBind(type: bigint, signal: string, callback: CallbackDescriptor): (...values: unknown[]) => unknown {
-    const key = `${String(type)}\0${getSignalBaseName(signal)}`;
-
-    return connectCache(
-        key,
-        LIB,
-        "g_signal_connect_data",
-        [objectT("borrowed"), stringT("borrowed"), callback, uint32T],
-        uint64T,
-    );
-}
-
 /**
  * Connects a handler to a GObject signal on an instance and returns the handler id.
  * @param instance Emitter to connect to.
@@ -265,9 +300,10 @@ function connectSignal(instance: object, signal: string, spec: SignalConnectSpec
     const { callback, handler, isAfter } = spec;
     const wrapped = wrapCallback(handler, callback, "signal");
     const type: bigint = (instance as TypedClass).__type__;
-    const connect = connectBind(type, signal, callback);
-    const handlerId = connect(getHandle(instance), signal, wrapped, isAfter ? 1 : 0) as number;
-    trackConnection(instance, getSignalBaseName(signal), handlerId);
+    const key = `${String(type)}\0${getSignalBaseName(signal)}`;
+    const closure = newCCallbackClosure(key, callback, wrapped);
+    const handlerId = gSignalConnectClosure(getHandle(instance), signal, closure, isAfter) as number;
+    trackConnection(instance, canonicalSignalName(signal), handlerId);
 
     return handlerId;
 }
@@ -279,7 +315,7 @@ function overrideSignalClassClosure(type: bigint, signalId: number, handler: Sig
 function connectClosureSignal(instance: object, signal: string, handler: SignalHandler, isAfter: boolean): number {
     const closure = toClosure((...args: unknown[]) => Reflect.apply(handler, null, args.slice(1)));
     const handlerId = gSignalConnectClosure(getHandle(instance), signal, closure, isAfter) as number;
-    trackConnection(instance, getSignalBaseName(signal), handlerId);
+    trackConnection(instance, canonicalSignalName(signal), handlerId);
 
     return handlerId;
 }
@@ -375,19 +411,129 @@ function emitSignal(instance: object, signal: string, args: EmitArg[], returns?:
     return packTupleResult(readEmitOutputs(reads), fromValue(returnValue), true);
 }
 
+function installSignalDispatch(
+    klass: AnyClass,
+    names: readonly string[],
+    spec: SignalDispatchSpec,
+): void {
+    const ownerType = getClassType(klass);
+
+    for (const rawName of names) {
+        const name = canonicalSignalName(rawName);
+        pendingSignalDispatches.getOrInsertComputed(name, () => []).push({ ownerType, spec });
+    }
+}
+
+const resolvePendingSignalDispatch = (signalId: number, name: string): SignalDispatch | undefined => {
+    const pending = pendingSignalDispatches.get(name) ?? [];
+
+    for (let index = pending.length - 1; index >= 0; index -= 1) {
+        const entry = pending[index];
+
+        if (
+            entry !== undefined &&
+            entry.ownerType !== TYPE_INVALID &&
+            signalIdFor(entry.ownerType, name) === signalId
+        ) {
+            signalDispatchTable.set(signalId, entry.spec);
+
+            return entry.spec;
+        }
+    }
+
+    return undefined;
+};
+
+const signalDispatchFor = (instance: object, signal: string): SignalDispatch | undefined => {
+    const name = canonicalSignalName(signal);
+    const instanceType = getInstanceType(instance);
+
+    if (instanceType === TYPE_INVALID) {
+        return undefined;
+    }
+
+    const signalId = signalIdFor(instanceType, name);
+
+    if (signalId === 0) {
+        return undefined;
+    }
+
+    return signalDispatchTable.get(signalId) ?? resolvePendingSignalDispatch(signalId, name);
+};
+
+const connectDispatcherFor = (instance: object, signal: string): SignalConnector => {
+    const dispatch = signalDispatchFor(instance, signal);
+
+    if (dispatch === undefined) {
+        throw new TypeError("connectSignal: unknown signal");
+    }
+
+    return dispatch.connect;
+};
+
+const emitDispatcherFor = (instance: object, signal: string): SignalEmitter => {
+    const dispatch = signalDispatchFor(instance, signal);
+
+    if (dispatch === undefined) {
+        throw new TypeError("emitSignal: unknown signal");
+    }
+
+    return dispatch.emit;
+};
+
+function signalConnect<T extends object, K extends SignalName<NoInfer<T>>>(
+    instance: T,
+    signal: K,
+    handler: SignalMap<NoInfer<T>>[K],
+    isAfter?: boolean,
+): number {
+    return connectSignalByName(instance, signal, handler, isAfter);
+}
+
+function connectSignalByName(
+    instance: object,
+    signal: string,
+    handler: unknown,
+    isAfter?: boolean,
+): number {
+    if (!isSignalHandler(handler)) {
+        throw new TypeError("connectSignal: handler must be a function");
+    }
+
+    return connectDispatcherFor(instance, signal)(instance, signal, handler, isAfter);
+}
+
+function emitSignalByName(instance: object, signal: string, args: unknown[]): unknown {
+    return emitDispatcherFor(instance, signal)(instance, signal, args);
+}
+
+function signalEmit<T extends object, K extends SignalEmitName<NoInfer<T>>>(
+    instance: T,
+    signal: K,
+    ...args: SignalEmitArguments<NoInfer<T>, K>
+): SignalEmitResult<NoInfer<T>, K> {
+    return emitSignalByName(instance, signal, args) as SignalEmitResult<NoInfer<T>, K>;
+}
+
 export {
+    canonicalDetailedSignalName,
+    canonicalSignalName,
     signalForHandlerName,
     getSignalBaseName,
     signalIdFor,
     connectClosureSignal,
     connectSignal,
+    connectSignalByName,
     type DeclaredSignalTypes,
     disconnectSignal,
     emitDeclaredSignal,
     emitSignal,
+    emitSignalByName,
     hasSignalListener,
     isSignalHandlerConnected,
+    installSignalDispatch,
     overrideSignalClassClosure,
-    untrackConnection,
+    signalConnect,
+    signalEmit,
     type SignalHandler,
 };

package/src/t.ts

@@ -41,10 +41,7 @@ type T = {
     unichar: typeof helpers.unicharT;
     /** Descriptor for an opaque `gpointer` argument, taken from a typed array's memory or a numeric address. */
     buffer: typeof helpers.bufferT;
-    /**
-     * Builds a descriptor for a C string, whose optional length sizes the caller-allocated buffer
-     * used when the string is passed by reference.
-     */
+    /** Builds a C-string descriptor with optional caller-allocated length. */
     string: typeof helpers.stringT;
     /** Builds a descriptor for a `GObject`, wrapped in the class registered for its runtime GType. */
     object: typeof helpers.objectT;
@@ -82,28 +79,15 @@ type T = {
     cursorArray: typeof helpers.cursorArrayT;
     /** Builds a descriptor for a function pointer, marshalling a JavaScript function into a native closure. */
     callback: typeof helpers.callbackT;
-    /**
-     * Binds a native function, wiring up argument directions, `GError` checking, and packing output
-     * arguments into the result.
-     */
+    /** Binds a native function with argument directions, errors, and packed outputs. */
     fn: typeof fn;
-    /**
-     * Binds a struct field at a fixed offset, compiling its descriptor once into an accessor that
-     * reads and writes it.
-     */
+    /** Binds a struct field at a fixed offset. */
     field: typeof field;
-    /**
-     * Binds a struct field whose offset is supplied per access, for walking records stored at a
-     * stride in a buffer.
-     */
+    /** Binds a struct field whose offset is supplied per access. */
     fieldAt: typeof fieldAt;
 };
 
-/**
- * Type descriptor builder: a collection of factory helpers that describe C types for
- * FFI marshalling, plus `bind` to bind a native function and `fn` to describe a
- * function signature.
- */
+/** FFI descriptor factories and native function binders. */
 const t: T = {
     bind,
     int8: helpers.int8T,

package/src/type.ts

@@ -86,7 +86,7 @@ const TYPE_VARIANT: bigint = typeFromName("GVariant");
 /** GType tag for a Unicode character stored as `guint`. */
 const TYPE_UNICHAR: bigint = typeFromName("guint");
 const getErrorType: () => bigint = lazyType("GError");
-const getStrvType: () => bigint = lazyType("GStrv");
+const getStrvType = (): bigint => resolveType(LIB, "g_strv_get_type");
 
 const PLAIN_DESCRIPTOR_TYPES: Partial<Record<Descriptor["kind"], bigint>> = {
     boolean: TYPE_BOOLEAN,
@@ -244,6 +244,14 @@ function isResolvableDescriptor(descriptor: Descriptor): descriptor is Resolvabl
     return RESOLVABLE_DESCRIPTOR_KINDS.has(descriptor.kind);
 }
 
+function resolveEnumOrFlagsType(descriptor: Extract<Descriptor, { kind: "enum" | "flags" }>): bigint {
+    if (descriptor.getTypeFnName === "") {
+        return descriptor.isSigned ? TYPE_INT : TYPE_UINT;
+    }
+
+    return resolveType(descriptor.sharedLibrary, descriptor.getTypeFnName);
+}
+
 function resolveDescriptorType(descriptor: Descriptor): bigint {
     if (descriptor.kind === "biguint64" && "type" in descriptor) {
         return TYPE_GTYPE;
@@ -262,7 +270,7 @@ function resolveDescriptorType(descriptor: Descriptor): bigint {
     switch (descriptor.kind) {
         case "enum":
         case "flags": {
-            return resolveType(descriptor.sharedLibrary, descriptor.getTypeFnName);
+            return resolveEnumOrFlagsType(descriptor);
         }
         case "boxed": {
             return resolveBoxedType(descriptor);

package/src/value.ts

@@ -422,6 +422,14 @@ const arrayValueType = (descriptor: ArrayDescriptor): ValueType => {
     throw new Error(`Unsupported array type ${descriptor.arrayKind} of ${descriptor.itemDescriptor.kind}`);
 };
 
+const resolveEnumOrFlagsValueType = (descriptor: Extract<Descriptor, { kind: "enum" | "flags" }>): ValueType => {
+    if (descriptor.getTypeFnName === "") {
+        return descriptor.kind === "flags" ? flagsValueType : enumValueType;
+    }
+
+    return enumOrFlagsValueType(resolveType(descriptor.sharedLibrary, descriptor.getTypeFnName));
+};
+
 const resolveValueType = (descriptor: Descriptor): ValueType => {
     if (descriptor.kind === "biguint64" && "type" in descriptor) {
         return typeValueType;
@@ -440,7 +448,7 @@ const resolveValueType = (descriptor: Descriptor): ValueType => {
     switch (descriptor.kind) {
         case "enum":
         case "flags": {
-            return enumOrFlagsValueType(resolveType(descriptor.sharedLibrary, descriptor.getTypeFnName));
+            return resolveEnumOrFlagsValueType(descriptor);
         }
         case "boxed": {
             return boxedValueType(resolveBoxedType(descriptor));

package/src/variant.ts

@@ -34,10 +34,7 @@ type BasicValueMap<Nested> = {
 
 /** Single-character code of one of the GVariant basic types in {@link BasicValueMap}. */
 type BasicCode = keyof BasicValueMap<unknown>;
-/**
- * JavaScript type a byte array (`ay`) unpacks to: the same one the generated bindings use for byte sequences, so a
- * `Uint8Array` under the `v2ByteArrays` future flag and a `number[]` otherwise.
- */
+/** JavaScript type a byte array (`ay`) unpacks to. */
 type ByteArray = ReturnType<GLib.Bytes["unrefToArray"]>;
 /** Values a byte array (`ay`) packs from. */
 type ByteArrayInput = Uint8Array | number[];
@@ -503,8 +500,7 @@ const toVariant = <S extends string>(typeString: S, value: VariantInput<S>): GLi
 /**
  * Unpacks a `GLib.Variant` into the JavaScript value its GVariant type describes, the inverse of
  * {@link toVariant}. A dictionary keyed by strings unpacks to a record and one keyed by anything
- * else to a `Map`, an array to an array, a byte array (`ay`) to the byte array type the generated
- * bindings use (`Uint8Array` under the `v2ByteArrays` future flag, `number[]` otherwise), a tuple
+ * else to a `Map`, an array to an array, a byte array (`ay`) to a `Uint8Array`, a tuple
  * to an array of its members, a maybe to its value or `null`, and a nested variant to the
  * `GLib.Variant` itself unless `recursive` is set, in which case it is unwrapped all the way down.
  *

package/src/vfunc-call.ts

@@ -1,6 +1,5 @@
-import type { BindVfuncOptions } from "@gtkx/native";
 import type { AnyClass } from "@gtkx/utils";
-import { bindVfunc } from "@gtkx/native";
+import { bindVfunc, type BindVfuncOptions } from "@gtkx/native";
 import { type Arg, isCallerAllocatedArg, requiresInputArg } from "./arg.js";
 import { buildNativeArgTypes, fromNativeCallable } from "./fn.js";
 import { toNative } from "./native-value.js";
@@ -106,21 +105,9 @@ function buildInvoker(slot: ResolvedSlot, instanceType: bigint | undefined, call
 }
 
 function cachedInvoker(cache: InvokerCache, owner: AnyClass, key: string, build: () => Invoker): Invoker {
-    let byKey = cache.get(owner);
+    const byKey = cache.getOrInsertComputed(owner, () => new Map<string, Invoker>());
 
-    if (byKey === undefined) {
-        byKey = new Map();
-        cache.set(owner, byKey);
-    }
-
-    let invoker = byKey.get(key);
-
-    if (invoker === undefined) {
-        invoker = build();
-        byKey.set(key, invoker);
-    }
-
-    return invoker;
+    return byKey.getOrInsertComputed(key, build);
 }
 
 function resolveParentSlot(klass: AnyClass, parentType: bigint, methodName: string): ResolvedSlot | undefined {