@gtkx/runtime 1.0.0 → 1.1.0

package/src/value.ts

@@ -9,6 +9,9 @@ import {
     boxedT,
     float32T,
     float64T,
+    type FundamentalDescriptor,
+    fundamentalLifecycleFor,
+    fundamentalT,
     int8T,
     int32T,
     objectT,
@@ -61,10 +64,13 @@ type ValueType = {
 
 type ValueGetter = (value: ExternalObject<Handle>) => unknown;
 type ValueWriter = ValueType["set"];
+type ValueNarrower = (jsValue: unknown) => unknown;
 
 const setBoxedCache = createBindCache();
 const setStaticBoxedCache = createBindCache();
 const dupBoxedCache = createBindCache();
+const setInstanceCache = createBindCache();
+const peekPointerCache = createBindCache();
 const gValueInit = bind(LIB, "g_value_init", [VALUE_T, biguint64T], voidT);
 const gValueCopy = bind(LIB, "g_value_copy", [VALUE_T, VALUE_T], voidT);
 const booleanValueType = bindValueType("boolean", booleanT);
@@ -86,9 +92,10 @@ const objectValueType = bindValueType("object", objectT("borrowed"));
 const paramValueType = bindValueType("param", PARAM_T);
 const variantValueType = bindValueType("variant", VARIANT_T);
 const pointerValueType = bindValueType("pointer", uint64T);
+const setStrvBoxed = bind(LIB, "g_value_set_boxed", [VALUE_T, arrayT(stringT("borrowed"))], voidT);
 
 const strvValueType: ValueType = {
-    set: bind(LIB, "g_value_set_boxed", [VALUE_T, arrayT(stringT("borrowed"))], voidT),
+    set: setStrvValue,
     get: bind(LIB, "g_value_get_boxed", [VALUE_T], arrayT(stringT("borrowed"))),
 };
 
@@ -112,7 +119,6 @@ const PLAIN_VALUE_TYPES: Partial<Record<Descriptor["kind"], ValueType>> = {
 
 const PLAIN_VALUE_GETTERS: Map<bigint, ValueGetter> = new Map([
     [TYPE_BOOLEAN, booleanValueType.get],
-    [TYPE_GTYPE, typeValueType.get],
     [TYPE_CHAR, scharValueType.get],
     [TYPE_UCHAR, ucharValueType.get],
     [TYPE_INT, intValueType.get],
@@ -129,7 +135,6 @@ const PLAIN_VALUE_GETTERS: Map<bigint, ValueGetter> = new Map([
 
 const PLAIN_VALUE_SETTERS: Map<bigint, ValueType["set"]> = new Map([
     [TYPE_BOOLEAN, booleanValueType.set],
-    [TYPE_GTYPE, typeValueType.set],
     [TYPE_CHAR, scharValueType.set],
     [TYPE_UCHAR, ucharValueType.set],
     [TYPE_INT, intValueType.set],
@@ -182,6 +187,46 @@ const boxedValueType = (type: bigint): ValueType => {
 const enumOrFlagsValueType = (type: bigint): ValueType =>
     typeFundamental(type) === TYPE_FLAGS ? flagsValueType : enumValueType;
 
+function unsupportedFundamental(type: bigint): never {
+    throw new Error(`Unsupported fundamental type '${typeName(type) ?? String(type)}' for value`);
+}
+
+const setInstanceBind = (fundamental: bigint, descriptor: FundamentalDescriptor) =>
+    setInstanceCache(String(fundamental), LIB, "g_value_set_instance", [VALUE_T, descriptor], voidT);
+
+const peekPointerBind = (fundamental: bigint, descriptor: FundamentalDescriptor) =>
+    peekPointerCache(String(fundamental), LIB, "g_value_peek_pointer", [VALUE_T], descriptor);
+
+const customFundamentalDescriptor = (fundamental: bigint): FundamentalDescriptor | undefined => {
+    const name = typeName(fundamental);
+
+    if (name === null) {
+        return undefined;
+    }
+
+    const lifecycle = fundamentalLifecycleFor(name);
+
+    if (lifecycle === undefined) {
+        return undefined;
+    }
+
+    return fundamentalT(lifecycle.sharedLibrary, lifecycle.refFnName, lifecycle.unrefFnName, {
+        ownership: "borrowed",
+        typeName: name,
+    });
+};
+
+const customFundamentalValueType = (type: bigint): ValueType | undefined => {
+    const fundamental = typeFundamental(type);
+    const descriptor = customFundamentalDescriptor(fundamental);
+
+    if (descriptor === undefined) {
+        return undefined;
+    }
+
+    return { set: setInstanceBind(fundamental, descriptor), get: peekPointerBind(fundamental, descriptor) };
+};
+
 const fundamentalValueType = (type: bigint): ValueType => {
     switch (typeFundamental(type)) {
         case TYPE_PARAM: {
@@ -194,7 +239,7 @@ const fundamentalValueType = (type: bigint): ValueType => {
             return boxedValueType(type);
         }
         default: {
-            throw new Error(`Unsupported fundamental type '${typeName(type) ?? String(type)}' for value`);
+            return customFundamentalValueType(type) ?? unsupportedFundamental(type);
         }
     }
 };
@@ -332,6 +377,10 @@ function setStringValue(value: ExternalObject<Handle>, nativeValue: unknown): vo
     stringValueType.set(value, nativeValue ?? null);
 }
 
+function setStrvValue(value: ExternalObject<Handle>, nativeValue: unknown): void {
+    setStrvBoxed(value, nativeValue ?? null);
+}
+
 function setPointerValue(value: ExternalObject<Handle>, nativeValue: unknown): void {
     if (nativeValue != null) {
         throw new Error("G_TYPE_POINTER non-null values cannot be marshalled from JS");
@@ -350,22 +399,51 @@ function setBoxedFromValue(value: ExternalObject<Handle>, nativeValue: unknown):
     setBoxedValue(value, nativeValue ?? null);
 }
 
-const resolveValueGetter = (fundamental: bigint): ValueGetter | undefined =>
+const customFundamentalGetter = (type: bigint): ValueGetter | undefined => {
+    const valueType = customFundamentalValueType(type);
+
+    if (valueType === undefined) {
+        return undefined;
+    }
+
+    return (value) => wrapHandle(valueType.get(value) as ExternalObject<Handle> | null, getWrapperClass(type));
+};
+
+const customFundamentalSetter = (type: bigint): ValueType["set"] | undefined => {
+    const valueType = customFundamentalValueType(type);
+
+    return valueType === undefined ? undefined : handleSetter(valueType);
+};
+
+const builtInValueGetter = (fundamental: bigint): ValueGetter | undefined =>
     PLAIN_VALUE_GETTERS.get(fundamental) ?? wrappedValueGetter(fundamental);
 
-const resolveValueSetter = (fundamental: bigint): ValueType["set"] | undefined =>
+const builtInValueSetter = (fundamental: bigint): ValueType["set"] | undefined =>
     PLAIN_VALUE_SETTERS.get(fundamental) ?? WRAPPED_VALUE_SETTERS.get(fundamental);
 
-function setStrvValue(value: ExternalObject<Handle>, jsValue: unknown): void {
-    strvValueType.set(value, jsValue ?? null);
+const exactValueType = (type: bigint): ValueType | undefined => {
+    if (type === TYPE_GTYPE) {
+        return typeValueType;
+    }
+
+    return type === getStrvType() ? strvValueType : undefined;
+};
+
+const resolveValueGetter = (type: bigint): ValueGetter | undefined =>
+    exactValueType(type)?.get ?? builtInValueGetter(typeFundamental(type)) ?? customFundamentalGetter(type);
+
+const resolveValueSetter = (type: bigint): ValueType["set"] | undefined =>
+    exactValueType(type)?.set ?? builtInValueSetter(typeFundamental(type)) ?? customFundamentalSetter(type);
+
+const holdsUnchanged: ValueNarrower = (jsValue) => jsValue;
+const holdsAsFloat: ValueNarrower = (jsValue) => Math.fround(jsValue as number);
+
+function valueNarrowerFor(type: bigint): ValueNarrower {
+    return typeFundamental(type) === TYPE_FLOAT ? holdsAsFloat : holdsUnchanged;
 }
 
 function valueWriterFor(type: bigint): ValueWriter {
-    if (type === getStrvType()) {
-        return setStrvValue;
-    }
-
-    const set = resolveValueSetter(typeFundamental(type));
+    const set = resolveValueSetter(type);
 
     if (set === undefined) {
         throw new Error(`Unsupported type for intoValue: ${typeName(type) ?? String(type)}`);
@@ -407,12 +485,7 @@ function toValue(descriptor: Descriptor, value: unknown): ExternalObject<Handle>
 
 function fromValue(value: ExternalObject<Handle>): unknown {
     const type = getValueType(value);
-
-    if (type === getStrvType()) {
-        return strvValueType.get(value);
-    }
-
-    const get = resolveValueGetter(typeFundamental(type));
+    const get = resolveValueGetter(type);
 
     if (get === undefined) {
         throw new Error(`Unsupported type for fromValue: ${typeName(type) ?? String(type)}`);
@@ -463,6 +536,8 @@ export {
     outValueForDescriptor,
     outValueForBoxedDescriptor,
     inoutValueForBoxedDescriptor,
+    type ValueNarrower,
+    valueNarrowerFor,
     type ValueWriter,
     valueWriterFor,
 };

package/src/vfunc-call.ts

@@ -82,7 +82,11 @@ function buildInvoker(slot: ResolvedSlot, instanceType: bigint | undefined, call
 
     const shaped = fromNativeCallable(
         bindVfunc(bindOptionsFor(slot, instanceType, args, label)),
-        { args, returns: descriptor.returnDescriptor, canThrow },
+        {
+            args,
+            returns: descriptor.returnDescriptor,
+            canThrow,
+        },
         takeRefSeeds,
     );
 

package/src/vfunc.ts

@@ -2,6 +2,7 @@ import type { Descriptor } from "@gtkx/native";
 import { type AnyClass, getParentClass, walkClassChain } from "@gtkx/utils";
 import type { Arg } from "./arg.js";
 import { isCallerAllocatedOut } from "./callback.js";
+import { foldedLengthSources } from "./folded-lengths.js";
 import { getInterfaceVfuncRegistry, getVfuncRegistry, type VfuncDescriptor } from "./registry.js";
 
 function findClassVfuncDescriptor(klass: AnyClass, methodName: string): VfuncDescriptor | null {
@@ -12,9 +13,13 @@ function findInterfaceVfuncDescriptor(interfaceGtype: bigint, methodName: string
     return getInterfaceVfuncRegistry(interfaceGtype)?.[methodName];
 }
 
-function vfuncArg(descriptor: Descriptor): Arg {
+function vfuncArg(descriptor: Descriptor, isFoldedLength: boolean): Arg {
     if (descriptor.kind === "ref") {
-        return { type: descriptor.innerDescriptor, direction: descriptor.inout === true ? "inout" : "out" };
+        return {
+            type: descriptor.innerDescriptor,
+            direction: descriptor.inout === true ? "inout" : "out",
+            isConsumed: isFoldedLength,
+        };
     }
 
     if (isCallerAllocatedOut(descriptor)) {
@@ -25,7 +30,9 @@ function vfuncArg(descriptor: Descriptor): Arg {
 }
 
 function vfuncArgs(descriptor: VfuncDescriptor): Arg[] {
-    return descriptor.argDescriptors.map((argDescriptor) => vfuncArg(argDescriptor));
+    const lengths = foldedLengthSources(descriptor);
+
+    return descriptor.argDescriptors.map((argDescriptor, index) => vfuncArg(argDescriptor, lengths.has(index)));
 }
 
 export { findClassVfuncDescriptor, findInterfaceVfuncDescriptor, vfuncArgs };