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

package/src/value.ts

@@ -1,6 +1,7 @@
 import { alloc, type Descriptor, type ExternalObject, getType, type Handle, read, write } from "@gtkx/native";
 import { bind, createBindCache } from "./bind.js";
 import {
+    type ArrayDescriptor,
     arrayT,
     bigint64T,
     biguint64T,
@@ -20,6 +21,7 @@ import { toNative } from "./native-value.js";
 import { getHandle, getWrapperClass, wrapHandle } from "./registry.js";
 import {
     getStrvType,
+    isResolvableDescriptor,
     resolveBoxedType,
     resolveDescriptorType,
     resolveFundamentalType,
@@ -50,30 +52,13 @@ type ValueType = {
     get: (value: ExternalObject<Handle>) => unknown;
 };
 
-const getBoxedTypeName = (type: bigint): string => typeName(type) ?? "GBoxed";
-const newValue = (): ExternalObject<Handle> => alloc(VALUE_SIZE, "GValue");
+type ValueGetter = (value: ExternalObject<Handle>) => unknown;
 
 const setBoxedCache = createBindCache();
 const setStaticBoxedCache = createBindCache();
 const dupBoxedCache = 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 bindValueType = (symbol: string, descriptor: Descriptor): ValueType => ({
-    set: bind(LIB, `g_value_set_${symbol}`, [VALUE_T, descriptor], voidT),
-    get: bind(LIB, `g_value_get_${symbol}`, [VALUE_T], descriptor),
-});
-
-const setBoxedBind = (name: string) =>
-    setBoxedCache(name, LIB, "g_value_set_boxed", [VALUE_T, boxedT(name, { sharedLibrary: LIB })], voidT);
-
-const setStaticBoxedBind = (name: string) =>
-    setStaticBoxedCache(name, LIB, "g_value_set_static_boxed", [VALUE_T, boxedT(name, { sharedLibrary: LIB })], voidT);
-
-const dupBoxedBind = (name: string) =>
-    dupBoxedCache(name, LIB, "g_value_dup_boxed", [VALUE_T], boxedT(name, { ownership: "full", sharedLibrary: LIB }));
-
 const booleanValueType = bindValueType("boolean", booleanT);
 const typeValueType = bindValueType("gtype", biguint64T);
 const intValueType = bindValueType("int", int32T);
@@ -95,8 +80,80 @@ const strvValueType: ValueType = {
     get: bind(LIB, "g_value_get_boxed", [VALUE_T], arrayT(stringT("borrowed"))),
 };
 
+const PLAIN_VALUE_TYPES: Partial<Record<Descriptor["kind"], ValueType>> = {
+    boolean: booleanValueType,
+    string: stringValueType,
+    int8: intValueType,
+    int16: intValueType,
+    int32: intValueType,
+    uint8: uintValueType,
+    uint16: uintValueType,
+    uint32: uintValueType,
+    int64: int64ValueType,
+    bigint64: int64ValueType,
+    uint64: uint64ValueType,
+    biguint64: uint64ValueType,
+    float32: floatValueType,
+    float64: doubleValueType,
+    object: objectValueType,
+};
+
+const PLAIN_VALUE_GETTERS: Map<bigint, ValueGetter> = new Map([
+    [TYPE_BOOLEAN, booleanValueType.get],
+    [TYPE_GTYPE, typeValueType.get],
+    [TYPE_INT, intValueType.get],
+    [TYPE_UINT, uintValueType.get],
+    [TYPE_INT64, int64ValueType.get],
+    [TYPE_UINT64, uint64ValueType.get],
+    [TYPE_FLOAT, floatValueType.get],
+    [TYPE_DOUBLE, doubleValueType.get],
+    [TYPE_ENUM, enumValueType.get],
+    [TYPE_FLAGS, flagsValueType.get],
+]);
+
+const PLAIN_VALUE_SETTERS: Map<bigint, ValueType["set"]> = new Map([
+    [TYPE_BOOLEAN, booleanValueType.set],
+    [TYPE_GTYPE, typeValueType.set],
+    [TYPE_INT, intValueType.set],
+    [TYPE_UINT, uintValueType.set],
+    [TYPE_INT64, int64ValueType.set],
+    [TYPE_UINT64, uint64ValueType.set],
+    [TYPE_FLOAT, floatValueType.set],
+    [TYPE_DOUBLE, doubleValueType.set],
+    [TYPE_ENUM, enumValueType.set],
+    [TYPE_FLAGS, flagsValueType.set],
+]);
+
+const WRAPPED_VALUE_SETTERS: Map<bigint, ValueType["set"]> = new Map([
+    [TYPE_STRING, setStringValue],
+    [TYPE_OBJECT, handleSetter(objectValueType)],
+    [TYPE_PARAM, handleSetter(paramValueType)],
+    [TYPE_VARIANT, handleSetter(variantValueType)],
+    [TYPE_BOXED, setBoxedFromValue],
+]);
+
+const getBoxedTypeName = (type: bigint): string => typeName(type) ?? "GBoxed";
+const newValue = (): ExternalObject<Handle> => alloc(VALUE_SIZE, resolveBoxedType(VALUE_T));
+
+function bindValueType(symbol: string, descriptor: Descriptor): ValueType {
+    return {
+        set: bind(LIB, `g_value_set_${symbol}`, [VALUE_T, descriptor], voidT),
+        get: bind(LIB, `g_value_get_${symbol}`, [VALUE_T], descriptor),
+    };
+}
+
+const setBoxedBind = (name: string) =>
+    setBoxedCache(name, LIB, "g_value_set_boxed", [VALUE_T, boxedT(name, { sharedLibrary: LIB })], voidT);
+
+const setStaticBoxedBind = (name: string) =>
+    setStaticBoxedCache(name, LIB, "g_value_set_static_boxed", [VALUE_T, boxedT(name, { sharedLibrary: LIB })], voidT);
+
+const dupBoxedBind = (name: string) =>
+    dupBoxedCache(name, LIB, "g_value_dup_boxed", [VALUE_T], boxedT(name, { ownership: "full", sharedLibrary: LIB }));
+
 const boxedValueType = (type: bigint): ValueType => {
     const name = getBoxedTypeName(type);
+
     return { set: setBoxedBind(name), get: dupBoxedBind(name) };
 };
 
@@ -105,31 +162,37 @@ const enumOrFlagsValueType = (type: bigint): ValueType =>
 
 const fundamentalValueType = (type: bigint): ValueType => {
     switch (typeFundamental(type)) {
-        case TYPE_PARAM:
+        case TYPE_PARAM: {
             return paramValueType;
-        case TYPE_VARIANT:
+        }
+        case TYPE_VARIANT: {
             return variantValueType;
-        case TYPE_BOXED:
+        }
+        case TYPE_BOXED: {
             return boxedValueType(type);
-        default:
+        }
+        default: {
             throw new Error(`Unsupported fundamental type '${typeName(type) ?? String(type)}' for value`);
+        }
     }
 };
 
-export function getValueType(value: ExternalObject<Handle>): bigint {
+function getValueType(value: ExternalObject<Handle>): bigint {
     return read(value, biguint64T, 0) as bigint;
 }
 
-export function copyValue(dest: ExternalObject<Handle>, src: ExternalObject<Handle>): void {
+function copyValue(dest: ExternalObject<Handle>, src: ExternalObject<Handle>): void {
     if (getValueType(dest) === TYPE_INVALID) {
         gValueInit(dest, getValueType(src));
     }
+
     gValueCopy(src, dest);
 }
 
 const newTypedValue = (type: bigint): ExternalObject<Handle> => {
     const value = newValue();
     gValueInit(value, type);
+
     return value;
 };
 
@@ -141,6 +204,7 @@ const newBoxedValue = (
     const type = resolveDescriptorType(descriptor);
     const value = newTypedValue(type);
     resolveSetBind(getBoxedTypeName(type))(value, getHandle(boxed));
+
     return value;
 };
 
@@ -148,160 +212,219 @@ const newBoxedValue = (
  * Reads the boxed pointer out of a GValue and returns it wrapped in its registered
  * class, or null when the value does not hold a boxed type.
  */
-export function getBoxedValue(value: ExternalObject<Handle>): object | null {
+function getBoxedValue(value: ExternalObject<Handle>): object | null {
     const type = getValueType(value);
-    if (typeFundamental(type) !== TYPE_BOXED) return null;
+
+    if (typeFundamental(type) !== TYPE_BOXED) {
+        return null;
+    }
+
     const cls = getWrapperClass(type);
     const boxed = dupBoxedBind(getBoxedTypeName(type))(value) as ExternalObject<Handle> | null;
+
     return wrapHandle(boxed, cls);
 }
 
 /** Stores a boxed object, or null, into a GValue that holds a boxed type. */
-export function setBoxedValue(value: ExternalObject<Handle>, boxed: object | null): void {
+function setBoxedValue(value: ExternalObject<Handle>, boxed: object | null): void {
     const name = getBoxedTypeName(getValueType(value));
     setBoxedBind(name)(value, boxed === null ? null : getHandle(boxed));
 }
 
+const arrayValueType = (descriptor: ArrayDescriptor): ValueType => {
+    if (descriptor.itemDescriptor.kind === "string" && descriptor.arrayKind === "array") {
+        return strvValueType;
+    }
+
+    throw new Error(`Unsupported array type ${descriptor.arrayKind} of ${descriptor.itemDescriptor.kind}`);
+};
+
 const resolveValueType = (descriptor: Descriptor): ValueType => {
     if (descriptor.kind === "biguint64" && "type" in descriptor) {
         return typeValueType;
     }
+
+    const plain = PLAIN_VALUE_TYPES[descriptor.kind];
+
+    if (plain !== undefined) {
+        return plain;
+    }
+
+    if (!isResolvableDescriptor(descriptor)) {
+        throw new Error(`Unsupported type descriptor '${descriptor.kind}'`);
+    }
+
     switch (descriptor.kind) {
-        case "boolean":
-            return booleanValueType;
-        case "string":
-            return stringValueType;
-        case "int8":
-        case "int16":
-        case "int32":
-            return intValueType;
-        case "uint8":
-        case "uint16":
-        case "uint32":
-            return uintValueType;
-        case "int64":
-        case "bigint64":
-            return int64ValueType;
-        case "uint64":
-        case "biguint64":
-            return uint64ValueType;
-        case "float32":
-            return floatValueType;
-        case "float64":
-            return doubleValueType;
-        case "object":
-            return objectValueType;
         case "enum":
-        case "flags":
+        case "flags": {
             return enumOrFlagsValueType(resolveType(descriptor.sharedLibrary, descriptor.getTypeFnName));
-        case "boxed":
+        }
+        case "boxed": {
             return boxedValueType(resolveBoxedType(descriptor));
-        case "fundamental":
+        }
+        case "fundamental": {
             return fundamentalValueType(resolveFundamentalType(descriptor));
-        case "array":
-            if (descriptor.itemDescriptor.kind === "string" && descriptor.arrayKind === "array") {
-                return strvValueType;
-            }
-            throw new Error(`Unsupported array type ${descriptor.arrayKind} of ${descriptor.itemDescriptor.kind}`);
-        default:
-            throw new Error(`Unsupported type descriptor '${descriptor.kind}'`);
+        }
+        case "array": {
+            return arrayValueType(descriptor);
+        }
     }
 };
 
-const resolveValueGetter = (fundamental: bigint): ((value: ExternalObject<Handle>) => unknown) | undefined => {
+const wrappedValueGetter = (fundamental: bigint): ValueGetter | undefined => {
     switch (fundamental) {
-        case TYPE_BOOLEAN:
-            return booleanValueType.get;
-        case TYPE_GTYPE:
-            return typeValueType.get;
-        case TYPE_INT:
-            return intValueType.get;
-        case TYPE_UINT:
-            return uintValueType.get;
-        case TYPE_INT64:
-            return int64ValueType.get;
-        case TYPE_UINT64:
-            return uint64ValueType.get;
-        case TYPE_FLOAT:
-            return floatValueType.get;
-        case TYPE_DOUBLE:
-            return doubleValueType.get;
-        case TYPE_ENUM:
-            return enumValueType.get;
-        case TYPE_FLAGS:
-            return flagsValueType.get;
-        case TYPE_STRING:
+        case TYPE_STRING: {
             return (value) => stringValueType.get(value) ?? null;
-        case TYPE_OBJECT:
+        }
+        case TYPE_OBJECT: {
             return (value) => wrapHandle(objectValueType.get(value) as ExternalObject<Handle> | null);
-        case TYPE_PARAM:
+        }
+        case TYPE_PARAM: {
             return (value) =>
                 wrapHandle(paramValueType.get(value) as ExternalObject<Handle> | null, getWrapperClass(TYPE_PARAM));
-        case TYPE_VARIANT:
+        }
+        case TYPE_VARIANT: {
             return (value) =>
                 wrapHandle(variantValueType.get(value) as ExternalObject<Handle> | null, getWrapperClass(TYPE_VARIANT));
-        case TYPE_BOXED:
+        }
+        case TYPE_BOXED: {
             return getBoxedValue;
-        case TYPE_POINTER:
+        }
+        case TYPE_POINTER: {
             return (value) => {
                 if (pointerValueType.get(value)) {
                     throw new Error("G_TYPE_POINTER non-null values cannot be marshalled to JS");
                 }
+
                 return null;
             };
-        default:
+        }
+        default: {
             return undefined;
+        }
     }
 };
 
-export function toValue(descriptor: Descriptor, value: unknown): ExternalObject<Handle> {
+function setStringValue(value: ExternalObject<Handle>, nativeValue: unknown): void {
+    stringValueType.set(value, nativeValue ?? null);
+}
+
+function handleSetter(target: ValueType): ValueType["set"] {
+    return (value, nativeValue) => {
+        target.set(value, nativeValue == null ? null : getHandle(nativeValue));
+    };
+}
+
+function setBoxedFromValue(value: ExternalObject<Handle>, nativeValue: unknown): void {
+    setBoxedValue(value, nativeValue ?? null);
+}
+
+const resolveValueGetter = (fundamental: bigint): ValueGetter | undefined =>
+    PLAIN_VALUE_GETTERS.get(fundamental) ?? wrappedValueGetter(fundamental);
+
+const resolveValueSetter = (fundamental: bigint): ValueType["set"] | undefined =>
+    PLAIN_VALUE_SETTERS.get(fundamental) ?? WRAPPED_VALUE_SETTERS.get(fundamental);
+
+/**
+ * Stores a JavaScript value into an already-initialized GValue, converting it to
+ * whatever type the GValue holds.
+ *
+ * @param value The initialized GValue to write into.
+ * @param jsValue The JavaScript value to store.
+ */
+function intoValue(value: ExternalObject<Handle>, jsValue: unknown): void {
+    const type = getValueType(value);
+    const set = resolveValueSetter(typeFundamental(type));
+
+    if (set === undefined) {
+        throw new Error(`Unsupported type for intoValue: ${typeName(type) ?? String(type)}`);
+    }
+
+    set(value, jsValue);
+}
+
+const resolveNativeValue = (descriptor: Descriptor, value: unknown): unknown => {
     const isHandleKind = descriptor.kind === "object" || descriptor.kind === "boxed";
-    const nativeValue = isHandleKind
-        ? value == null
-            ? null
-            : getHandle(value as object)
-        : toNative(descriptor, value);
-    const type =
-        descriptor.kind === "object"
-            ? nativeValue == null
-                ? TYPE_OBJECT
-                : getType(nativeValue as ExternalObject<Handle>)
-            : resolveDescriptorType(descriptor);
+
+    if (!isHandleKind) {
+        return toNative(descriptor, value);
+    }
+
+    return value == null ? null : getHandle(value);
+};
+
+const resolveValueGType = (descriptor: Descriptor, nativeValue: unknown): bigint => {
+    if (descriptor.kind !== "object") {
+        return resolveDescriptorType(descriptor);
+    }
+
+    return nativeValue == null ? TYPE_OBJECT : getType(nativeValue as ExternalObject<Handle>);
+};
+
+function toValue(descriptor: Descriptor, value: unknown): ExternalObject<Handle> {
+    const nativeValue = resolveNativeValue(descriptor, value);
+    const type = resolveValueGType(descriptor, nativeValue);
     const gValue = newTypedValue(type);
     resolveValueType(descriptor).set(gValue, nativeValue);
+
     return gValue;
 }
 
-export function fromValue(value: ExternalObject<Handle>): unknown {
+function fromValue(value: ExternalObject<Handle>): unknown {
     const type = getValueType(value);
-    if (type === getStrvType()) return strvValueType.get(value);
+
+    if (type === getStrvType()) {
+        return strvValueType.get(value);
+    }
+
     const get = resolveValueGetter(typeFundamental(type));
+
     if (get === undefined) {
         throw new Error(`Unsupported type for fromValue: ${typeName(type) ?? String(type)}`);
     }
+
     return get(value);
 }
 
-export function newValueForDescriptor(descriptor: Descriptor): ExternalObject<Handle> {
+function newValueForDescriptor(descriptor: Descriptor): ExternalObject<Handle> {
     return newTypedValue(resolveDescriptorType(descriptor));
 }
 
-export function outValueForDescriptor(
+function outValueForDescriptor(
     descriptor: Descriptor,
     initial?: unknown,
 ): { value: ExternalObject<Handle>; read: () => unknown } {
     const storage = alloc(8);
     write(storage, uint64T, 0, 0);
-    if (initial !== undefined) write(storage, descriptor, 0, initial);
+
+    if (initial !== undefined) {
+        write(storage, descriptor, 0, initial);
+    }
+
     const value = newTypedValue(TYPE_POINTER);
     pointerValueType.set(value, storage);
+
     return { value, read: () => read(storage, descriptor, 0) };
 }
 
-export function outValueForBoxedDescriptor(descriptor: Descriptor, boxed: object): ExternalObject<Handle> {
+function outValueForBoxedDescriptor(descriptor: Descriptor, boxed: object): ExternalObject<Handle> {
     return newBoxedValue(descriptor, boxed, setBoxedBind);
 }
 
-export function inoutValueForBoxedDescriptor(descriptor: Descriptor, boxed: object): ExternalObject<Handle> {
+function inoutValueForBoxedDescriptor(descriptor: Descriptor, boxed: object): ExternalObject<Handle> {
     return newBoxedValue(descriptor, boxed, setStaticBoxedBind);
 }
+
+export {
+    getValueType,
+    intoValue,
+    copyValue,
+    getBoxedValue,
+    setBoxedValue,
+    toValue,
+    fromValue,
+    newValueForDescriptor,
+    outValueForDescriptor,
+    outValueForBoxedDescriptor,
+    inoutValueForBoxedDescriptor,
+};