@gtkx/runtime 1.0.0-rc.1 → 1.0.0-rc.2

package/src/registry.ts

@@ -1,3 +1,4 @@
+import type { AnyClass } from "@gtkx/utils";
 import {
     type ExternalObject,
     getType,
@@ -6,7 +7,6 @@ import {
     type RegisterClassVfunc as NativeRegisterClassVfunc,
     setWrapper,
 } from "@gtkx/native";
-import type { AnyClass } from "@gtkx/utils";
 import type { Mixin, MixinReceiver } from "./mixin.js";
 import { TYPE_INVALID, type TypedClass, typeInterfaces, typeIsA, typeName, typeParent } from "./type.js";
 
@@ -14,46 +14,50 @@ import { TYPE_INVALID, type TypedClass, typeInterfaces, typeIsA, typeName, typeP
  * Static side of class `C` with its construct signature preserved but the member
  * named `K` (default `"new"`) removed.
  */
-export type StaticBase<C, K extends PropertyKey = "new"> = Omit<C, K> &
+type StaticBase<C, K extends PropertyKey = "new"> = Omit<C, K> &
     (C extends new (...args: infer A) => infer R ? new (...args: A) => R : never);
 
-export type VfuncDescriptor<K extends "class" | "interface"> = {
+type VfuncDescriptor<K extends "class" | "interface"> = {
     kind: K;
     className: string;
     vfuncName: string;
     byteOffset: number;
+    vtableSize: number;
     argDescriptors: NativeRegisterClassVfunc["argDescriptors"];
     returnDescriptor: NativeRegisterClassVfunc["returnDescriptor"];
 };
 
-export type VfuncRegistry = Record<string, VfuncDescriptor<"class"> | VfuncDescriptor<"interface">>;
+type VfuncRegistry = Record<string, VfuncDescriptor<"class"> | VfuncDescriptor<"interface">>;
 
-const classRegistry = new Map<bigint, AnyClass>();
-const interfaceMixinRegistry = new Map<bigint, Mixin>();
-const composedClassRegistry = new Map<bigint, AnyClass>();
-const handleMap = new WeakMap<object, ExternalObject<Handle>>();
-const vfuncRegistry = new WeakMap<object, VfuncRegistry>();
-const interfaceVfuncRegistry = new Map<bigint, VfuncRegistry>();
+const classRegistry: Map<bigint, AnyClass> = new Map();
+const interfaceMixinRegistry: Map<bigint, Mixin> = new Map();
+const composedClassRegistry: Map<bigint, AnyClass> = new Map();
+const handleMap: WeakMap<object, ExternalObject<Handle>> = new WeakMap();
+const vfuncRegistry: WeakMap<object, VfuncRegistry> = new WeakMap();
+const interfaceVfuncRegistry: Map<bigint, VfuncRegistry> = new Map();
 
 function setClassType(cls: AnyClass, type: bigint): void {
     (cls.prototype as { [K in keyof TypedClass]: TypedClass[K] }).__type__ = type;
 }
 
-export function getClassType(cls: AnyClass): bigint {
+function getClassType(cls: AnyClass): bigint {
     const proto: object = cls.prototype;
+
     return Object.hasOwn(proto, "__type__") ? (proto as TypedClass).__type__ : TYPE_INVALID;
 }
 
 /** Returns the GType tag of the given wrapper instance. */
-export function getInstanceType(instance: object): bigint {
+function getInstanceType(instance: object): bigint {
     return getClassType(instance.constructor as AnyClass);
 }
 
-export function registerClassType(cls: AnyClass, type: bigint): void {
-    if (type !== TYPE_INVALID) {
-        classRegistry.set(type, cls);
-        setClassType(cls, type);
+function registerClassType(cls: AnyClass, type: bigint): void {
+    if (type === TYPE_INVALID) {
+        return;
     }
+
+    classRegistry.set(type, cls);
+    setClassType(cls, type);
 }
 
 /**
@@ -63,9 +67,12 @@ export function registerClassType(cls: AnyClass, type: bigint): void {
  * @param type GType the class wraps.
  * @param vfuncs Virtual functions the class overrides.
  */
-export function registerWrapperClass(cls: AnyClass, type: bigint, vfuncs?: VfuncRegistry): void {
+function registerWrapperClass(cls: AnyClass, type: bigint, vfuncs?: VfuncRegistry): void {
     registerClassType(cls, type);
-    if (vfuncs) registerVfuncRegistry(cls, vfuncs);
+
+    if (vfuncs) {
+        registerVfuncRegistry(cls, vfuncs);
+    }
 }
 
 /**
@@ -76,11 +83,17 @@ export function registerWrapperClass(cls: AnyClass, type: bigint, vfuncs?: Vfunc
  * @param mixin Mixin that applies the interface to a wrapper class.
  * @param vfuncs Virtual functions the interface exposes.
  */
-export function registerInterface(cls: AnyClass, type: bigint, mixin: Mixin, vfuncs?: VfuncRegistry): void {
-    if (type === TYPE_INVALID) return;
+function registerInterface(cls: AnyClass, type: bigint, mixin: Mixin, vfuncs?: VfuncRegistry): void {
+    if (type === TYPE_INVALID) {
+        return;
+    }
+
     setClassType(cls, type);
     interfaceMixinRegistry.set(type, mixin);
-    if (vfuncs) registerInterfaceVfuncRegistry(type, vfuncs);
+
+    if (vfuncs) {
+        registerInterfaceVfuncRegistry(type, vfuncs);
+    }
 }
 
 /**
@@ -91,24 +104,29 @@ export function registerInterface(cls: AnyClass, type: bigint, mixin: Mixin, vfu
  * @param handle Native handle to wrap.
  * @param cls Wrapper class to instantiate, or omitted to resolve it from the runtime type.
  */
-export function wrapHandle(handle: null | undefined, cls?: AnyClass): null;
-export function wrapHandle<T extends object>(handle: ExternalObject<Handle>, cls: AnyClass<T>): T;
-export function wrapHandle<T extends object>(
+function wrapHandle(handle: null | undefined, cls?: AnyClass): null;
+function wrapHandle<T extends object>(handle: ExternalObject<Handle>, cls: AnyClass<T>): T;
+
+function wrapHandle<T extends object>(
     handle: ExternalObject<Handle> | null | undefined,
     cls: AnyClass<T>,
 ): T | null;
-export function wrapHandle<T extends object = TypedClass>(handle: ExternalObject<Handle>, cls?: AnyClass): T;
-export function wrapHandle<T extends object = TypedClass>(
-    handle: ExternalObject<Handle> | null | undefined,
-    cls?: AnyClass,
-): T | null;
-export function wrapHandle(handle: ExternalObject<Handle> | null | undefined, cls?: AnyClass): object | null {
-    if (handle === null || handle === undefined) return null;
+
+function wrapHandle(handle: ExternalObject<Handle>, cls?: AnyClass): TypedClass;
+function wrapHandle(handle: ExternalObject<Handle> | null | undefined, cls?: AnyClass): TypedClass | null;
+
+function wrapHandle(handle: ExternalObject<Handle> | null | undefined, cls?: AnyClass): object | null {
+    if (handle === null || handle === undefined) {
+        return null;
+    }
+
     if (cls === undefined) {
         return getOrCreateWrapper(handle);
     }
-    const instance: object = Object.create(cls.prototype);
+
+    const instance: object = Object.create(cls.prototype) as object;
     setHandle(instance, handle);
+
     return instance;
 }
 
@@ -116,85 +134,135 @@ export function wrapHandle(handle: ExternalObject<Handle> | null | undefined, cl
  * Returns the wrapper class registered for a GType, walking up to ancestor types,
  * and throws if none is registered.
  */
-export function getWrapperClass(type: bigint): AnyClass {
+function getWrapperClass(type: bigint): AnyClass {
     const cls = resolveWrapperClass(type);
+
     if (!cls) {
         throw new Error(`No registered wrapper class for type '${typeName(type) ?? String(type)}'`);
     }
+
     return cls;
 }
 
-export function resolveWrapperClass(type: bigint): AnyClass | null {
+function resolveWrapperClass(type: bigint): AnyClass | null {
     let currentType = type;
+
     while (currentType !== TYPE_INVALID) {
         const cls = classRegistry.get(currentType);
-        if (cls) return cls;
+
+        if (cls) {
+            return cls;
+        }
+
         currentType = typeParent(currentType);
     }
+
     return null;
 }
 
+function applyInterfaceMixin(cls: AnyClass, type: bigint, baseType: bigint, applied: Set<bigint>): AnyClass {
+    if (applied.has(type) || typeIsA(baseType, type)) {
+        return cls;
+    }
+
+    const mixin = interfaceMixinRegistry.get(type);
+
+    if (mixin === undefined) {
+        return cls;
+    }
+
+    applied.add(type);
+
+    return mixin(cls as AnyClass<MixinReceiver>);
+}
+
 function createComposedClass(base: AnyClass, runtimeType: bigint): AnyClass {
     const baseType = getClassType(base);
-    const applied = new Set<bigint>();
+    const applied: Set<bigint> = new Set();
     let cls: AnyClass = base;
+
     for (const type of typeInterfaces(runtimeType)) {
-        if (applied.has(type) || typeIsA(baseType, type)) continue;
-        const mixin = interfaceMixinRegistry.get(type);
-        if (mixin === undefined) continue;
-        applied.add(type);
-        cls = mixin(cls as AnyClass<MixinReceiver>);
+        cls = applyInterfaceMixin(cls, type, baseType, applied);
     }
+
     return applied.size === 0 ? base : cls;
 }
 
 function resolveComposedClass(runtimeType: bigint): AnyClass | null {
     const exact = classRegistry.get(runtimeType);
-    if (exact) return exact;
+
+    if (exact) {
+        return exact;
+    }
+
     const cached = composedClassRegistry.get(runtimeType);
-    if (cached) return cached;
+
+    if (cached) {
+        return cached;
+    }
+
     const base = resolveWrapperClass(runtimeType);
-    if (base === null) return null;
+
+    if (base === null) {
+        return null;
+    }
+
     const composed = createComposedClass(base, runtimeType);
-    if (composed === base) return base;
+
+    if (composed === base) {
+        return base;
+    }
+
     setClassType(composed, runtimeType);
     composedClassRegistry.set(runtimeType, composed);
+
     return composed;
 }
 
 function getOrCreateWrapper(handle: ExternalObject<Handle>): object {
     const existing = getWrapper(handle);
-    if (existing) return existing;
+
+    if (existing) {
+        return existing;
+    }
 
     const runtimeType: bigint = getType(handle);
+
     if (runtimeType === TYPE_INVALID) {
         throw new Error("Cannot resolve runtime GLib type from handle");
     }
 
     const cls = resolveComposedClass(runtimeType);
-    if (!cls) throw new Error(`Expected registered GLib type, got type ${String(runtimeType)}`);
-    const instance: object = Object.create(cls.prototype);
+
+    if (!cls) {
+        throw new Error(`Expected registered GLib type, got type ${String(runtimeType)}`);
+    }
+
+    const instance: object = Object.create(cls.prototype) as object;
     registerWrapper(handle, instance);
+
     return instance;
 }
 
 /** Returns the native handle bound to a wrapper instance, throwing if none is set. */
-export function getHandle(instance: object): ExternalObject<Handle> {
+function getHandle(instance: object): ExternalObject<Handle> {
     const handle = handleMap.get(instance);
+
     if (handle === undefined) {
         const name = (instance as { constructor?: { name?: string } }).constructor?.name ?? "object";
         throw new Error(`No native handle associated with ${name}`);
     }
+
     return handle;
 }
 
 /** Returns the native handle bound to an instance, or undefined when there is none or the instance is null. */
-export function tryGetHandle(instance: object | null | undefined): ExternalObject<Handle> | undefined {
+function tryGetHandle(instance: object | null | undefined): ExternalObject<Handle> | undefined {
     return instance == null ? undefined : handleMap.get(instance);
 }
 
 /** Associates a native handle with a wrapper instance. */
-export function setHandle(instance: object, handle: ExternalObject<Handle>): void {
+function setHandle(instance: object, handle: ExternalObject<Handle>): void {
     handleMap.set(instance, handle);
 }
 
@@ -207,15 +275,37 @@ function registerVfuncRegistry(cls: object, registry: VfuncRegistry): void {
     vfuncRegistry.set(cls, registry);
 }
 
-export function getVfuncRegistry(cls: object): VfuncRegistry | undefined {
+function getVfuncRegistry(cls: object): VfuncRegistry | undefined {
     return vfuncRegistry.get(cls);
 }
 
 function registerInterfaceVfuncRegistry(type: bigint, registry: VfuncRegistry): void {
-    if (type === TYPE_INVALID) return;
+    if (type === TYPE_INVALID) {
+        return;
+    }
+
     interfaceVfuncRegistry.set(type, registry);
 }
 
-export function getInterfaceVfuncRegistry(type: bigint): VfuncRegistry | undefined {
+function getInterfaceVfuncRegistry(type: bigint): VfuncRegistry | undefined {
     return interfaceVfuncRegistry.get(type);
 }
+
+export {
+    getClassType,
+    getInstanceType,
+    registerClassType,
+    registerWrapperClass,
+    registerInterface,
+    wrapHandle,
+    getWrapperClass,
+    resolveWrapperClass,
+    getHandle,
+    tryGetHandle,
+    setHandle,
+    getVfuncRegistry,
+    getInterfaceVfuncRegistry,
+    type StaticBase,
+    type VfuncDescriptor,
+    type VfuncRegistry,
+};

package/src/signal.ts

@@ -1,10 +1,12 @@
 import type { Descriptor, ExternalObject, Handle } from "@gtkx/native";
+import type { TypedClass } from "./type.js";
 import { type Arg, isCallerAllocatedArg, isInoutArg, isOutputArg } from "./arg.js";
 import { bind, createBindCache } from "./bind.js";
 import { wrapCallback } from "./callback.js";
 import {
     arrayT,
     biguint64T,
+    booleanT,
     type CallbackDescriptor,
     objectT,
     stringT,
@@ -15,7 +17,6 @@ import {
 import { LIB, VALUE_SIZE, VALUE_T } from "./library.js";
 import { getHandle } from "./registry.js";
 import { packTupleResult } from "./tuple.js";
-import type { TypedClass } from "./type.js";
 import {
     fromValue,
     getBoxedValue,
@@ -27,7 +28,7 @@ import {
 } from "./value.js";
 
 /** Function invoked when a connected GObject signal is emitted. */
-export type SignalHandler = (...args: unknown[]) => unknown;
+type SignalHandler = (...args: unknown[]) => unknown;
 
 type SignalConnectSpec = {
     callback: CallbackDescriptor;
@@ -55,25 +56,42 @@ const gSignalHandlersBlockMatched = bind(
     uint32T,
 );
 
+const gSignalHandlerIsConnected = bind(
+    LIB,
+    "g_signal_handler_is_connected",
+    [objectT("borrowed"), uint64T],
+    booleanT,
+);
+
 /** Returns the signal name without its detail suffix (the part after `::`). */
-export const getSignalBaseName = (signal: string): string => {
+const getSignalBaseName = (signal: string): string => {
     const detailIndex = signal.indexOf("::");
+
     return detailIndex === -1 ? signal : signal.slice(0, detailIndex);
 };
 
-function getQuarkForSignalDetail(signal: string): number {
+function getSignalDetailQuark(signal: string): number {
     const detailIndex = signal.indexOf("::");
-    if (detailIndex === -1) return 0;
+
+    if (detailIndex === -1) {
+        return 0;
+    }
+
     return gQuarkFromString(signal.slice(detailIndex + 2)) as number;
 }
 
+const isSignalHandlerConnected = (instance: object, handlerId: number): boolean =>
+    gSignalHandlerIsConnected(getHandle(instance), handlerId) as boolean;
+
 const getSignalId = (instance: object, signal: string): number => {
     const type: bigint = (instance as TypedClass).__type__;
+
     return gSignalLookup(getSignalBaseName(signal), type) as number;
 };
 
 function connectBind(type: bigint, signal: string, callback: CallbackDescriptor): (...values: unknown[]) => unknown {
-    const key = `${type}\0${getSignalBaseName(signal)}`;
+    const key = `${String(type)}\0${getSignalBaseName(signal)}`;
+
     return connectCache(
         key,
         LIB,
@@ -89,26 +107,35 @@ function connectBind(type: bigint, signal: string, callback: CallbackDescriptor)
  * @param signal Signal name, optionally including a `::detail` suffix.
  * @param spec Callback descriptor, handler function, and whether to run after the default handler.
  */
-export function connectSignal(instance: object, signal: string, spec: SignalConnectSpec): number {
+function connectSignal(instance: object, signal: string, spec: SignalConnectSpec): number {
     const { callback, handler, after } = spec;
     const wrapped = wrapCallback(handler, callback, "emitter");
     const type: bigint = (instance as TypedClass).__type__;
     const connect = connectBind(type, signal, callback);
+
     return connect(getHandle(instance), signal, wrapped, after ? 1 : 0) as number;
 }
 
-export function blockMatchedSignalHandlers(instance: object, signal: string): void {
+function blockMatchedSignalHandlers(instance: object, signal: string): void {
     const signalId = getSignalId(instance, signal);
     gSignalHandlersBlockMatched(getHandle(instance), 1, signalId, 0, undefined, undefined, undefined);
 }
 
 const createEmitValue = (arg: EmitArg): { value: ExternalObject<Handle>; read?: () => unknown } => {
-    if (!isOutputArg(arg)) return { value: toValue(arg.type, arg.value) };
+    if (!isOutputArg(arg)) {
+        return { value: toValue(arg.type, arg.value) };
+    }
+
     if (isCallerAllocatedArg(arg)) {
-        if (isInoutArg(arg)) return { value: inoutValueForBoxedDescriptor(arg.type, arg.value as object) };
+        if (isInoutArg(arg)) {
+            return { value: inoutValueForBoxedDescriptor(arg.type, arg.value as object) };
+        }
+
         const value = outValueForBoxedDescriptor(arg.type, arg.value as object);
+
         return { value, read: () => getBoxedValue(value) };
     }
+
     return isInoutArg(arg) ? outValueForDescriptor(arg.type, arg.value) : outValueForDescriptor(arg.type);
 };
 
@@ -120,21 +147,25 @@ const createEmitValue = (arg: EmitArg): { value: ExternalObject<Handle>; read?:
  * @param args Arguments to pass, including output and inout arguments.
  * @param returnDescriptor Descriptor for the signal's return value, omitted when it returns void.
  */
-export function emitSignal(instance: object, signal: string, args: EmitArg[], returnDescriptor?: Descriptor): unknown {
+function emitSignal(instance: object, signal: string, args: EmitArg[], returnDescriptor?: Descriptor): unknown {
     const signalId = getSignalId(instance, signal);
-    const detail = getQuarkForSignalDetail(signal);
+    const detail = getSignalDetailQuark(signal);
     const values: ExternalObject<Handle>[] = [toValue(objectT("full"), instance)];
     const reads: (() => unknown)[] = [];
 
     for (const arg of args) {
         const { value, read } = createEmitValue(arg);
         values.push(value);
-        if (read) reads.push(read);
+
+        if (read) {
+            reads.push(read);
+        }
     }
 
     if (returnDescriptor !== undefined) {
         const returnValue = newValueForDescriptor(returnDescriptor);
         gSignalEmitv(values, signalId, detail, returnValue);
+
         return packTupleResult(
             reads.map((read) => read()),
             fromValue(returnValue),
@@ -150,3 +181,12 @@ export function emitSignal(instance: object, signal: string, args: EmitArg[], re
         false,
     );
 }
+
+export {
+    getSignalBaseName,
+    connectSignal,
+    blockMatchedSignalHandlers,
+    emitSignal,
+    isSignalHandlerConnected,
+    type SignalHandler,
+};

package/src/t.ts

@@ -47,7 +47,7 @@ type T = {
  * FFI marshalling, plus `bind` to bind a native function and `fn` to describe a
  * function signature.
  */
-export const t: T = {
+const t: T = {
     bind,
     int8: helpers.int8T,
     uint8: helpers.uint8T,
@@ -86,3 +86,5 @@ export const t: T = {
     callback: helpers.callbackT,
     fn,
 };
+
+export { t };

package/src/tuple.ts

@@ -1,13 +1,20 @@
-export const packTupleResult = (outs: unknown[], primary: unknown, hasPrimary: boolean): unknown => {
+const packTupleResult = (outs: unknown[], primary: unknown, hasPrimary: boolean): unknown => {
     if (hasPrimary) {
         return outs.length === 0 ? primary : [primary, ...outs];
     }
-    if (outs.length === 0) return undefined;
-    if (outs.length === 1) return outs[0];
+
+    if (outs.length === 0) {
+        return undefined;
+    }
+
+    if (outs.length === 1) {
+        return outs[0];
+    }
+
     return outs;
 };
 
-export const splitTupleResult = (
+const splitTupleResult = (
     result: unknown,
     hasPrimary: boolean,
     outCount: number,
@@ -16,10 +23,15 @@ export const splitTupleResult = (
         if (Array.isArray(result)) {
             return { primary: result[0], outValues: result.slice(1) };
         }
+
         return { primary: result, outValues: [] };
     }
+
     if (outCount === 1) {
         return { primary: undefined, outValues: [result] };
     }
+
     return { primary: undefined, outValues: Array.isArray(result) ? result : [] };
 };
+
+export { packTupleResult, splitTupleResult };