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

package/src/fn.ts

@@ -24,61 +24,87 @@ type ArgSpec = {
     isOutParam: boolean;
 };
 
-const buildNativeArgTypes = (args: Arg[], throws: boolean): Descriptor[] => {
+const buildNativeArgTypes = (args: Arg[], canThrow: boolean): Descriptor[] => {
     const nativeArgTypes = args.map((argSpec) =>
         argSpec.direction !== undefined && argSpec.callerAllocated !== true ? refT(argSpec.type) : argSpec.type,
     );
-    if (throws)
+
+    if (canThrow) {
         nativeArgTypes.push(
             refT(boxedT("GError", { ownership: "full", sharedLibrary: LIB, getTypeFnName: "g_error_get_type" })),
         );
+    }
+
     return nativeArgTypes;
 };
 
 const buildArgSpecs = (args: Arg[]): ArgSpec[] => {
     let inputCursor = 0;
+
     return args.map((arg) => {
         const isRef = isRefArg(arg);
-        const consumesInput = !isRef || isInoutArg(arg);
+        const isConsumesInput = !isRef || isInoutArg(arg);
         const isOutParam = isOutputArg(arg) && arg.consumed !== true;
+
         return {
             arg,
             isRef,
             isCallerAllocated: isCallerAllocatedArg(arg),
-            consumesInput,
-            inputIndex: consumesInput ? inputCursor++ : -1,
+            consumesInput: isConsumesInput,
+            inputIndex: isConsumesInput ? inputCursor++ : -1,
             isOutParam,
         };
     });
 };
 
+const resolveCallerAllocated = (inputs: unknown[], inputIndex: number): unknown => {
+    const wrapper = inputs[inputIndex];
+
+    return wrapper == null ? wrapper : getHandle(wrapper);
+};
+
+const buildRefValue = (isInputConsumed: boolean, inputs: unknown[], inputIndex: number): Ref => ({
+    value: isInputConsumed ? inputs[inputIndex] : null,
+});
+
+const buildNativeValue = (spec: ArgSpec, inputs: unknown[]): unknown => {
+    const { arg, isRef, isCallerAllocated, consumesInput, inputIndex } = spec;
+
+    if (isCallerAllocated) {
+        return resolveCallerAllocated(inputs, inputIndex);
+    }
+
+    if (isRef) {
+        return buildRefValue(consumesInput, inputs, inputIndex);
+    }
+
+    if (arg.type.kind === "callback") {
+        return wrapCallbackValue(arg.type, inputs[inputIndex]);
+    }
+
+    return inputs[inputIndex];
+};
+
 const buildNativeValues = (plans: ArgSpec[], inputs: unknown[]): unknown[] =>
-    plans.map(({ arg, isRef, isCallerAllocated, consumesInput, inputIndex }) => {
-        if (isCallerAllocated) {
-            const wrapper = inputs[inputIndex];
-            return wrapper == null ? wrapper : getHandle(wrapper as object);
-        }
-        if (isRef) {
-            return { value: consumesInput ? inputs[inputIndex] : null };
-        }
-        if (arg.type.kind === "callback") {
-            return wrapCallbackValue(arg.type, inputs[inputIndex]);
-        }
-        return inputs[inputIndex];
-    });
+    plans.map((plan) => buildNativeValue(plan, inputs));
 
 const readOutParams = (plans: ArgSpec[], inputs: unknown[], nativeValues: unknown[]): unknown[] => {
     const outParams: unknown[] = [];
-    plans.forEach(({ arg, isCallerAllocated, inputIndex, isOutParam }, index) => {
-        if (!isOutParam) return;
+
+    for (const [index, { arg, isCallerAllocated, inputIndex, isOutParam }] of plans.entries()) {
+        if (!isOutParam) {
+            continue;
+        }
+
         outParams.push(
             isCallerAllocated ? inputs[inputIndex] : fromNative(arg.type, (nativeValues[index] as Ref).value),
         );
-    });
+    }
+
     return outParams;
 };
 
-export function fn(sharedLibrary: string, symbol: string, spec: FnSpec): (...inputs: unknown[]) => unknown {
+function fn(sharedLibrary: string, symbol: string, spec: FnSpec): (...inputs: unknown[]) => unknown {
     const { args, returns: returnDescriptor, throws = false } = spec;
     const nativeArgTypes = buildNativeArgTypes(args, throws);
     const nativeFn = bind(sharedLibrary, symbol, nativeArgTypes, returnDescriptor);
@@ -87,6 +113,7 @@ export function fn(sharedLibrary: string, symbol: string, spec: FnSpec): (...inp
 
     const shape = (inputs: unknown[], nativeValues: unknown[], nativeResult: unknown): unknown => {
         const primary = hasPrimary ? fromNative(returnDescriptor, nativeResult) : undefined;
+
         return packTupleResult(readOutParams(plans, inputs, nativeValues), primary, hasPrimary);
     };
 
@@ -97,12 +124,16 @@ export function fn(sharedLibrary: string, symbol: string, spec: FnSpec): (...inp
             nativeValues.push(errorRef);
             const nativeResult = nativeFn(...nativeValues);
             checkError(errorRef);
+
             return shape(inputs, nativeValues, nativeResult);
         };
     }
 
     return (...inputs) => {
         const nativeValues = buildNativeValues(plans, inputs);
+
         return shape(inputs, nativeValues, nativeFn(...nativeValues));
     };
 }
+
+export { fn };

package/src/index.ts

@@ -1,11 +1,12 @@
-export { alloc, type ExternalObject, type Handle, read, setWrapper, write } from "@gtkx/native";
+import "./exit-hook.js";
+
 export { createErrorDomain, type ErrorDomain } from "./error.js";
 export { type ApplicationLike, onExit, quit, quitApplication, runApplication } from "./lifecycle.js";
 export { offSignal, onceSignal, onSignal } from "./listeners.js";
 export { installMixins, type Mixin } from "./mixin.js";
 export { fromNative } from "./native-value.js";
 export { getObjectProperty, newObjectWithProperties, setObjectProperty } from "./object.js";
-export { promisify } from "./promisify.js";
+export { type FinishResult, promisify } from "./promisify.js";
 export { registerClass } from "./register-class.js";
 export {
     getHandle,
@@ -55,3 +56,4 @@ export {
     valueIsA,
 } from "./type.js";
 export { getBoxedValue, setBoxedValue } from "./value.js";
+export { alloc, type ExternalObject, type Handle, read, setWrapper, write } from "@gtkx/native";

package/src/library.ts

@@ -1,15 +1,17 @@
 import { type BoxedDescriptor, boxedT, type FundamentalDescriptor, fundamentalT } from "./descriptors.js";
 
-export const LIB = "libgobject-2.0.so.0,libglib-2.0.so.0";
-export const VALUE_SIZE = 24;
-export const VALUE_T: BoxedDescriptor = boxedT("GValue", { sharedLibrary: LIB, getTypeFnName: "g_value_get_type" });
+const LIB = "libgobject-2.0.so.0,libglib-2.0.so.0";
+const VALUE_SIZE = 24;
+const VALUE_T: BoxedDescriptor = boxedT("GValue", { sharedLibrary: LIB, getTypeFnName: "g_value_get_type" });
 
-export const PARAM_T: FundamentalDescriptor = fundamentalT(LIB, "g_param_spec_ref", "g_param_spec_unref", {
+const PARAM_T: FundamentalDescriptor = fundamentalT(LIB, "g_param_spec_ref", "g_param_spec_unref", {
     ownership: "borrowed",
     typeName: "GParam",
 });
 
-export const VARIANT_T: FundamentalDescriptor = fundamentalT(LIB, "g_variant_ref", "g_variant_unref", {
+const VARIANT_T: FundamentalDescriptor = fundamentalT(LIB, "g_variant_ref", "g_variant_unref", {
     ownership: "borrowed",
     typeName: "GVariant",
 });
+
+export { LIB, VALUE_SIZE, VALUE_T, PARAM_T, VARIANT_T };

package/src/lifecycle.ts

@@ -5,7 +5,7 @@ import { blockMatchedSignalHandlers } from "./signal.js";
  * Minimal structural interface of a GTK4/GIO application needed to register, run,
  * and shut it down, plus the signals its lifecycle helpers connect to.
  */
-export type ApplicationLike = {
+type ApplicationLike = {
     getIsRegistered(): boolean;
     register(cancellable: null): boolean;
     activate(): void;
@@ -17,7 +17,29 @@ export type ApplicationLike = {
 };
 
 const shutdownCallbacks: (() => void)[] = [];
-let hasQuit = false;
+/**
+ * Runs every registered exit callback and shuts down the native runtime. Safe to
+ * call more than once; only the first call takes effect.
+ */
+const quit: () => void = createQuit();
+
+function createQuit(): () => void {
+    let hasQuit = false;
+
+    return () => {
+        if (hasQuit) {
+            return;
+        }
+
+        hasQuit = true;
+
+        for (const callback of shutdownCallbacks) {
+            callback();
+        }
+
+        nativeQuit();
+    };
+}
 
 /**
  * Registers a callback to run once when the process quits, before the native
@@ -25,36 +47,29 @@ let hasQuit = false;
  *
  * @param callback Invoked during shutdown.
  */
-export const onExit = (callback: () => void): void => {
+const onExit = (callback: () => void): void => {
     shutdownCallbacks.push(callback);
 };
 
-/**
- * Runs every registered exit callback and shuts down the native runtime. Safe to
- * call more than once; only the first call takes effect.
- */
-export const quit = (): void => {
-    if (hasQuit) return;
-    hasQuit = true;
-
-    for (const callback of shutdownCallbacks) callback();
-
-    nativeQuit();
-};
-
-process.on("exit", quit);
-
 /**
  * Registers the application if needed and activates it, keeping the runtime alive
  * while it is active and releasing it on shutdown.
  *
  * @param application The application to register and activate.
  */
-export const runApplication = (application: ApplicationLike): void => {
-    application.on("activate", () => keepAlive(true));
-    application.on("shutdown", () => keepAlive(false));
+const runApplication = (application: ApplicationLike): void => {
+    application.on("activate", () => {
+        keepAlive(true);
+    });
+
+    application.on("shutdown", () => {
+        keepAlive(false);
+    });
+
+    if (!application.getIsRegistered()) {
+        application.register(null);
+    }
 
-    if (!application.getIsRegistered()) application.register(null);
     application.activate();
 };
 
@@ -64,10 +79,23 @@ export const runApplication = (application: ApplicationLike): void => {
  *
  * @param application The application to shut down.
  */
-export const quitApplication = (application: ApplicationLike): void => {
-    if (!application.getIsRegistered()) return;
-    for (const window of application.getWindows?.() ?? []) application.removeWindow?.(window);
-    application.on("shutdown", () => application.quit());
+const quitApplication = (application: ApplicationLike): void => {
+    if (!application.getIsRegistered()) {
+        return;
+    }
+
+    const windows = application.getWindows?.() ?? [];
+
+    for (const window of windows) {
+        application.removeWindow?.(window);
+    }
+
+    application.on("shutdown", () => {
+        application.quit();
+    });
+
     blockMatchedSignalHandlers(application, "activate");
     application.run([]);
 };
+
+export { onExit, quit, runApplication, quitApplication, type ApplicationLike };

package/src/listeners.ts

@@ -1,34 +1,50 @@
-import type { SignalHandler } from "./signal.js";
+import { isSignalHandlerConnected, type SignalHandler } from "./signal.js";
 
 type SignalConnectable = {
-    connect(signal: string, handler: SignalHandler, after?: boolean): number;
+    connect(signal: string, handler: SignalHandler, isAfter?: boolean): number;
     disconnect(handlerId: number): void;
 };
 
-const listenerTable = new WeakMap<object, Map<string, Map<SignalHandler, number>>>();
+const listenerTable: WeakMap<object, Map<string, Map<SignalHandler, number>>> = new WeakMap();
 
 const findListenerHandlerId = (instance: object, signal: string, handler: SignalHandler): number | undefined =>
     listenerTable.get(instance)?.get(signal)?.get(handler);
 
 const trackListener = (instance: object, signal: string, handler: SignalHandler, handlerId: number): void => {
     let bySignal = listenerTable.get(instance);
+
     if (!bySignal) {
         bySignal = new Map();
         listenerTable.set(instance, bySignal);
     }
+
     let byHandler = bySignal.get(signal);
+
     if (!byHandler) {
         byHandler = new Map();
         bySignal.set(signal, byHandler);
     }
+
     byHandler.set(handler, handlerId);
 };
 
-const untrackListener = (instance: object, signal: string, handler: SignalHandler): void => {
+const untrackHandlerId = (instance: object, signal: string, handlerId: number): void => {
     const bySignal = listenerTable.get(instance);
     const byHandler = bySignal?.get(signal);
-    byHandler?.delete(handler);
-    if (byHandler?.size === 0) bySignal?.delete(signal);
+
+    if (byHandler === undefined) {
+        return;
+    }
+
+    for (const [handler, id] of byHandler) {
+        if (id === handlerId) {
+            byHandler.delete(handler);
+        }
+    }
+
+    if (byHandler.size === 0) {
+        bySignal?.delete(signal);
+    }
 };
 
 /**
@@ -38,10 +54,10 @@ const untrackListener = (instance: object, signal: string, handler: SignalHandle
  * @param instance The object emitting the signal.
  * @param signal The signal name to connect to.
  * @param handler The callback invoked on each emission.
- * @param after When true, run the handler after the default handler.
+ * @param isAfter When true, run the handler after the default handler.
  */
-export function onSignal(instance: SignalConnectable, signal: string, handler: SignalHandler, after?: boolean): void {
-    const handlerId = instance.connect(signal, handler, after);
+function onSignal(instance: SignalConnectable, signal: string, handler: SignalHandler, isAfter?: boolean): void {
+    const handlerId = instance.connect(signal, handler, isAfter);
     trackListener(instance, signal, handler, handlerId);
 }
 
@@ -52,17 +68,19 @@ export function onSignal(instance: SignalConnectable, signal: string, handler: S
  * @param instance The object emitting the signal.
  * @param signal The signal name to connect to.
  * @param handler The callback invoked on the first emission.
- * @param after When true, run the handler after the default handler.
+ * @param isAfter When true, run the handler after the default handler.
  */
-export function onceSignal(instance: SignalConnectable, signal: string, handler: SignalHandler, after?: boolean): void {
+function onceSignal(instance: SignalConnectable, signal: string, handler: SignalHandler, isAfter?: boolean): void {
     let handlerId = 0;
+
     const wrapped: SignalHandler = (...args) => {
-        untrackListener(instance, signal, wrapped);
-        untrackListener(instance, signal, handler);
+        untrackHandlerId(instance, signal, handlerId);
         instance.disconnect(handlerId);
+
         return handler(...args);
     };
-    handlerId = instance.connect(signal, wrapped, after);
+
+    handlerId = instance.connect(signal, wrapped, isAfter);
     trackListener(instance, signal, wrapped, handlerId);
     trackListener(instance, signal, handler, handlerId);
 }
@@ -75,10 +93,20 @@ export function onceSignal(instance: SignalConnectable, signal: string, handler:
  * @param signal The signal name the handler was connected to.
  * @param handler The handler to disconnect.
  */
-export function offSignal(instance: SignalConnectable, signal: string, handler: SignalHandler): void {
+function offSignal(instance: SignalConnectable, signal: string, handler: SignalHandler): void {
     const handlerId = findListenerHandlerId(instance, signal, handler);
-    if (handlerId !== undefined) {
-        instance.disconnect(handlerId);
-        untrackListener(instance, signal, handler);
+
+    if (handlerId === undefined) {
+        return;
     }
+
+    untrackHandlerId(instance, signal, handlerId);
+
+    if (!isSignalHandlerConnected(instance, handlerId)) {
+        return;
+    }
+
+    instance.disconnect(handlerId);
 }
+
+export { onSignal, onceSignal, offSignal };

package/src/mixin.ts

@@ -1,7 +1,7 @@
 import type { AnyClass } from "@gtkx/utils";
 
-export type MixinReceiver = {
-    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
+type MixinReceiver = {
+    connect(signal: string, handler: (...args: unknown[]) => unknown, isAfter?: boolean): number;
     emit(signal: string, ...args: unknown[]): unknown;
 };
 
@@ -9,17 +9,38 @@ export type MixinReceiver = {
  * A factory that, given a base class, returns a subclass adding extra members to
  * be merged onto a target prototype.
  */
-export type Mixin = (base: AnyClass<MixinReceiver>) => AnyClass;
+type Mixin = (base: AnyClass<MixinReceiver>) => AnyClass;
 
-function definedInClassChain(prototype: object, key: string): boolean {
+function isDefinedInClassChain(prototype: object, key: string): boolean {
     let current: object | null = prototype;
+
     while (current !== null && current !== Object.prototype) {
-        if (Object.hasOwn(current, key)) return true;
-        current = Object.getPrototypeOf(current);
+        if (Object.hasOwn(current, key)) {
+            return true;
+        }
+
+        current = Reflect.getPrototypeOf(current);
     }
+
     return false;
 }
 
+function copyLayerMember(target: AnyClass, layer: object, key: string): void {
+    if (key === "constructor") {
+        return;
+    }
+
+    if (isDefinedInClassChain(target.prototype, key)) {
+        return;
+    }
+
+    const descriptor = Object.getOwnPropertyDescriptor(layer, key);
+
+    if (descriptor !== undefined) {
+        Object.defineProperty(target.prototype, key, descriptor);
+    }
+}
+
 /**
  * Copies each mixin's prototype members onto the target class prototype, skipping
  * any member already defined anywhere in the target's class chain.
@@ -27,22 +48,26 @@ function definedInClassChain(prototype: object, key: string): boolean {
  * @param target The class whose prototype receives the mixin members.
  * @param mixins The mixins to apply, in order.
  */
-export function installMixins(target: AnyClass, mixins: Mixin[]): void {
+function copyLayerMembers(target: AnyClass, layer: object): void {
+    for (const key of Object.getOwnPropertyNames(layer)) {
+        copyLayerMember(target, layer, key);
+    }
+}
+
+function installMixins(target: AnyClass, mixins: Mixin[]): void {
     const empty: AnyClass<MixinReceiver> = class {
         connect(): number {
             return 0;
         }
+
         emit(): unknown {
             return undefined;
         }
     };
+
     for (const mixin of mixins) {
-        const layer: object = mixin(empty).prototype;
-        for (const key of Object.getOwnPropertyNames(layer)) {
-            if (key === "constructor") continue;
-            if (definedInClassChain(target.prototype, key)) continue;
-            const descriptor = Object.getOwnPropertyDescriptor(layer, key);
-            if (descriptor !== undefined) Object.defineProperty(target.prototype, key, descriptor);
-        }
+        copyLayerMembers(target, mixin(empty).prototype);
     }
 }
+
+export { installMixins, type MixinReceiver, type Mixin };

package/src/native-value.ts

@@ -1,12 +1,65 @@
 import type { Descriptor, ExternalObject, Handle } from "@gtkx/native";
-import type { ArrayDescriptor, FundamentalDescriptor, StructDescriptor } from "./descriptors.js";
+import type { ArrayDescriptor, FundamentalDescriptor, HashTableDescriptor, StructDescriptor } from "./descriptors.js";
 import { getWrapperClass, tryGetHandle, wrapHandle } from "./registry.js";
 import { resolveDescriptorType } from "./type.js";
 
-const collectionFromNative = (descriptor: ArrayDescriptor, value: unknown): unknown => {
-    if (value === null) return null;
-    return (value as unknown[]).map((item) => fromNative(descriptor.itemDescriptor, item));
-};
+type MarshalledKind = "object" | "struct" | "boxed" | "fundamental" | "array" | "hashtable";
+type MarshalledDescriptor = Extract<Descriptor, { kind: MarshalledKind }>;
+
+const MARSHALLED_KINDS: Set<Descriptor["kind"]> = new Set<MarshalledKind>([
+    "object",
+    "struct",
+    "boxed",
+    "fundamental",
+    "array",
+    "hashtable",
+]);
+
+function isMarshalledDescriptor(descriptor: Descriptor): descriptor is MarshalledDescriptor {
+    return MARSHALLED_KINDS.has(descriptor.kind);
+}
+
+function mapCollection(
+    descriptor: ArrayDescriptor,
+    value: unknown,
+    convert: (itemDescriptor: Descriptor, item: unknown) => unknown,
+): unknown[] {
+    return (value as unknown[]).map((item) => convert(descriptor.itemDescriptor, item));
+}
+
+function collectionFromNative(descriptor: ArrayDescriptor, value: unknown): unknown {
+    return value === null ? null : mapCollection(descriptor, value, fromNative);
+}
+
+function boxedFromNative(descriptor: Descriptor, value: unknown): unknown {
+    return value == null
+        ? null
+        : wrapHandle(value as ExternalObject<Handle>, getWrapperClass(resolveDescriptorType(descriptor)));
+}
+
+function fundamentalFromNative(descriptor: FundamentalDescriptor, value: unknown): unknown {
+    return value == null
+        ? null
+        : wrapHandle(
+                value as ExternalObject<Handle>,
+                descriptor.wrapperClass ?? getWrapperClass(resolveDescriptorType(descriptor)),
+            );
+}
+
+function hashTableFromNative(descriptor: HashTableDescriptor, value: unknown): unknown {
+    if (value === null) {
+        return null;
+    }
+
+    const entries = value as [unknown, unknown][];
+
+    return new Map(
+        entries.map(([key, val]): [unknown, unknown] => [
+            fromNative(descriptor.keyDescriptor, key),
+            fromNative(descriptor.valueDescriptor, val),
+        ]),
+    );
+}
 
 /**
  * Converts a raw value returned from native code into its JavaScript form,
@@ -16,63 +69,67 @@ const collectionFromNative = (descriptor: ArrayDescriptor, value: unknown): unkn
  * @param descriptor Describes the native type of the value.
  * @param value The raw native value to convert.
  */
-export function fromNative(descriptor: Descriptor, value: unknown): unknown {
+function fromNative(descriptor: Descriptor, value: unknown): unknown {
+    if (!isMarshalledDescriptor(descriptor)) {
+        return value;
+    }
+
     switch (descriptor.kind) {
-        case "object":
-            return wrapHandle(value as ExternalObject<Handle> | null, undefined);
-        case "struct":
+        case "object": {
+            return wrapHandle(value as ExternalObject<Handle> | null);
+        }
+        case "struct": {
             return wrapHandle(value as ExternalObject<Handle> | null, (descriptor as StructDescriptor).wrapperClass);
-        case "boxed":
-            return value == null
-                ? null
-                : wrapHandle(value as ExternalObject<Handle>, getWrapperClass(resolveDescriptorType(descriptor)));
-        case "fundamental":
-            return value == null
-                ? null
-                : wrapHandle(
-                      value as ExternalObject<Handle>,
-                      (descriptor as FundamentalDescriptor).wrapperClass ??
-                          getWrapperClass(resolveDescriptorType(descriptor)),
-                  );
-        case "array":
+        }
+        case "boxed": {
+            return boxedFromNative(descriptor, value);
+        }
+        case "fundamental": {
+            return fundamentalFromNative(descriptor, value);
+        }
+        case "array": {
             return collectionFromNative(descriptor, value);
+        }
         case "hashtable": {
-            if (value === null) return null;
-            const entries = value as [unknown, unknown][];
-            return new Map(
-                entries.map(([key, val]): [unknown, unknown] => [
-                    fromNative(descriptor.keyDescriptor, key),
-                    fromNative(descriptor.valueDescriptor, val),
-                ]),
-            );
+            return hashTableFromNative(descriptor, value);
         }
-        default:
-            return value;
     }
 }
 
-const collectionToNative = (descriptor: ArrayDescriptor, value: unknown): unknown => {
-    if (value == null) return null;
-    return (value as unknown[]).map((item) => toNative(descriptor.itemDescriptor, item));
-};
+function collectionToNative(descriptor: ArrayDescriptor, value: unknown): unknown {
+    return value == null ? null : mapCollection(descriptor, value, toNative);
+}
+
+function hashTableToNative(descriptor: HashTableDescriptor, value: unknown): unknown {
+    if (value == null) {
+        return null;
+    }
+
+    return [...(value as Map<unknown, unknown>)].map(([key, val]): [unknown, unknown] => [
+        toNative(descriptor.keyDescriptor, key),
+        toNative(descriptor.valueDescriptor, val),
+    ]);
+}
+
+function toNative(descriptor: Descriptor, value: unknown): unknown {
+    if (!isMarshalledDescriptor(descriptor)) {
+        return value;
+    }
 
-export function toNative(descriptor: Descriptor, value: unknown): unknown {
     switch (descriptor.kind) {
         case "object":
         case "struct":
         case "boxed":
-        case "fundamental":
+        case "fundamental": {
             return tryGetHandle(value as object | null | undefined) ?? null;
-        case "array":
+        }
+        case "array": {
             return collectionToNative(descriptor, value);
+        }
         case "hashtable": {
-            if (value == null) return null;
-            return [...(value as Map<unknown, unknown>)].map(([key, val]): [unknown, unknown] => [
-                toNative(descriptor.keyDescriptor, key),
-                toNative(descriptor.valueDescriptor, val),
-            ]);
+            return hashTableToNative(descriptor, value);
         }
-        default:
-            return value;
     }
 }
+
+export { fromNative, toNative };