@gtkx/runtime 1.2.1 → 1.3.0

package/dist/variant.d.ts

@@ -1,6 +1,6 @@
 import * as GLib from "@gtkx/gi/glib";
-/** JavaScript type every GVariant basic type code unpacks to. */
-type BasicValueMap = {
+/** JavaScript type every GVariant basic type code unpacks to, with a nested variant held as `Nested`. */
+type BasicValueMap<Nested> = {
     /** Boolean, held as a single byte reading 0 or 1. */
     b: boolean;
     /** Unsigned byte. */
@@ -28,58 +28,107 @@ type BasicValueMap = {
     /** GVariant type signature. */
     g: string;
     /** Boxed variant holding a value of any type. */
-    v: GLib.Variant;
+    v: Nested;
 };
 /** Single-character code of one of the GVariant basic types in {@link BasicValueMap}. */
-type BasicCode = keyof BasicValueMap;
-/** Parses the element type of an array, yielding the array type it produces and the rest of the string. */
-type ParseArray<S extends string> = Parse<S> extends [infer V, infer R extends string] ? [V[], R] : never;
+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.
+ */
+type ByteArray = ReturnType<GLib.Bytes["unrefToArray"]>;
+/** Values a byte array (`ay`) packs from. */
+type ByteArrayInput = Uint8Array | number[];
+/**
+ * Parses the element type of an array, yielding the array type it produces and the rest of the string. An array of
+ * bytes yields the byte array type instead of `number[]`.
+ */
+type ParseArray<S extends string, Bytes, Nested> = S extends `y${infer Rest}` ? [Bytes, Rest] : Parse<S, Bytes, Nested> extends [infer V, infer R extends string] ? [V[], R] : never;
 /** Parses the element type of a maybe, yielding the nullable type it produces and the rest of the string. */
-type ParseMaybe<S extends string> = Parse<S> extends [infer V, infer R extends string] ? [V | null, R] : never;
+type ParseMaybe<S extends string, Bytes, Nested> = Parse<S, Bytes, Nested> extends [infer V, infer R extends string] ? [V | null, R] : never;
 /** Collects tuple member types into `Acc` up to the closing parenthesis, yielding them and the rest of the string. */
-type ParseTuple<S extends string, Acc extends unknown[]> = S extends `)${infer Rest}` ? [Acc, Rest] : [Parse<S>] extends [never] ? never : Parse<S> extends [infer V, infer R extends string] ? ParseTuple<R, [...Acc, V]> : never;
+type ParseTuple<S extends string, Bytes, Nested, Acc extends unknown[]> = S extends `)${infer Rest}` ? [Acc, Rest] : [Parse<S, Bytes, Nested>] extends [never] ? never : Parse<S, Bytes, Nested> extends [infer V, infer R extends string] ? ParseTuple<R, Bytes, Nested, [...Acc, V]> : never;
 /** Types a dictionary entry key can hold. */
 type DictKey = string | number | bigint | boolean;
 /** Parses the key and value types of a dictionary entry, yielding them and the rest of the string after its brace. */
-type ParsePair<S extends string> = Parse<S> extends [infer K, infer R1 extends string] ? Parse<R1> extends [infer V, infer R2 extends string] ? R2 extends `}${infer R3}` ? [K] extends [DictKey] ? [K, V, R3] : never : never : never : never;
+type ParsePair<S extends string, Bytes, Nested> = Parse<S, Bytes, Nested> extends [infer K, infer R1 extends string] ? Parse<R1, Bytes, Nested> extends [infer V, infer R2 extends string] ? R2 extends `}${infer R3}` ? [K] extends [DictKey] ? [K, V, R3] : never : never : never : never;
 /**
  * Parses a dictionary entry into the collection an array of those entries unpacks to, a record for string keys and a
  * `Map` otherwise, plus the rest of the string.
  */
-type ParseDict<S extends string> = ParsePair<S> extends [infer K, infer V, infer R extends string] ? [[K] extends [string] ? Record<string, V> : Map<K, V>, R] : never;
+type ParseDict<S extends string, Bytes, Nested> = ParsePair<S, Bytes, Nested> extends [infer K, infer V, infer R extends string] ? [[K] extends [string] ? Record<string, V> : Map<K, V>, R] : never;
 /** Parses a standalone dictionary entry into a key and value pair, yielding it and the rest of the string. */
-type ParseEntry<S extends string> = ParsePair<S> extends [infer K, infer V, infer R extends string] ? [[K, V], R] : never;
+type ParseEntry<S extends string, Bytes, Nested> = ParsePair<S, Bytes, Nested> extends [infer K, infer V, infer R extends string] ? [[K, V], R] : never;
 /** Parses what follows an `a` as a dictionary when it opens an entry, and as a plain array otherwise. */
-type ParseArrayOrDict<S extends string> = S extends `{${infer Rest}` ? ParseDict<Rest> : ParseArray<S>;
+type ParseArrayOrDict<S extends string, Bytes, Nested> = S extends `{${infer Rest}` ? ParseDict<Rest, Bytes, Nested> : ParseArray<S, Bytes, Nested>;
 /**
  * Parses the type at the head of `S`, yielding the JavaScript type it unpacks to and the rest of the string, or
  * `never` when the string is malformed.
  */
-type Parse<S extends string> = S extends `a${infer Rest}` ? ParseArrayOrDict<Rest> : S extends `m${infer Rest}` ? ParseMaybe<Rest> : S extends `(${infer Rest}` ? ParseTuple<Rest, []> : S extends `{${infer Rest}` ? ParseEntry<Rest> : S extends `${infer C}${infer Rest}` ? C extends BasicCode ? [BasicValueMap[C], Rest] : never : never;
-/** JavaScript type a variant of type string `S` unpacks to, or `unknown` when `S` is not one complete type. */
-type VariantValue<S extends string> = [Parse<S>] extends [never] ? unknown : Parse<S> extends [infer V, ""] ? V : unknown;
+type Parse<S extends string, Bytes, Nested> = S extends `a${infer Rest}` ? ParseArrayOrDict<Rest, Bytes, Nested> : S extends `m${infer Rest}` ? ParseMaybe<Rest, Bytes, Nested> : S extends `(${infer Rest}` ? ParseTuple<Rest, Bytes, Nested, []> : S extends `{${infer Rest}` ? ParseEntry<Rest, Bytes, Nested> : S extends `${infer C}${infer Rest}` ? C extends BasicCode ? [BasicValueMap<Nested>[C], Rest] : never : never;
+/** JavaScript type a type string `S` describes, or `unknown` when `S` is not one complete type. */
+type ParsedValue<S extends string, Bytes, Nested> = [Parse<S, Bytes, Nested>] extends [never] ? unknown : Parse<S, Bytes, Nested> extends [infer V, ""] ? V : unknown;
+/**
+ * JavaScript type a variant of type string `S` unpacks to, or `unknown` when `S` is not one complete type. A byte
+ * array (`ay`) unpacks to {@link ByteArray} and a nested variant (`v`) to the `GLib.Variant` itself.
+ */
+type VariantValue<S extends string> = ParsedValue<S, ByteArray, GLib.Variant>;
+/**
+ * JavaScript type {@link toVariant} packs into a variant of type string `S`, or `unknown` when `S` is not one
+ * complete type. The same as {@link VariantValue}, except that a byte array (`ay`) also packs from a `number[]`.
+ */
+type VariantInput<S extends string> = ParsedValue<S, ByteArrayInput, GLib.Variant>;
+/**
+ * JavaScript type a variant of type string `S` unpacks to when every nested variant is unwrapped as well, so a `v`
+ * reads as `unknown`.
+ */
+type RecursiveVariantValue<S extends string> = ParsedValue<S, ByteArray, unknown>;
+/** Options {@link fromVariant} reads. */
+type FromVariantOptions = {
+    /**
+     * Whether to unwrap every nested variant (`v`) into the value it holds, all the way down, instead of handing back
+     * the `GLib.Variant` itself. Discards the type information those variants carry.
+     */
+    recursive?: boolean;
+};
+/** {@link FromVariantOptions} with recursive unwrapping selected, typing the result accordingly. */
+type RecursiveFromVariantOptions = {
+    /** Unwraps every nested variant (`v`) into the value it holds, all the way down. */
+    recursive: true;
+};
 /**
  * Packs a JavaScript value into the `GLib.Variant` a GVariant type string describes, building the
  * nested arrays, dictionaries, tuples and maybes the type calls for. A type string given as a
  * literal also types `value`, so `"as"` takes an array of strings, `"a{sv}"` a record of variants,
- * `"(si)"` a string and a number pair, and a 64-bit type a `bigint`.
+ * `"(si)"` a string and a number pair, a 64-bit type a `bigint`, and `"ay"` a `Uint8Array` or an
+ * array of byte values.
  * @param typeString GVariant type of the variant to build, such as `"a{sv}"`.
  * @param value Value to pack, shaped the way `typeString` describes.
  * @returns The packed variant.
- * @throws {Error} When the type string is not one complete GVariant type, or when a value packed as
- * an object path or a type signature is not a valid one.
+ * @throws {Error} When the type string is not one complete GVariant type, when a value packed as
+ * an object path or a type signature is not a valid one, or when a byte array is packed from
+ * anything but a `Uint8Array` or an array of byte values.
  */
-declare const toVariant: <S extends string>(typeString: S, value: VariantValue<S>) => GLib.Variant;
+declare const toVariant: <S extends string>(typeString: S, value: VariantInput<S>) => GLib.Variant;
 /**
- * Unpacks a `GLib.Variant` into the JavaScript value a GVariant type string 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 tuple to an array of its members, a maybe to its value or
- * `null`, and a nested variant to the `GLib.Variant` itself.
+ * 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
+ * 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.
+ *
+ * The type string is optional: without one the variant's own type is read, and the result is
+ * `unknown`. With one given as a literal, the result is typed from it.
  * @param typeString GVariant type the variant holds, such as `"a{sv}"`.
  * @param variant Variant to read, which has to hold that type.
- * @returns The unpacked value, typed from `typeString` when it is given as a literal.
+ * @param options Whether to unwrap nested variants recursively.
+ * @returns The unpacked value.
  * @throws {Error} When the type string is not one complete GVariant type.
  */
-declare const fromVariant: <S extends string>(typeString: S, variant: GLib.Variant) => VariantValue<S>;
-export { fromVariant, toVariant, type VariantValue };
+declare function fromVariant<S extends string>(typeString: S, variant: GLib.Variant): VariantValue<S>;
+declare function fromVariant<S extends string>(typeString: S, variant: GLib.Variant, options: RecursiveFromVariantOptions): RecursiveVariantValue<S>;
+declare function fromVariant<S extends string>(typeString: S, variant: GLib.Variant, options: FromVariantOptions): VariantValue<S> | RecursiveVariantValue<S>;
+declare function fromVariant(variant: GLib.Variant, options?: FromVariantOptions): unknown;
+export { type ByteArray, type FromVariantOptions, fromVariant, type RecursiveFromVariantOptions, type RecursiveVariantValue, toVariant, type VariantInput, type VariantValue, };
 //# sourceMappingURL=variant.d.ts.map

package/dist/variant.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"variant.d.ts","sourceRoot":"","sources":["../src/variant.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,eAAe,CAAC;AAEtC,iEAAiE;AACjE,KAAK,aAAa,GAAG;IACjB,qDAAqD;IACrD,CAAC,EAAE,OAAO,CAAC;IACX,qBAAqB;IACrB,CAAC,EAAE,MAAM,CAAC;IACV,6BAA6B;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,+BAA+B;IAC/B,CAAC,EAAE,MAAM,CAAC;IACV,6BAA6B;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,+BAA+B;IAC/B,CAAC,EAAE,MAAM,CAAC;IACV,6DAA6D;IAC7D,CAAC,EAAE,MAAM,CAAC;IACV,8CAA8C;IAC9C,CAAC,EAAE,MAAM,CAAC;IACV,6BAA6B;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,+BAA+B;IAC/B,CAAC,EAAE,MAAM,CAAC;IACV,kEAAkE;IAClE,CAAC,EAAE,MAAM,CAAC;IACV,yBAAyB;IACzB,CAAC,EAAE,MAAM,CAAC;IACV,+BAA+B;IAC/B,CAAC,EAAE,MAAM,CAAC;IACV,iDAAiD;IACjD,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC;CACnB,CAAC;AAEF,yFAAyF;AACzF,KAAK,SAAS,GAAG,MAAM,aAAa,CAAC;AACrC,2GAA2G;AAC3G,KAAK,UAAU,CAAC,CAAC,SAAS,MAAM,IAAI,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,SAAS,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC;AAC1G,6GAA6G;AAC7G,KAAK,UAAU,CAAC,CAAC,SAAS,MAAM,IAAI,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,SAAS,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC;AAE/G,sHAAsH;AACtH,KAAK,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,SAAS,OAAO,EAAE,IAAI,CAAC,SAAS,IAAI,MAAM,IAAI,EAAE,GAC/E,CAAC,GAAG,EAAE,IAAI,CAAC,GACX,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAClB,KAAK,GACL,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,SAAS,MAAM,CAAC,GAC9C,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,GAC1B,KAAK,CAAC;AAExB,6CAA6C;AAC7C,KAAK,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAElD,sHAAsH;AACtH,KAAK,SAAS,CAAC,CAAC,SAAS,MAAM,IAC3B,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,SAAS,MAAM,CAAC,GAC7C,KAAK,CAAC,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,SAAS,MAAM,CAAC,GAChD,EAAE,SAAS,IAAI,MAAM,EAAE,EAAE,GACrB,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,GACb,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,GACV,KAAK,GACb,KAAK,GACT,KAAK,GACT,KAAK,CAAC;AAEhB;;;GAGG;AACH,KAAK,SAAS,CAAC,CAAC,SAAS,MAAM,IAC3B,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,SAAS,MAAM,CAAC,GACzD,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,GACzD,KAAK,CAAC;AAEhB,8GAA8G;AAC9G,KAAK,UAAU,CAAC,CAAC,SAAS,MAAM,IAC5B,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,SAAS,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC;AAE1F,yGAAyG;AACzG,KAAK,gBAAgB,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,IAAI,MAAM,IAAI,EAAE,GAAG,SAAS,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;AAEvG;;;GAGG;AACH,KAAK,KAAK,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,IAAI,MAAM,IAAI,EAAE,GACnD,gBAAgB,CAAC,IAAI,CAAC,GACtB,CAAC,SAAS,IAAI,MAAM,IAAI,EAAE,GACtB,UAAU,CAAC,IAAI,CAAC,GAChB,CAAC,SAAS,IAAI,MAAM,IAAI,EAAE,GACtB,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC,GACpB,CAAC,SAAS,IAAI,MAAM,IAAI,EAAE,GACtB,UAAU,CAAC,IAAI,CAAC,GAChB,CAAC,SAAS,GAAG,MAAM,CAAC,GAAG,MAAM,IAAI,EAAE,GAC/B,CAAC,SAAS,SAAS,GACf,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,GACxB,KAAK,GACT,KAAK,CAAC;AAE5B,+GAA+G;AAC/G,KAAK,YAAY,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAC1D,OAAO,GACP,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,GAC1B,CAAC,GACD,OAAO,CAAC;AAuSlB;;;;;;;;;;GAUG;AACH,QAAA,MAAM,SAAS,GAAI,CAAC,SAAS,MAAM,EAAE,YAAY,CAAC,EAAE,OAAO,YAAY,CAAC,CAAC,CAAC,KAAG,IAAI,CAAC,OACjC,CAAC;AAElD;;;;;;;;;GASG;AACH,QAAA,MAAM,WAAW,GAAI,CAAC,SAAS,MAAM,EAAE,YAAY,CAAC,EAAE,SAAS,IAAI,CAAC,OAAO,KAAG,YAAY,CAAC,CAAC,CACpB,CAAC;AAEzE,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,KAAK,YAAY,EAAE,CAAC"}
+{"version":3,"file":"variant.d.ts","sourceRoot":"","sources":["../src/variant.ts"],"names":[],"mappings":"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"}

package/dist/variant.js

@@ -8,6 +8,7 @@ const CONTAINER_PARSERS = {
     "{": parseEntryNode,
 };
 const parsedTypes = new Map();
+const BYTE_ARRAY_TYPE_STRING = "ay";
 const unpackBasic = {
     b: (variant) => variant.getBoolean(),
     y: (variant) => variant.getByte(),
@@ -109,6 +110,7 @@ const parseVariantType = (typeString) => {
     parsedTypes.set(typeString, node);
     return node;
 };
+const isByteArray = (node) => node.kind === "array" && node.element.kind === "basic" && node.element.code === "y";
 const unpackChildren = (variant, unpackChild) => {
     const children = [];
     const count = variant.nChildren();
@@ -117,41 +119,47 @@ const unpackChildren = (variant, unpackChild) => {
     }
     return children;
 };
-const unpackPair = (key, value, entry) => [
-    unpackNode(key, entry.getChildValue(0)),
-    unpackNode(value, entry.getChildValue(1)),
+const unpackPair = (key, value, entry, isRecursive) => [
+    unpackNode(key, entry.getChildValue(0), isRecursive),
+    unpackNode(value, entry.getChildValue(1), isRecursive),
 ];
-const unpackDict = (node, variant) => {
-    const entries = unpackChildren(variant, (entry) => unpackPair(node.key, node.value, entry));
+const unpackDict = (node, variant, isRecursive) => {
+    const entries = unpackChildren(variant, (entry) => unpackPair(node.key, node.value, entry, isRecursive));
     if (!isStringKeyed(node.key)) {
         return new Map(entries);
     }
     const stringEntries = entries.map(([key, value]) => [key, value]);
     return Object.fromEntries(stringEntries);
 };
-const unpackMaybe = (element, variant) => {
+const unpackMaybe = (element, variant, isRecursive) => {
     const child = variant.getMaybe();
-    return child === null ? null : unpackNode(element, child);
+    return child === null ? null : unpackNode(element, child, isRecursive);
 };
-const unpackNode = (node, variant) => {
+const unpackNested = (variant, isRecursive) => {
+    const held = variant.getVariant();
+    return isRecursive ? unpackNode(parseVariantType(held.getTypeString()), held, true) : held;
+};
+const unpackNode = (node, variant, isRecursive) => {
     switch (node.kind) {
         case "basic": {
-            return unpackBasic[node.code](variant);
+            return node.code === "v" ? unpackNested(variant, isRecursive) : unpackBasic[node.code](variant);
         }
         case "array": {
-            return unpackChildren(variant, (child) => unpackNode(node.element, child));
+            return isByteArray(node)
+                ? variant.getDataAsBytes().unrefToArray()
+                : unpackChildren(variant, (child) => unpackNode(node.element, child, isRecursive));
         }
         case "dict": {
-            return unpackDict(node, variant);
+            return unpackDict(node, variant, isRecursive);
         }
         case "entry": {
-            return unpackPair(node.key, node.value, variant);
+            return unpackPair(node.key, node.value, variant, isRecursive);
         }
         case "tuple": {
-            return node.items.map((item, index) => unpackNode(item, variant.getChildValue(index)));
+            return node.items.map((item, index) => unpackNode(item, variant.getChildValue(index), isRecursive));
         }
         case "maybe": {
-            return unpackMaybe(node.element, variant);
+            return unpackMaybe(node.element, variant, isRecursive);
         }
     }
 };
@@ -171,12 +179,21 @@ const packEntry = (key, value, pair) => GLib.Variant.newDictEntry(packNode(key,
 const dictEntries = (value) => value instanceof Map ? [...value] : Object.entries(value);
 const packDict = (node, value) => GLib.Variant.newArray(GLib.VariantType.new(node.entryTypeString), dictEntries(value).map((pair) => packEntry(node.key, node.value, pair)));
 const packMaybe = (node, value) => GLib.Variant.newMaybe(GLib.VariantType.new(node.elementTypeString), value === null ? null : packNode(node.element, value));
+const packByteArray = (value) => {
+    if (!(value instanceof Uint8Array) && !Array.isArray(value)) {
+        throw new TypeError("Expected a Uint8Array or an array of byte values for a byte array (ay)");
+    }
+    return GLib.Variant.newFromBytes(GLib.VariantType.new(BYTE_ARRAY_TYPE_STRING), GLib.Bytes.new(value), true);
+};
 const packNode = (node, value) => {
     switch (node.kind) {
         case "basic": {
             return packBasic[node.code](value);
         }
         case "array": {
+            if (isByteArray(node)) {
+                return packByteArray(value);
+            }
             return GLib.Variant.newArray(GLib.VariantType.new(node.elementTypeString), value.map((item) => packNode(node.element, item)));
         }
         case "dict": {
@@ -197,24 +214,22 @@ const packNode = (node, value) => {
  * Packs a JavaScript value into the `GLib.Variant` a GVariant type string describes, building the
  * nested arrays, dictionaries, tuples and maybes the type calls for. A type string given as a
  * literal also types `value`, so `"as"` takes an array of strings, `"a{sv}"` a record of variants,
- * `"(si)"` a string and a number pair, and a 64-bit type a `bigint`.
+ * `"(si)"` a string and a number pair, a 64-bit type a `bigint`, and `"ay"` a `Uint8Array` or an
+ * array of byte values.
  * @param typeString GVariant type of the variant to build, such as `"a{sv}"`.
  * @param value Value to pack, shaped the way `typeString` describes.
  * @returns The packed variant.
- * @throws {Error} When the type string is not one complete GVariant type, or when a value packed as
- * an object path or a type signature is not a valid one.
+ * @throws {Error} When the type string is not one complete GVariant type, when a value packed as
+ * an object path or a type signature is not a valid one, or when a byte array is packed from
+ * anything but a `Uint8Array` or an array of byte values.
  */
 const toVariant = (typeString, value) => packNode(parseVariantType(typeString), value);
-/**
- * Unpacks a `GLib.Variant` into the JavaScript value a GVariant type string 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 tuple to an array of its members, a maybe to its value or
- * `null`, and a nested variant to the `GLib.Variant` itself.
- * @param typeString GVariant type the variant holds, such as `"a{sv}"`.
- * @param variant Variant to read, which has to hold that type.
- * @returns The unpacked value, typed from `typeString` when it is given as a literal.
- * @throws {Error} When the type string is not one complete GVariant type.
- */
-const fromVariant = (typeString, variant) => unpackNode(parseVariantType(typeString), variant);
-export { fromVariant, toVariant };
+function fromVariant(first, second, third) {
+    if (typeof first === "string") {
+        return unpackNode(parseVariantType(first), second, third?.recursive === true);
+    }
+    const options = second;
+    return unpackNode(parseVariantType(first.getTypeString()), first, options?.recursive === true);
+}
+export { fromVariant, toVariant, };
 //# sourceMappingURL=variant.js.map

package/dist/variant.js.map

@@ -1 +1 @@
-{"version":3,"file":"variant.js","sourceRoot":"","sources":["../src/variant.ts"],"names":[],"mappings":"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","sourcesContent":["import * as GLib from \"@gtkx/gi/glib\";\n\n/** JavaScript type every GVariant basic type code unpacks to. */\ntype BasicValueMap = {\n    /** Boolean, held as a single byte reading 0 or 1. */\n    b: boolean;\n    /** Unsigned byte. */\n    y: number;\n    /** Signed 16-bit integer. */\n    n: number;\n    /** Unsigned 16-bit integer. */\n    q: number;\n    /** Signed 32-bit integer. */\n    i: number;\n    /** Unsigned 32-bit integer. */\n    u: number;\n    /** Index into the file descriptor list a message carries. */\n    h: number;\n    /** Double precision floating point number. */\n    d: number;\n    /** Signed 64-bit integer. */\n    x: bigint;\n    /** Unsigned 64-bit integer. */\n    t: bigint;\n    /** UTF-8 string, under no further constraint on what it holds. */\n    s: string;\n    /** D-Bus object path. */\n    o: string;\n    /** GVariant type signature. */\n    g: string;\n    /** Boxed variant holding a value of any type. */\n    v: GLib.Variant;\n};\n\n/** Single-character code of one of the GVariant basic types in {@link BasicValueMap}. */\ntype BasicCode = keyof BasicValueMap;\n/** Parses the element type of an array, yielding the array type it produces and the rest of the string. */\ntype ParseArray<S extends string> = Parse<S> extends [infer V, infer R extends string] ? [V[], R] : never;\n/** Parses the element type of a maybe, yielding the nullable type it produces and the rest of the string. */\ntype ParseMaybe<S extends string> = Parse<S> extends [infer V, infer R extends string] ? [V | null, R] : never;\n\n/** Collects tuple member types into `Acc` up to the closing parenthesis, yielding them and the rest of the string. */\ntype ParseTuple<S extends string, Acc extends unknown[]> = S extends `)${infer Rest}`\n    ? [Acc, Rest]\n    : [Parse<S>] extends [never]\n            ? never\n            : Parse<S> extends [infer V, infer R extends string]\n                ? ParseTuple<R, [...Acc, V]>\n                : never;\n\n/** Types a dictionary entry key can hold. */\ntype DictKey = string | number | bigint | boolean;\n\n/** Parses the key and value types of a dictionary entry, yielding them and the rest of the string after its brace. */\ntype ParsePair<S extends string> =\n    Parse<S> extends [infer K, infer R1 extends string]\n        ? Parse<R1> extends [infer V, infer R2 extends string]\n            ? R2 extends `}${infer R3}`\n                ? [K] extends [DictKey]\n                        ? [K, V, R3]\n                        : never\n                : never\n            : never\n        : never;\n\n/**\n * Parses a dictionary entry into the collection an array of those entries unpacks to, a record for string keys and a\n * `Map` otherwise, plus the rest of the string.\n */\ntype ParseDict<S extends string> =\n    ParsePair<S> extends [infer K, infer V, infer R extends string]\n        ? [[K] extends [string] ? Record<string, V> : Map<K, V>, R]\n        : never;\n\n/** Parses a standalone dictionary entry into a key and value pair, yielding it and the rest of the string. */\ntype ParseEntry<S extends string> =\n    ParsePair<S> extends [infer K, infer V, infer R extends string] ? [[K, V], R] : never;\n\n/** Parses what follows an `a` as a dictionary when it opens an entry, and as a plain array otherwise. */\ntype ParseArrayOrDict<S extends string> = S extends `{${infer Rest}` ? ParseDict<Rest> : ParseArray<S>;\n\n/**\n * Parses the type at the head of `S`, yielding the JavaScript type it unpacks to and the rest of the string, or\n * `never` when the string is malformed.\n */\ntype Parse<S extends string> = S extends `a${infer Rest}`\n    ? ParseArrayOrDict<Rest>\n    : S extends `m${infer Rest}`\n        ? ParseMaybe<Rest>\n        : S extends `(${infer Rest}`\n            ? ParseTuple<Rest, []>\n            : S extends `{${infer Rest}`\n                ? ParseEntry<Rest>\n                : S extends `${infer C}${infer Rest}`\n                    ? C extends BasicCode\n                        ? [BasicValueMap[C], Rest]\n                        : never\n                    : never;\n\n/** JavaScript type a variant of type string `S` unpacks to, or `unknown` when `S` is not one complete type. */\ntype VariantValue<S extends string> = [Parse<S>] extends [never]\n    ? unknown\n    : Parse<S> extends [infer V, \"\"]\n        ? V\n        : unknown;\n\ntype VariantTypeNode =\n    | { kind: \"basic\"; code: BasicCode } |\n    { kind: \"array\"; elementTypeString: string; element: VariantTypeNode } |\n    { kind: \"dict\"; entryTypeString: string; key: VariantTypeNode; value: VariantTypeNode } |\n    { kind: \"entry\"; key: VariantTypeNode; value: VariantTypeNode } |\n    { kind: \"tuple\"; items: VariantTypeNode[] } |\n    { kind: \"maybe\"; elementTypeString: string; element: VariantTypeNode };\n\nconst BASIC_CODES = \"bynqiuxthdsogv\";\nconst STRING_KEY_CODES: Set<string> = new Set([\"s\", \"o\", \"g\"]);\n\nconst CONTAINER_PARSERS: Record<string, (source: string, start: number) => [VariantTypeNode, number]> = {\n    a: parseArrayNode,\n    m: parseMaybeNode,\n    \"(\": parseTupleNode,\n    \"{\": parseEntryNode,\n};\n\nconst parsedTypes: Map<string, VariantTypeNode> = new Map();\n\nconst unpackBasic: Record<BasicCode, (variant: GLib.Variant) => unknown> = {\n    b: (variant) => variant.getBoolean(),\n    y: (variant) => variant.getByte(),\n    n: (variant) => variant.getInt16(),\n    q: (variant) => variant.getUint16(),\n    i: (variant) => variant.getInt32(),\n    u: (variant) => variant.getUint32(),\n    h: (variant) => variant.getHandle(),\n    d: (variant) => variant.getDouble(),\n    x: (variant) => variant.getInt64(),\n    t: (variant) => variant.getUint64(),\n    s: (variant) => variant.getString()[0],\n    o: (variant) => variant.getString()[0],\n    g: (variant) => variant.getString()[0],\n    v: (variant) => variant.getVariant(),\n};\n\nconst packBasic: Record<BasicCode, (value: unknown) => GLib.Variant> = {\n    b: (value) => GLib.Variant.newBoolean(value as boolean),\n    y: (value) => GLib.Variant.newByte(value as number),\n    n: (value) => GLib.Variant.newInt16(value as number),\n    q: (value) => GLib.Variant.newUint16(value as number),\n    i: (value) => GLib.Variant.newInt32(value as number),\n    u: (value) => GLib.Variant.newUint32(value as number),\n    h: (value) => GLib.Variant.newHandle(value as number),\n    d: (value) => GLib.Variant.newDouble(value as number),\n    x: (value) => GLib.Variant.newInt64(value as bigint),\n    t: (value) => GLib.Variant.newUint64(value as bigint),\n    s: (value) => GLib.Variant.newString(value as string),\n    o: packObjectPath,\n    g: packSignature,\n    v: (value) => GLib.Variant.newVariant(value as GLib.Variant),\n};\n\nconst isBasicCode = (code: string): code is BasicCode => BASIC_CODES.includes(code);\nconst isStringKeyed = (key: VariantTypeNode): boolean => key.kind === \"basic\" && STRING_KEY_CODES.has(key.code);\nconst invalidType = (source: string): Error => new Error(`Invalid GVariant type string \"${source}\"`);\n\nconst parsePair = (source: string, start: number): [VariantTypeNode, VariantTypeNode, number] => {\n    const [key, keyEnd] = parseNode(source, start);\n\n    if (key.kind !== \"basic\" || key.code === \"v\") {\n        throw invalidType(source);\n    }\n\n    const [value, valueEnd] = parseNode(source, keyEnd);\n\n    if (source[valueEnd] !== \"}\") {\n        throw invalidType(source);\n    }\n\n    return [key, value, valueEnd + 1];\n};\n\nfunction parseArrayNode(source: string, start: number): [VariantTypeNode, number] {\n    if (source[start] === \"{\") {\n        const [key, value, end] = parsePair(source, start + 1);\n\n        return [{ kind: \"dict\", entryTypeString: source.slice(start, end), key, value }, end];\n    }\n\n    const [element, end] = parseNode(source, start);\n\n    return [{ kind: \"array\", elementTypeString: source.slice(start, end), element }, end];\n}\n\nfunction parseMaybeNode(source: string, start: number): [VariantTypeNode, number] {\n    const [element, end] = parseNode(source, start);\n\n    return [{ kind: \"maybe\", elementTypeString: source.slice(start, end), element }, end];\n}\n\nfunction parseTupleNode(source: string, start: number): [VariantTypeNode, number] {\n    const items: VariantTypeNode[] = [];\n    let position = start;\n\n    while (source[position] !== \")\") {\n        if (position >= source.length) {\n            throw invalidType(source);\n        }\n\n        const [item, end] = parseNode(source, position);\n        items.push(item);\n        position = end;\n    }\n\n    return [{ kind: \"tuple\", items }, position + 1];\n}\n\nfunction parseEntryNode(source: string, start: number): [VariantTypeNode, number] {\n    const [key, value, end] = parsePair(source, start);\n\n    return [{ kind: \"entry\", key, value }, end];\n}\n\nconst parseNode = (source: string, start: number): [VariantTypeNode, number] => {\n    const code = source[start];\n\n    if (code === undefined) {\n        throw invalidType(source);\n    }\n\n    const container = CONTAINER_PARSERS[code];\n\n    if (container !== undefined) {\n        return container(source, start + 1);\n    }\n\n    if (isBasicCode(code)) {\n        return [{ kind: \"basic\", code }, start + 1];\n    }\n\n    throw invalidType(source);\n};\n\nconst parseVariantType = (typeString: string): VariantTypeNode => {\n    const cached = parsedTypes.get(typeString);\n\n    if (cached !== undefined) {\n        return cached;\n    }\n\n    const [node, end] = parseNode(typeString, 0);\n\n    if (end !== typeString.length) {\n        throw invalidType(typeString);\n    }\n\n    parsedTypes.set(typeString, node);\n\n    return node;\n};\n\nconst unpackChildren = (variant: GLib.Variant, unpackChild: (child: GLib.Variant) => unknown): unknown[] => {\n    const children: unknown[] = [];\n    const count = variant.nChildren();\n\n    for (let index = 0; index < count; index += 1) {\n        children.push(unpackChild(variant.getChildValue(index)));\n    }\n\n    return children;\n};\n\nconst unpackPair = (key: VariantTypeNode, value: VariantTypeNode, entry: GLib.Variant): [unknown, unknown] => [\n    unpackNode(key, entry.getChildValue(0)),\n    unpackNode(value, entry.getChildValue(1)),\n];\n\nconst unpackDict = (\n    node: { key: VariantTypeNode; value: VariantTypeNode },\n    variant: GLib.Variant,\n): Record<string, unknown> | Map<unknown, unknown> => {\n    const entries = unpackChildren(variant, (entry) => unpackPair(node.key, node.value, entry)) as [unknown, unknown][];\n\n    if (!isStringKeyed(node.key)) {\n        return new Map(entries);\n    }\n\n    const stringEntries: [string, unknown][] = entries.map(([key, value]) => [key as string, value]);\n\n    return Object.fromEntries(stringEntries);\n};\n\nconst unpackMaybe = (element: VariantTypeNode, variant: GLib.Variant): unknown => {\n    const child = variant.getMaybe();\n\n    return child === null ? null : unpackNode(element, child);\n};\n\nconst unpackNode = (node: VariantTypeNode, variant: GLib.Variant): unknown => {\n    switch (node.kind) {\n        case \"basic\": {\n            return unpackBasic[node.code](variant);\n        }\n        case \"array\": {\n            return unpackChildren(variant, (child) => unpackNode(node.element, child));\n        }\n        case \"dict\": {\n            return unpackDict(node, variant);\n        }\n        case \"entry\": {\n            return unpackPair(node.key, node.value, variant);\n        }\n        case \"tuple\": {\n            return node.items.map((item, index) => unpackNode(item, variant.getChildValue(index)));\n        }\n        case \"maybe\": {\n            return unpackMaybe(node.element, variant);\n        }\n    }\n};\n\nconst packValidatedString = (\n    value: unknown,\n    isValid: (value: string) => boolean,\n    description: string,\n    construct: (value: string) => GLib.Variant,\n): GLib.Variant => {\n    if (typeof value !== \"string\" || !isValid(value)) {\n        throw new Error(`\"${String(value)}\" is not a valid GVariant ${description}`);\n    }\n\n    return construct(value);\n};\n\nfunction packObjectPath(value: unknown): GLib.Variant {\n    return packValidatedString(\n        value,\n        (path) => GLib.Variant.isObjectPath(path),\n        \"object path\",\n        (path) => GLib.Variant.newObjectPath(path),\n    );\n}\n\nfunction packSignature(value: unknown): GLib.Variant {\n    return packValidatedString(\n        value,\n        (signature) => GLib.Variant.isSignature(signature),\n        \"type signature\",\n        (signature) => GLib.Variant.newSignature(signature),\n    );\n}\n\nconst packEntry = (key: VariantTypeNode, value: VariantTypeNode, pair: [unknown, unknown]): GLib.Variant =>\n    GLib.Variant.newDictEntry(packNode(key, pair[0]), packNode(value, pair[1]));\n\nconst dictEntries = (value: unknown): [unknown, unknown][] =>\n    value instanceof Map ? [...value] : Object.entries(value as Record<string, unknown>);\n\nconst packDict = (\n    node: { entryTypeString: string; key: VariantTypeNode; value: VariantTypeNode },\n    value: unknown,\n): GLib.Variant =>\n    GLib.Variant.newArray(\n        GLib.VariantType.new(node.entryTypeString),\n        dictEntries(value).map((pair) => packEntry(node.key, node.value, pair)),\n    );\n\nconst packMaybe = (node: { elementTypeString: string; element: VariantTypeNode }, value: unknown): GLib.Variant =>\n    GLib.Variant.newMaybe(\n        GLib.VariantType.new(node.elementTypeString),\n        value === null ? null : packNode(node.element, value),\n    );\n\nconst packNode = (node: VariantTypeNode, value: unknown): GLib.Variant => {\n    switch (node.kind) {\n        case \"basic\": {\n            return packBasic[node.code](value);\n        }\n        case \"array\": {\n            return GLib.Variant.newArray(\n                GLib.VariantType.new(node.elementTypeString),\n                (value as unknown[]).map((item) => packNode(node.element, item)),\n            );\n        }\n        case \"dict\": {\n            return packDict(node, value);\n        }\n        case \"entry\": {\n            return packEntry(node.key, node.value, value as [unknown, unknown]);\n        }\n        case \"tuple\": {\n            return GLib.Variant.newTuple(\n                node.items.map((item, index) => packNode(item, (value as unknown[])[index])),\n            );\n        }\n        case \"maybe\": {\n            return packMaybe(node, value);\n        }\n    }\n};\n\n/**\n * Packs a JavaScript value into the `GLib.Variant` a GVariant type string describes, building the\n * nested arrays, dictionaries, tuples and maybes the type calls for. A type string given as a\n * literal also types `value`, so `\"as\"` takes an array of strings, `\"a{sv}\"` a record of variants,\n * `\"(si)\"` a string and a number pair, and a 64-bit type a `bigint`.\n * @param typeString GVariant type of the variant to build, such as `\"a{sv}\"`.\n * @param value Value to pack, shaped the way `typeString` describes.\n * @returns The packed variant.\n * @throws {Error} When the type string is not one complete GVariant type, or when a value packed as\n * an object path or a type signature is not a valid one.\n */\nconst toVariant = <S extends string>(typeString: S, value: VariantValue<S>): GLib.Variant =>\n    packNode(parseVariantType(typeString), value);\n\n/**\n * Unpacks a `GLib.Variant` into the JavaScript value a GVariant type string describes, the inverse\n * of {@link toVariant}. A dictionary keyed by strings unpacks to a record and one keyed by anything\n * else to a `Map`, an array to an array, a tuple to an array of its members, a maybe to its value or\n * `null`, and a nested variant to the `GLib.Variant` itself.\n * @param typeString GVariant type the variant holds, such as `\"a{sv}\"`.\n * @param variant Variant to read, which has to hold that type.\n * @returns The unpacked value, typed from `typeString` when it is given as a literal.\n * @throws {Error} When the type string is not one complete GVariant type.\n */\nconst fromVariant = <S extends string>(typeString: S, variant: GLib.Variant): VariantValue<S> =>\n    unpackNode(parseVariantType(typeString), variant) as VariantValue<S>;\n\nexport { fromVariant, toVariant, type VariantValue };\n"]}
+{"version":3,"file":"variant.js","sourceRoot":"","sources":["../src/variant.ts"],"names":[],"mappings":"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","sourcesContent":["import * as GLib from \"@gtkx/gi/glib\";\n\n/** JavaScript type every GVariant basic type code unpacks to, with a nested variant held as `Nested`. */\ntype BasicValueMap<Nested> = {\n    /** Boolean, held as a single byte reading 0 or 1. */\n    b: boolean;\n    /** Unsigned byte. */\n    y: number;\n    /** Signed 16-bit integer. */\n    n: number;\n    /** Unsigned 16-bit integer. */\n    q: number;\n    /** Signed 32-bit integer. */\n    i: number;\n    /** Unsigned 32-bit integer. */\n    u: number;\n    /** Index into the file descriptor list a message carries. */\n    h: number;\n    /** Double precision floating point number. */\n    d: number;\n    /** Signed 64-bit integer. */\n    x: bigint;\n    /** Unsigned 64-bit integer. */\n    t: bigint;\n    /** UTF-8 string, under no further constraint on what it holds. */\n    s: string;\n    /** D-Bus object path. */\n    o: string;\n    /** GVariant type signature. */\n    g: string;\n    /** Boxed variant holding a value of any type. */\n    v: Nested;\n};\n\n/** Single-character code of one of the GVariant basic types in {@link BasicValueMap}. */\ntype BasicCode = keyof BasicValueMap<unknown>;\n/**\n * JavaScript type a byte array (`ay`) unpacks to: the same one the generated bindings use for byte sequences, so a\n * `Uint8Array` under the `v2ByteArrays` future flag and a `number[]` otherwise.\n */\ntype ByteArray = ReturnType<GLib.Bytes[\"unrefToArray\"]>;\n/** Values a byte array (`ay`) packs from. */\ntype ByteArrayInput = Uint8Array | number[];\n\n/**\n * Parses the element type of an array, yielding the array type it produces and the rest of the string. An array of\n * bytes yields the byte array type instead of `number[]`.\n */\ntype ParseArray<S extends string, Bytes, Nested> = S extends `y${infer Rest}`\n    ? [Bytes, Rest]\n    : Parse<S, Bytes, Nested> extends [infer V, infer R extends string]\n        ? [V[], R]\n        : never;\n\n/** Parses the element type of a maybe, yielding the nullable type it produces and the rest of the string. */\ntype ParseMaybe<S extends string, Bytes, Nested> =\n    Parse<S, Bytes, Nested> extends [infer V, infer R extends string] ? [V | null, R] : never;\n\n/** Collects tuple member types into `Acc` up to the closing parenthesis, yielding them and the rest of the string. */\ntype ParseTuple<S extends string, Bytes, Nested, Acc extends unknown[]> = S extends `)${infer Rest}`\n    ? [Acc, Rest]\n    : [Parse<S, Bytes, Nested>] extends [never]\n            ? never\n            : Parse<S, Bytes, Nested> extends [infer V, infer R extends string]\n                ? ParseTuple<R, Bytes, Nested, [...Acc, V]>\n                : never;\n\n/** Types a dictionary entry key can hold. */\ntype DictKey = string | number | bigint | boolean;\n\n/** Parses the key and value types of a dictionary entry, yielding them and the rest of the string after its brace. */\ntype ParsePair<S extends string, Bytes, Nested> =\n    Parse<S, Bytes, Nested> extends [infer K, infer R1 extends string]\n        ? Parse<R1, Bytes, Nested> extends [infer V, infer R2 extends string]\n            ? R2 extends `}${infer R3}`\n                ? [K] extends [DictKey]\n                        ? [K, V, R3]\n                        : never\n                : never\n            : never\n        : never;\n\n/**\n * Parses a dictionary entry into the collection an array of those entries unpacks to, a record for string keys and a\n * `Map` otherwise, plus the rest of the string.\n */\ntype ParseDict<S extends string, Bytes, Nested> =\n    ParsePair<S, Bytes, Nested> extends [infer K, infer V, infer R extends string]\n        ? [[K] extends [string] ? Record<string, V> : Map<K, V>, R]\n        : never;\n\n/** Parses a standalone dictionary entry into a key and value pair, yielding it and the rest of the string. */\ntype ParseEntry<S extends string, Bytes, Nested> =\n    ParsePair<S, Bytes, Nested> extends [infer K, infer V, infer R extends string] ? [[K, V], R] : never;\n\n/** Parses what follows an `a` as a dictionary when it opens an entry, and as a plain array otherwise. */\ntype ParseArrayOrDict<S extends string, Bytes, Nested> = S extends `{${infer Rest}`\n    ? ParseDict<Rest, Bytes, Nested>\n    : ParseArray<S, Bytes, Nested>;\n\n/**\n * Parses the type at the head of `S`, yielding the JavaScript type it unpacks to and the rest of the string, or\n * `never` when the string is malformed.\n */\ntype Parse<S extends string, Bytes, Nested> = S extends `a${infer Rest}`\n    ? ParseArrayOrDict<Rest, Bytes, Nested>\n    : S extends `m${infer Rest}`\n        ? ParseMaybe<Rest, Bytes, Nested>\n        : S extends `(${infer Rest}`\n            ? ParseTuple<Rest, Bytes, Nested, []>\n            : S extends `{${infer Rest}`\n                ? ParseEntry<Rest, Bytes, Nested>\n                : S extends `${infer C}${infer Rest}`\n                    ? C extends BasicCode\n                        ? [BasicValueMap<Nested>[C], Rest]\n                        : never\n                    : never;\n\n/** JavaScript type a type string `S` describes, or `unknown` when `S` is not one complete type. */\ntype ParsedValue<S extends string, Bytes, Nested> = [Parse<S, Bytes, Nested>] extends [never]\n    ? unknown\n    : Parse<S, Bytes, Nested> extends [infer V, \"\"]\n        ? V\n        : unknown;\n\n/**\n * JavaScript type a variant of type string `S` unpacks to, or `unknown` when `S` is not one complete type. A byte\n * array (`ay`) unpacks to {@link ByteArray} and a nested variant (`v`) to the `GLib.Variant` itself.\n */\ntype VariantValue<S extends string> = ParsedValue<S, ByteArray, GLib.Variant>;\n/**\n * JavaScript type {@link toVariant} packs into a variant of type string `S`, or `unknown` when `S` is not one\n * complete type. The same as {@link VariantValue}, except that a byte array (`ay`) also packs from a `number[]`.\n */\ntype VariantInput<S extends string> = ParsedValue<S, ByteArrayInput, GLib.Variant>;\n/**\n * JavaScript type a variant of type string `S` unpacks to when every nested variant is unwrapped as well, so a `v`\n * reads as `unknown`.\n */\ntype RecursiveVariantValue<S extends string> = ParsedValue<S, ByteArray, unknown>;\n\n/** Options {@link fromVariant} reads. */\ntype FromVariantOptions = {\n    /**\n     * Whether to unwrap every nested variant (`v`) into the value it holds, all the way down, instead of handing back\n     * the `GLib.Variant` itself. Discards the type information those variants carry.\n     */\n    recursive?: boolean;\n};\n\n/** {@link FromVariantOptions} with recursive unwrapping selected, typing the result accordingly. */\ntype RecursiveFromVariantOptions = {\n    /** Unwraps every nested variant (`v`) into the value it holds, all the way down. */\n    recursive: true;\n};\n\ntype VariantTypeNode =\n    | { kind: \"basic\"; code: BasicCode } |\n    { kind: \"array\"; elementTypeString: string; element: VariantTypeNode } |\n    { kind: \"dict\"; entryTypeString: string; key: VariantTypeNode; value: VariantTypeNode } |\n    { kind: \"entry\"; key: VariantTypeNode; value: VariantTypeNode } |\n    { kind: \"tuple\"; items: VariantTypeNode[] } |\n    { kind: \"maybe\"; elementTypeString: string; element: VariantTypeNode };\n\nconst BASIC_CODES = \"bynqiuxthdsogv\";\nconst STRING_KEY_CODES: Set<string> = new Set([\"s\", \"o\", \"g\"]);\n\nconst CONTAINER_PARSERS: Record<string, (source: string, start: number) => [VariantTypeNode, number]> = {\n    a: parseArrayNode,\n    m: parseMaybeNode,\n    \"(\": parseTupleNode,\n    \"{\": parseEntryNode,\n};\n\nconst parsedTypes: Map<string, VariantTypeNode> = new Map();\nconst BYTE_ARRAY_TYPE_STRING = \"ay\";\n\nconst unpackBasic: Record<BasicCode, (variant: GLib.Variant) => unknown> = {\n    b: (variant) => variant.getBoolean(),\n    y: (variant) => variant.getByte(),\n    n: (variant) => variant.getInt16(),\n    q: (variant) => variant.getUint16(),\n    i: (variant) => variant.getInt32(),\n    u: (variant) => variant.getUint32(),\n    h: (variant) => variant.getHandle(),\n    d: (variant) => variant.getDouble(),\n    x: (variant) => variant.getInt64(),\n    t: (variant) => variant.getUint64(),\n    s: (variant) => variant.getString()[0],\n    o: (variant) => variant.getString()[0],\n    g: (variant) => variant.getString()[0],\n    v: (variant) => variant.getVariant(),\n};\n\nconst packBasic: Record<BasicCode, (value: unknown) => GLib.Variant> = {\n    b: (value) => GLib.Variant.newBoolean(value as boolean),\n    y: (value) => GLib.Variant.newByte(value as number),\n    n: (value) => GLib.Variant.newInt16(value as number),\n    q: (value) => GLib.Variant.newUint16(value as number),\n    i: (value) => GLib.Variant.newInt32(value as number),\n    u: (value) => GLib.Variant.newUint32(value as number),\n    h: (value) => GLib.Variant.newHandle(value as number),\n    d: (value) => GLib.Variant.newDouble(value as number),\n    x: (value) => GLib.Variant.newInt64(value as bigint),\n    t: (value) => GLib.Variant.newUint64(value as bigint),\n    s: (value) => GLib.Variant.newString(value as string),\n    o: packObjectPath,\n    g: packSignature,\n    v: (value) => GLib.Variant.newVariant(value as GLib.Variant),\n};\n\nconst isBasicCode = (code: string): code is BasicCode => BASIC_CODES.includes(code);\nconst isStringKeyed = (key: VariantTypeNode): boolean => key.kind === \"basic\" && STRING_KEY_CODES.has(key.code);\nconst invalidType = (source: string): Error => new Error(`Invalid GVariant type string \"${source}\"`);\n\nconst parsePair = (source: string, start: number): [VariantTypeNode, VariantTypeNode, number] => {\n    const [key, keyEnd] = parseNode(source, start);\n\n    if (key.kind !== \"basic\" || key.code === \"v\") {\n        throw invalidType(source);\n    }\n\n    const [value, valueEnd] = parseNode(source, keyEnd);\n\n    if (source[valueEnd] !== \"}\") {\n        throw invalidType(source);\n    }\n\n    return [key, value, valueEnd + 1];\n};\n\nfunction parseArrayNode(source: string, start: number): [VariantTypeNode, number] {\n    if (source[start] === \"{\") {\n        const [key, value, end] = parsePair(source, start + 1);\n\n        return [{ kind: \"dict\", entryTypeString: source.slice(start, end), key, value }, end];\n    }\n\n    const [element, end] = parseNode(source, start);\n\n    return [{ kind: \"array\", elementTypeString: source.slice(start, end), element }, end];\n}\n\nfunction parseMaybeNode(source: string, start: number): [VariantTypeNode, number] {\n    const [element, end] = parseNode(source, start);\n\n    return [{ kind: \"maybe\", elementTypeString: source.slice(start, end), element }, end];\n}\n\nfunction parseTupleNode(source: string, start: number): [VariantTypeNode, number] {\n    const items: VariantTypeNode[] = [];\n    let position = start;\n\n    while (source[position] !== \")\") {\n        if (position >= source.length) {\n            throw invalidType(source);\n        }\n\n        const [item, end] = parseNode(source, position);\n        items.push(item);\n        position = end;\n    }\n\n    return [{ kind: \"tuple\", items }, position + 1];\n}\n\nfunction parseEntryNode(source: string, start: number): [VariantTypeNode, number] {\n    const [key, value, end] = parsePair(source, start);\n\n    return [{ kind: \"entry\", key, value }, end];\n}\n\nconst parseNode = (source: string, start: number): [VariantTypeNode, number] => {\n    const code = source[start];\n\n    if (code === undefined) {\n        throw invalidType(source);\n    }\n\n    const container = CONTAINER_PARSERS[code];\n\n    if (container !== undefined) {\n        return container(source, start + 1);\n    }\n\n    if (isBasicCode(code)) {\n        return [{ kind: \"basic\", code }, start + 1];\n    }\n\n    throw invalidType(source);\n};\n\nconst parseVariantType = (typeString: string): VariantTypeNode => {\n    const cached = parsedTypes.get(typeString);\n\n    if (cached !== undefined) {\n        return cached;\n    }\n\n    const [node, end] = parseNode(typeString, 0);\n\n    if (end !== typeString.length) {\n        throw invalidType(typeString);\n    }\n\n    parsedTypes.set(typeString, node);\n\n    return node;\n};\n\nconst isByteArray = (node: VariantTypeNode): boolean =>\n    node.kind === \"array\" && node.element.kind === \"basic\" && node.element.code === \"y\";\n\nconst unpackChildren = (variant: GLib.Variant, unpackChild: (child: GLib.Variant) => unknown): unknown[] => {\n    const children: unknown[] = [];\n    const count = variant.nChildren();\n\n    for (let index = 0; index < count; index += 1) {\n        children.push(unpackChild(variant.getChildValue(index)));\n    }\n\n    return children;\n};\n\nconst unpackPair = (\n    key: VariantTypeNode,\n    value: VariantTypeNode,\n    entry: GLib.Variant,\n    isRecursive: boolean,\n): [unknown, unknown] => [\n    unpackNode(key, entry.getChildValue(0), isRecursive),\n    unpackNode(value, entry.getChildValue(1), isRecursive),\n];\n\nconst unpackDict = (\n    node: { key: VariantTypeNode; value: VariantTypeNode },\n    variant: GLib.Variant,\n    isRecursive: boolean,\n): Record<string, unknown> | Map<unknown, unknown> => {\n    const entries = unpackChildren(variant, (entry) => unpackPair(node.key, node.value, entry, isRecursive)) as [\n        unknown,\n        unknown,\n    ][];\n\n    if (!isStringKeyed(node.key)) {\n        return new Map(entries);\n    }\n\n    const stringEntries: [string, unknown][] = entries.map(([key, value]) => [key as string, value]);\n\n    return Object.fromEntries(stringEntries);\n};\n\nconst unpackMaybe = (element: VariantTypeNode, variant: GLib.Variant, isRecursive: boolean): unknown => {\n    const child = variant.getMaybe();\n\n    return child === null ? null : unpackNode(element, child, isRecursive);\n};\n\nconst unpackNested = (variant: GLib.Variant, isRecursive: boolean): unknown => {\n    const held = variant.getVariant();\n\n    return isRecursive ? unpackNode(parseVariantType(held.getTypeString()), held, true) : held;\n};\n\nconst unpackNode = (node: VariantTypeNode, variant: GLib.Variant, isRecursive: boolean): unknown => {\n    switch (node.kind) {\n        case \"basic\": {\n            return node.code === \"v\" ? unpackNested(variant, isRecursive) : unpackBasic[node.code](variant);\n        }\n        case \"array\": {\n            return isByteArray(node)\n                ? variant.getDataAsBytes().unrefToArray()\n                : unpackChildren(variant, (child) => unpackNode(node.element, child, isRecursive));\n        }\n        case \"dict\": {\n            return unpackDict(node, variant, isRecursive);\n        }\n        case \"entry\": {\n            return unpackPair(node.key, node.value, variant, isRecursive);\n        }\n        case \"tuple\": {\n            return node.items.map((item, index) => unpackNode(item, variant.getChildValue(index), isRecursive));\n        }\n        case \"maybe\": {\n            return unpackMaybe(node.element, variant, isRecursive);\n        }\n    }\n};\n\nconst packValidatedString = (\n    value: unknown,\n    isValid: (value: string) => boolean,\n    description: string,\n    construct: (value: string) => GLib.Variant,\n): GLib.Variant => {\n    if (typeof value !== \"string\" || !isValid(value)) {\n        throw new Error(`\"${String(value)}\" is not a valid GVariant ${description}`);\n    }\n\n    return construct(value);\n};\n\nfunction packObjectPath(value: unknown): GLib.Variant {\n    return packValidatedString(\n        value,\n        (path) => GLib.Variant.isObjectPath(path),\n        \"object path\",\n        (path) => GLib.Variant.newObjectPath(path),\n    );\n}\n\nfunction packSignature(value: unknown): GLib.Variant {\n    return packValidatedString(\n        value,\n        (signature) => GLib.Variant.isSignature(signature),\n        \"type signature\",\n        (signature) => GLib.Variant.newSignature(signature),\n    );\n}\n\nconst packEntry = (key: VariantTypeNode, value: VariantTypeNode, pair: [unknown, unknown]): GLib.Variant =>\n    GLib.Variant.newDictEntry(packNode(key, pair[0]), packNode(value, pair[1]));\n\nconst dictEntries = (value: unknown): [unknown, unknown][] =>\n    value instanceof Map ? [...value] : Object.entries(value as Record<string, unknown>);\n\nconst packDict = (\n    node: { entryTypeString: string; key: VariantTypeNode; value: VariantTypeNode },\n    value: unknown,\n): GLib.Variant =>\n    GLib.Variant.newArray(\n        GLib.VariantType.new(node.entryTypeString),\n        dictEntries(value).map((pair) => packEntry(node.key, node.value, pair)),\n    );\n\nconst packMaybe = (node: { elementTypeString: string; element: VariantTypeNode }, value: unknown): GLib.Variant =>\n    GLib.Variant.newMaybe(\n        GLib.VariantType.new(node.elementTypeString),\n        value === null ? null : packNode(node.element, value),\n    );\n\nconst packByteArray = (value: unknown): GLib.Variant => {\n    if (!(value instanceof Uint8Array) && !Array.isArray(value)) {\n        throw new TypeError(\"Expected a Uint8Array or an array of byte values for a byte array (ay)\");\n    }\n\n    return GLib.Variant.newFromBytes(\n        GLib.VariantType.new(BYTE_ARRAY_TYPE_STRING),\n        GLib.Bytes.new(value as ByteArrayInput),\n        true,\n    );\n};\n\nconst packNode = (node: VariantTypeNode, value: unknown): GLib.Variant => {\n    switch (node.kind) {\n        case \"basic\": {\n            return packBasic[node.code](value);\n        }\n        case \"array\": {\n            if (isByteArray(node)) {\n                return packByteArray(value);\n            }\n\n            return GLib.Variant.newArray(\n                GLib.VariantType.new(node.elementTypeString),\n                (value as unknown[]).map((item) => packNode(node.element, item)),\n            );\n        }\n        case \"dict\": {\n            return packDict(node, value);\n        }\n        case \"entry\": {\n            return packEntry(node.key, node.value, value as [unknown, unknown]);\n        }\n        case \"tuple\": {\n            return GLib.Variant.newTuple(\n                node.items.map((item, index) => packNode(item, (value as unknown[])[index])),\n            );\n        }\n        case \"maybe\": {\n            return packMaybe(node, value);\n        }\n    }\n};\n\n/**\n * Packs a JavaScript value into the `GLib.Variant` a GVariant type string describes, building the\n * nested arrays, dictionaries, tuples and maybes the type calls for. A type string given as a\n * literal also types `value`, so `\"as\"` takes an array of strings, `\"a{sv}\"` a record of variants,\n * `\"(si)\"` a string and a number pair, a 64-bit type a `bigint`, and `\"ay\"` a `Uint8Array` or an\n * array of byte values.\n * @param typeString GVariant type of the variant to build, such as `\"a{sv}\"`.\n * @param value Value to pack, shaped the way `typeString` describes.\n * @returns The packed variant.\n * @throws {Error} When the type string is not one complete GVariant type, when a value packed as\n * an object path or a type signature is not a valid one, or when a byte array is packed from\n * anything but a `Uint8Array` or an array of byte values.\n */\nconst toVariant = <S extends string>(typeString: S, value: VariantInput<S>): GLib.Variant =>\n    packNode(parseVariantType(typeString), value);\n\n/**\n * Unpacks a `GLib.Variant` into the JavaScript value its GVariant type describes, the inverse of\n * {@link toVariant}. A dictionary keyed by strings unpacks to a record and one keyed by anything\n * else to a `Map`, an array to an array, a byte array (`ay`) to the byte array type the generated\n * bindings use (`Uint8Array` under the `v2ByteArrays` future flag, `number[]` otherwise), a tuple\n * to an array of its members, a maybe to its value or `null`, and a nested variant to the\n * `GLib.Variant` itself unless `recursive` is set, in which case it is unwrapped all the way down.\n *\n * The type string is optional: without one the variant's own type is read, and the result is\n * `unknown`. With one given as a literal, the result is typed from it.\n * @param typeString GVariant type the variant holds, such as `\"a{sv}\"`.\n * @param variant Variant to read, which has to hold that type.\n * @param options Whether to unwrap nested variants recursively.\n * @returns The unpacked value.\n * @throws {Error} When the type string is not one complete GVariant type.\n */\nfunction fromVariant<S extends string>(typeString: S, variant: GLib.Variant): VariantValue<S>;\n\nfunction fromVariant<S extends string>(\n    typeString: S,\n    variant: GLib.Variant,\n    options: RecursiveFromVariantOptions,\n): RecursiveVariantValue<S>;\n\nfunction fromVariant<S extends string>(\n    typeString: S,\n    variant: GLib.Variant,\n    options: FromVariantOptions,\n): VariantValue<S> | RecursiveVariantValue<S>;\n\nfunction fromVariant(variant: GLib.Variant, options?: FromVariantOptions): unknown;\n\nfunction fromVariant(\n    first: string | GLib.Variant,\n    second?: GLib.Variant | FromVariantOptions,\n    third?: FromVariantOptions,\n): unknown {\n    if (typeof first === \"string\") {\n        return unpackNode(parseVariantType(first), second as GLib.Variant, third?.recursive === true);\n    }\n\n    const options = second as FromVariantOptions | undefined;\n\n    return unpackNode(parseVariantType(first.getTypeString()), first, options?.recursive === true);\n}\n\nexport {\n    type ByteArray,\n    type FromVariantOptions,\n    fromVariant,\n    type RecursiveFromVariantOptions,\n    type RecursiveVariantValue,\n    toVariant,\n    type VariantInput,\n    type VariantValue,\n};\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtkx/runtime",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "FFI runtime the generated GTKX bindings call into: type descriptors, GValue marshalling, signals, GObject lifecycle",
   "keywords": [
     "gtkx",
@@ -55,11 +55,11 @@
     "node": ">=24"
   },
   "dependencies": {
-    "@gtkx/utils": "1.2.1",
-    "@gtkx/native": "1.2.1"
+    "@gtkx/utils": "1.3.0",
+    "@gtkx/native": "1.3.0"
   },
   "devDependencies": {
-    "@gtkx/vitest": "1.2.1"
+    "@gtkx/vitest": "1.3.0"
   },
   "scripts": {
     "release": "tsx ../../scripts/release-package.ts"

package/src/arg.ts

@@ -10,12 +10,17 @@ type Arg = {
     isCallerAllocated?: boolean;
     /** When true, the argument is consumed internally and left out of the packed result. */
     isConsumed?: boolean;
+    /** When true, the argument is a `GValue` the callee fills in, packed into the result as what it holds. */
+    isUnpacked?: boolean;
+    /** When true, the caller must provide the argument: `undefined` is rejected instead of reaching C as `NULL`. */
+    isRequired?: boolean;
 };
 
 const isOutputArg = (arg: Arg): boolean => arg.direction !== undefined;
 const isInoutArg = (arg: Arg): boolean => arg.direction === "inout";
 const isCallerAllocatedArg = (arg: Arg): boolean => arg.isCallerAllocated === true;
+const isUnpackedArg = (arg: Arg): boolean => arg.isUnpacked === true;
 const isRefArg = (arg: Arg): boolean => arg.direction !== undefined && arg.isCallerAllocated !== true;
 const requiresInputArg = (arg: Arg): boolean => !isRefArg(arg) || isInoutArg(arg);
 
-export { isOutputArg, isInoutArg, isCallerAllocatedArg, isRefArg, requiresInputArg, type Arg };
+export { isOutputArg, isInoutArg, isCallerAllocatedArg, isRefArg, isUnpackedArg, requiresInputArg, type Arg };

package/src/closure.ts

@@ -3,7 +3,7 @@ import { type AnyClass } from "@gtkx/utils";
 import { bind } from "./bind.js";
 import { boxedT, callbackT, sizedArrayT, structT, uint32T, uint64T, voidT } from "./descriptors.js";
 import { CLOSURE_SIZE, LIB, VALUE_SIZE, VALUE_T } from "./library.js";
-import { getClassType, getHandle, getWrapperClass, instanceClassName, wrapHandle } from "./registry.js";
+import { describeValueKind, getClassType, getHandle, getWrapperClass, wrapHandle } from "./registry.js";
 import { resolveBoxedType, typeIsA } from "./type.js";
 import { fromValue, getValueType, intoValue } from "./value.js";
 
@@ -70,18 +70,6 @@ const getNestedValue = (param: ExternalObject<Handle>): object | null =>
 const fromParamValue = (param: ExternalObject<Handle>): unknown =>
     getValueType(param) === resolveBoxedType(VALUE_T) ? getNestedValue(param) : fromValue(param);
 
-function describeValue(value: unknown): string {
-    if (value === null) {
-        return "null";
-    }
-
-    if (typeof value !== "object") {
-        return typeof value;
-    }
-
-    return instanceClassName(value);
-}
-
 function marshalFor(callback: ClosureCallback): (...args: unknown[]) => void {
     return (_closure: unknown, returnValue: unknown, _count: unknown, paramValues: unknown): void => {
         const values = paramValues as ExternalObject<Handle>[];
@@ -119,7 +107,7 @@ function toClosure(value: unknown): ExternalObject<Handle> {
         return getHandle(value);
     }
 
-    throw new ClosureMarshalError(`Cannot marshal ${describeValue(value)} into a GObject.Closure`);
+    throw new ClosureMarshalError(`Cannot marshal ${describeValueKind(value)} into a GObject.Closure`);
 }
 
 /** Same as {@link toClosure}, but passes a null or undefined value through as no closure at all. */