@solana/codecs-data-structures 6.3.1 → 6.3.2-canary-20260313112147

package/src/tuple.ts

@@ -0,0 +1,228 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import {
+    Codec,
+    combineCodec,
+    createDecoder,
+    createEncoder,
+    Decoder,
+    Encoder,
+    FixedSizeCodec,
+    FixedSizeDecoder,
+    FixedSizeEncoder,
+    getEncodedSize,
+    ReadonlyUint8Array,
+    VariableSizeCodec,
+    VariableSizeDecoder,
+    VariableSizeEncoder,
+} from '@solana/codecs-core';
+
+import { assertValidNumberOfItemsForCodec } from './assertions';
+import { DrainOuterGeneric, getFixedSize, getMaxSize, sumCodecSizes } from './utils';
+
+/**
+ * Infers the TypeScript type for a tuple that can be encoded using a tuple codec.
+ *
+ * This type maps each provided item encoder to its corresponding value type.
+ *
+ * @typeParam TItems - An array of encoders, each corresponding to a tuple element.
+ */
+type GetEncoderTypeFromItems<TItems extends readonly Encoder<any>[]> = DrainOuterGeneric<{
+    [I in keyof TItems]: TItems[I] extends Encoder<infer TFrom> ? TFrom : never;
+}>;
+
+/**
+ * Infers the TypeScript type for a tuple that can be decoded using a tuple codec.
+ *
+ * This type maps each provided item decoder to its corresponding value type.
+ *
+ * @typeParam TItems - An array of decoders, each corresponding to a tuple element.
+ */
+type GetDecoderTypeFromItems<TItems extends readonly Decoder<any>[]> = DrainOuterGeneric<{
+    [I in keyof TItems]: TItems[I] extends Decoder<infer TTo> ? TTo : never;
+}>;
+
+/**
+ * Defines the configuration options for tuple codecs.
+ */
+export type TupleCodecConfig = {
+    /**
+     * An optional description for the codec, that will be used in error messages.
+     */
+    description?: string;
+};
+
+/**
+ * Returns an encoder for tuples.
+ *
+ * This encoder serializes a fixed-size array (tuple) by encoding its items
+ * sequentially using the provided item encoders.
+ *
+ * For more details, see {@link getTupleCodec}.
+ *
+ * @typeParam TItems - An array of encoders, each corresponding to a tuple element.
+ *
+ * @param items - The encoders for each item in the tuple.
+ * @param config - Optional configuration for the description.
+ * @returns A `FixedSizeEncoder` or `VariableSizeEncoder` for encoding tuples.
+ *
+ * @example
+ * Encoding a tuple with 2 items.
+ * ```ts
+ * const encoder = getTupleEncoder([fixCodecSize(getUtf8Encoder(), 5), getU8Encoder()]);
+ *
+ * const bytes = encoder.encode(['Alice', 42]);
+ * // 0x416c6963652a
+ * //   |         └── Second item (42)
+ * //   └── First item ("Alice")
+ * ```
+ *
+ * @see {@link getTupleCodec}
+ */
+export function getTupleEncoder<const TItems extends readonly FixedSizeEncoder<any>[]>(
+    items: TItems,
+    config?: TupleCodecConfig,
+): FixedSizeEncoder<GetEncoderTypeFromItems<TItems>>;
+export function getTupleEncoder<const TItems extends readonly Encoder<any>[]>(
+    items: TItems,
+    config?: TupleCodecConfig,
+): VariableSizeEncoder<GetEncoderTypeFromItems<TItems>>;
+export function getTupleEncoder<const TItems extends readonly Encoder<any>[]>(
+    items: TItems,
+    config?: TupleCodecConfig,
+): Encoder<GetEncoderTypeFromItems<TItems>> {
+    type TFrom = GetEncoderTypeFromItems<TItems>;
+    const fixedSize = sumCodecSizes(items.map(getFixedSize));
+    const maxSize = sumCodecSizes(items.map(getMaxSize)) ?? undefined;
+
+    return createEncoder({
+        ...(fixedSize === null
+            ? {
+                  getSizeFromValue: (value: TFrom) =>
+                      items.map((item, index) => getEncodedSize(value[index], item)).reduce((all, one) => all + one, 0),
+                  maxSize,
+              }
+            : { fixedSize }),
+        write: (value: TFrom, bytes, offset) => {
+            assertValidNumberOfItemsForCodec(config?.description ?? 'tuple', items.length, value.length);
+            items.forEach((item, index) => {
+                offset = item.write(value[index], bytes, offset);
+            });
+            return offset;
+        },
+    });
+}
+
+/**
+ * Returns a decoder for tuples.
+ *
+ * This decoder deserializes a fixed-size array (tuple) by decoding its items
+ * sequentially using the provided item decoders.
+ *
+ * For more details, see {@link getTupleCodec}.
+ *
+ * @typeParam TItems - An array of decoders, each corresponding to a tuple element.
+ *
+ * @param items - The decoders for each item in the tuple.
+ * @returns A `FixedSizeDecoder` or `VariableSizeDecoder` for decoding tuples.
+ *
+ * @example
+ * Decoding a tuple with 2 items.
+ * ```ts
+ * const decoder = getTupleDecoder([fixCodecSize(getUtf8Decoder(), 5), getU8Decoder()]);
+ *
+ * const tuple = decoder.decode(new Uint8Array([
+ *   0x41,0x6c,0x69,0x63,0x65,0x2a
+ * ]));
+ * // ['Alice', 42]
+ * ```
+ *
+ * @see {@link getTupleCodec}
+ */
+export function getTupleDecoder<const TItems extends readonly FixedSizeDecoder<any>[]>(
+    items: TItems,
+): FixedSizeDecoder<GetDecoderTypeFromItems<TItems>>;
+export function getTupleDecoder<const TItems extends readonly Decoder<any>[]>(
+    items: TItems,
+): VariableSizeDecoder<GetDecoderTypeFromItems<TItems>>;
+export function getTupleDecoder<const TItems extends readonly Decoder<any>[]>(
+    items: TItems,
+): Decoder<GetDecoderTypeFromItems<TItems>> {
+    type TTo = GetDecoderTypeFromItems<TItems>;
+    const fixedSize = sumCodecSizes(items.map(getFixedSize));
+    const maxSize = sumCodecSizes(items.map(getMaxSize)) ?? undefined;
+
+    return createDecoder({
+        ...(fixedSize === null ? { maxSize } : { fixedSize }),
+        read: (bytes: ReadonlyUint8Array | Uint8Array, offset) => {
+            const values = [] as Array<any> & TTo;
+            items.forEach(item => {
+                const [newValue, newOffset] = item.read(bytes, offset);
+                values.push(newValue);
+                offset = newOffset;
+            });
+            return [values, offset];
+        },
+    });
+}
+
+/**
+ * Returns a codec for encoding and decoding tuples.
+ *
+ * This codec serializes tuples by encoding and decoding each item sequentially.
+ *
+ * Unlike the {@link getArrayCodec} codec, each item in the tuple has its own codec
+ * and, therefore, can be of a different type.
+ *
+ * @typeParam TItems - An array of codecs, each corresponding to a tuple element.
+ *
+ * @param items - The codecs for each item in the tuple.
+ * @returns A `FixedSizeCodec` or `VariableSizeCodec` for encoding and decoding tuples.
+ *
+ * @example
+ * Encoding and decoding a tuple with 2 items.
+ * ```ts
+ * const codec = getTupleCodec([fixCodecSize(getUtf8Codec(), 5), getU8Codec()]);
+ *
+ * const bytes = codec.encode(['Alice', 42]);
+ * // 0x416c6963652a
+ * //   |         └── Second item (42)
+ * //   └── First item ("Alice")
+ *
+ * const tuple = codec.decode(bytes);
+ * // ['Alice', 42]
+ * ```
+ *
+ * @remarks
+ * Separate {@link getTupleEncoder} and {@link getTupleDecoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getTupleEncoder([fixCodecSize(getUtf8Encoder(), 5), getU8Encoder()])
+ *   .encode(['Alice', 42]);
+ *
+ * const tuple = getTupleDecoder([fixCodecSize(getUtf8Decoder(), 5), getU8Decoder()])
+ *   .decode(bytes);
+ * ```
+ *
+ * @see {@link getTupleEncoder}
+ * @see {@link getTupleDecoder}
+ */
+export function getTupleCodec<const TItems extends readonly FixedSizeCodec<any>[]>(
+    items: TItems,
+    config?: TupleCodecConfig,
+): FixedSizeCodec<GetEncoderTypeFromItems<TItems>, GetDecoderTypeFromItems<TItems> & GetEncoderTypeFromItems<TItems>>;
+export function getTupleCodec<const TItems extends readonly Codec<any>[]>(
+    items: TItems,
+    config?: TupleCodecConfig,
+): VariableSizeCodec<
+    GetEncoderTypeFromItems<TItems>,
+    GetDecoderTypeFromItems<TItems> & GetEncoderTypeFromItems<TItems>
+>;
+export function getTupleCodec<const TItems extends readonly Codec<any>[]>(
+    items: TItems,
+    config?: TupleCodecConfig,
+): Codec<GetEncoderTypeFromItems<TItems>, GetDecoderTypeFromItems<TItems> & GetEncoderTypeFromItems<TItems>> {
+    return combineCodec(
+        getTupleEncoder(items, config),
+        getTupleDecoder(items) as Decoder<GetDecoderTypeFromItems<TItems> & GetEncoderTypeFromItems<TItems>>,
+    );
+}

package/src/union.ts

@@ -0,0 +1,257 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import {
+    Codec,
+    combineCodec,
+    createDecoder,
+    createEncoder,
+    Decoder,
+    Encoder,
+    FixedSizeCodec,
+    FixedSizeDecoder,
+    FixedSizeEncoder,
+    getEncodedSize,
+    isFixedSize,
+    Offset,
+    ReadonlyUint8Array,
+} from '@solana/codecs-core';
+import { SOLANA_ERROR__CODECS__UNION_VARIANT_OUT_OF_RANGE, SolanaError } from '@solana/errors';
+
+import { DrainOuterGeneric, getMaxSize, maxCodecSizes } from './utils';
+
+/**
+ * Infers the TypeScript type for values that can be encoded using a union codec.
+ *
+ * This type maps the provided variant encoders to their corresponding value types.
+ *
+ * @typeParam TVariants - An array of encoders, each corresponding to a union variant.
+ */
+type GetEncoderTypeFromVariants<TVariants extends readonly Encoder<any>[]> = DrainOuterGeneric<{
+    [I in keyof TVariants]: TVariants[I] extends Encoder<infer TFrom> ? TFrom : never;
+}>[number];
+
+/**
+ * Infers the TypeScript type for values that can be decoded using a union codec.
+ *
+ * This type maps the provided variant decoders to their corresponding value types.
+ *
+ * @typeParam TVariants - An array of decoders, each corresponding to a union variant.
+ */
+type GetDecoderTypeFromVariants<TVariants extends readonly Decoder<any>[]> = DrainOuterGeneric<{
+    [I in keyof TVariants]: TVariants[I] extends Decoder<infer TFrom> ? TFrom : never;
+}>[number];
+
+type UnionEncoder<TVariants extends readonly Encoder<unknown>[]> = TVariants extends readonly FixedSizeEncoder<any>[]
+    ? FixedSizeEncoder<GetEncoderTypeFromVariants<TVariants>>
+    : Encoder<GetEncoderTypeFromVariants<TVariants>>;
+
+type UnionDecoder<TVariants extends readonly Decoder<unknown>[]> = TVariants extends readonly FixedSizeDecoder<any>[]
+    ? FixedSizeDecoder<GetDecoderTypeFromVariants<TVariants>>
+    : Decoder<GetDecoderTypeFromVariants<TVariants>>;
+
+type UnionCodec<TVariants extends readonly Codec<unknown>[]> = TVariants extends readonly FixedSizeCodec<any>[]
+    ? FixedSizeCodec<
+          GetEncoderTypeFromVariants<TVariants>,
+          GetDecoderTypeFromVariants<TVariants> & GetEncoderTypeFromVariants<TVariants>
+      >
+    : Codec<
+          GetEncoderTypeFromVariants<TVariants>,
+          GetDecoderTypeFromVariants<TVariants> & GetEncoderTypeFromVariants<TVariants>
+      >;
+
+/**
+ * Returns an encoder for union types.
+ *
+ * This encoder serializes values by selecting the correct variant encoder
+ * based on the `getIndexFromValue` function.
+ *
+ * Unlike other codecs, this encoder does not store the variant index.
+ * It is the user's responsibility to manage discriminators separately.
+ *
+ * For more details, see {@link getUnionCodec}.
+ *
+ * @typeParam TVariants - An array of encoders, each corresponding to a union variant.
+ *
+ * @param variants - The encoders for each variant of the union.
+ * @param getIndexFromValue - A function that determines the variant index from the provided value.
+ * @returns An `Encoder` for encoding union values.
+ *
+ * @example
+ * Encoding a union of numbers and booleans.
+ * ```ts
+ * const encoder = getUnionEncoder(
+ *   [getU16Encoder(), getBooleanEncoder()],
+ *   value => (typeof value === 'number' ? 0 : 1)
+ * );
+ *
+ * encoder.encode(42);
+ * // 0x2a00
+ * //   └── Encoded number (42) as `u16`
+ *
+ * encoder.encode(true);
+ * // 0x01
+ * //   └── Encoded boolean (`true`) as `u8`
+ * ```
+ *
+ * @see {@link getUnionCodec}
+ */
+export function getUnionEncoder<const TVariants extends readonly Encoder<any>[]>(
+    variants: TVariants,
+    getIndexFromValue: (value: GetEncoderTypeFromVariants<TVariants>) => number,
+): UnionEncoder<TVariants> {
+    type TFrom = GetEncoderTypeFromVariants<TVariants>;
+    const fixedSize = getUnionFixedSize(variants);
+    const write: Encoder<TFrom>['write'] = (variant, bytes, offset) => {
+        const index = getIndexFromValue(variant);
+        assertValidVariantIndex(variants, index);
+        return variants[index].write(variant, bytes, offset);
+    };
+
+    if (fixedSize !== null) {
+        return createEncoder({ fixedSize, write }) as UnionEncoder<TVariants>;
+    }
+
+    const maxSize = getUnionMaxSize(variants);
+    return createEncoder({
+        ...(maxSize !== null ? { maxSize } : {}),
+        getSizeFromValue: variant => {
+            const index = getIndexFromValue(variant);
+            assertValidVariantIndex(variants, index);
+            return getEncodedSize(variant, variants[index]);
+        },
+        write,
+    }) as UnionEncoder<TVariants>;
+}
+
+/**
+ * Returns a decoder for union types.
+ *
+ * This decoder deserializes values by selecting the correct variant decoder
+ * based on the `getIndexFromBytes` function.
+ *
+ * Unlike other codecs, this decoder does not assume a stored discriminator.
+ * It is the user's responsibility to manage discriminators separately.
+ *
+ * For more details, see {@link getUnionCodec}.
+ *
+ * @typeParam TVariants - An array of decoders, each corresponding to a union variant.
+ *
+ * @param variants - The decoders for each variant of the union.
+ * @param getIndexFromBytes - A function that determines the variant index from the byte array.
+ * @returns A `Decoder` for decoding union values.
+ *
+ * @example
+ * Decoding a union of numbers and booleans.
+ * ```ts
+ * const decoder = getUnionDecoder(
+ *   [getU16Decoder(), getBooleanDecoder()],
+ *   (bytes, offset) => (bytes.length - offset > 1 ? 0 : 1)
+ * );
+ *
+ * decoder.decode(new Uint8Array([0x2a, 0x00])); // 42
+ * decoder.decode(new Uint8Array([0x01]));       // true
+ * // Type is inferred as `number | boolean`
+ * ```
+ *
+ * @see {@link getUnionCodec}
+ */
+export function getUnionDecoder<const TVariants extends readonly Decoder<any>[]>(
+    variants: TVariants,
+    getIndexFromBytes: (bytes: ReadonlyUint8Array, offset: Offset) => number,
+): UnionDecoder<TVariants> {
+    type TTo = GetDecoderTypeFromVariants<TVariants>;
+    const fixedSize = getUnionFixedSize(variants);
+    const read: Decoder<TTo>['read'] = (bytes, offset) => {
+        const index = getIndexFromBytes(bytes, offset);
+        assertValidVariantIndex(variants, index);
+        return variants[index].read(bytes, offset);
+    };
+
+    if (fixedSize !== null) {
+        return createDecoder({ fixedSize, read }) as UnionDecoder<TVariants>;
+    }
+
+    const maxSize = getUnionMaxSize(variants);
+    return createDecoder({ ...(maxSize !== null ? { maxSize } : {}), read }) as UnionDecoder<TVariants>;
+}
+
+/**
+ * Returns a codec for encoding and decoding union types.
+ *
+ * This codec serializes and deserializes union values by selecting the correct variant
+ * based on the provided index functions.
+ *
+ * Unlike the {@link getDiscriminatedUnionCodec}, this codec does not assume a stored
+ * discriminator and must be used with an explicit mechanism for managing discriminators.
+ *
+ * @typeParam TVariants - An array of codecs, each corresponding to a union variant.
+ *
+ * @param variants - The codecs for each variant of the union.
+ * @param getIndexFromValue - A function that determines the variant index from the provided value.
+ * @param getIndexFromBytes - A function that determines the variant index from the byte array.
+ * @returns A `Codec` for encoding and decoding union values.
+ *
+ * @example
+ * Encoding and decoding a union of numbers and booleans.
+ * ```ts
+ * const codec = getUnionCodec(
+ *   [getU16Codec(), getBooleanCodec()],
+ *   value => (typeof value === 'number' ? 0 : 1),
+ *   (bytes, offset) => (bytes.length - offset > 1 ? 0 : 1)
+ * );
+ *
+ * const bytes1 = codec.encode(42); // 0x2a00
+ * const value1: number | boolean = codec.decode(bytes1); // 42
+ *
+ * const bytes2 = codec.encode(true); // 0x01
+ * const value2: number | boolean = codec.decode(bytes2); // true
+ * ```
+ *
+ * @remarks
+ * If you need a codec that includes a stored discriminator,
+ * consider using {@link getDiscriminatedUnionCodec}.
+ *
+ * Separate {@link getUnionEncoder} and {@link getUnionDecoder} functions are also available.
+ *
+ * ```ts
+ * const bytes = getUnionEncoder(variantEncoders, getIndexFromValue).encode(42);
+ * const value = getUnionDecoder(variantDecoders, getIndexFromBytes).decode(bytes);
+ * ```
+ *
+ * @see {@link getUnionEncoder}
+ * @see {@link getUnionDecoder}
+ * @see {@link getDiscriminatedUnionCodec}
+ */
+export function getUnionCodec<const TVariants extends readonly Codec<any>[]>(
+    variants: TVariants,
+    getIndexFromValue: (value: GetEncoderTypeFromVariants<TVariants>) => number,
+    getIndexFromBytes: (bytes: ReadonlyUint8Array, offset: Offset) => number,
+): UnionCodec<TVariants> {
+    return combineCodec(
+        getUnionEncoder(variants, getIndexFromValue),
+        getUnionDecoder(variants as readonly Decoder<any>[], getIndexFromBytes) as Decoder<
+            GetDecoderTypeFromVariants<TVariants> & GetEncoderTypeFromVariants<TVariants>
+        >,
+    ) as UnionCodec<TVariants>;
+}
+
+function assertValidVariantIndex(variants: readonly unknown[], index: number) {
+    if (typeof variants[index] === 'undefined') {
+        throw new SolanaError(SOLANA_ERROR__CODECS__UNION_VARIANT_OUT_OF_RANGE, {
+            maxRange: variants.length - 1,
+            minRange: 0,
+            variant: index,
+        });
+    }
+}
+
+function getUnionFixedSize<const TVariants extends readonly (Decoder<any> | Encoder<any>)[]>(variants: TVariants) {
+    if (variants.length === 0) return 0;
+    if (!isFixedSize(variants[0])) return null;
+    const variantSize = variants[0].fixedSize;
+    const sameSizedVariants = variants.every(variant => isFixedSize(variant) && variant.fixedSize === variantSize);
+    return sameSizedVariants ? variantSize : null;
+}
+
+function getUnionMaxSize<const TVariants extends readonly (Decoder<any> | Encoder<any>)[]>(variants: TVariants) {
+    return maxCodecSizes(variants.map(variant => getMaxSize(variant)));
+}

package/src/unit.ts

@@ -0,0 +1,111 @@
+import {
+    combineCodec,
+    createDecoder,
+    createEncoder,
+    FixedSizeCodec,
+    FixedSizeDecoder,
+    FixedSizeEncoder,
+    ReadonlyUint8Array,
+} from '@solana/codecs-core';
+
+/**
+ * Returns an encoder for `void` values.
+ *
+ * This encoder writes nothing to the byte array and has a fixed size of 0 bytes.
+ * It is useful when working with structures that require a no-op encoder,
+ * such as empty variants in {@link getDiscriminatedUnionEncoder}.
+ *
+ * For more details, see {@link getUnitCodec}.
+ *
+ * @returns A `FixedSizeEncoder<void, 0>`, representing an empty encoder.
+ *
+ * @example
+ * Encoding a `void` value.
+ * ```ts
+ * getUnitEncoder().encode(undefined); // Produces an empty byte array.
+ * ```
+ *
+ * @see {@link getUnitCodec}
+ */
+export function getUnitEncoder(): FixedSizeEncoder<void, 0> {
+    return createEncoder({
+        fixedSize: 0,
+        write: (_value, _bytes, offset) => offset,
+    });
+}
+
+/**
+ * Returns a decoder for `void` values.
+ *
+ * This decoder always returns `undefined` and has a fixed size of 0 bytes.
+ * It is useful when working with structures that require a no-op decoder,
+ * such as empty variants in {@link getDiscriminatedUnionDecoder}.
+ *
+ * For more details, see {@link getUnitCodec}.
+ *
+ * @returns A `FixedSizeDecoder<void, 0>`, representing an empty decoder.
+ *
+ * @example
+ * Decoding a `void` value.
+ * ```ts
+ * getUnitDecoder().decode(anyBytes); // Returns `undefined`.
+ * ```
+ *
+ * @see {@link getUnitCodec}
+ */
+export function getUnitDecoder(): FixedSizeDecoder<void, 0> {
+    return createDecoder({
+        fixedSize: 0,
+        read: (_bytes: ReadonlyUint8Array | Uint8Array, offset) => [undefined, offset],
+    });
+}
+
+/**
+ * Returns a codec for `void` values.
+ *
+ * This codec does nothing when encoding or decoding and has a fixed size of 0 bytes.
+ * Namely, it always returns `undefined` when decoding and produces an empty byte array when encoding.
+ *
+ * This can be useful when working with structures that require a no-op codec,
+ * such as empty variants in {@link getDiscriminatedUnionCodec}.
+ *
+ * @returns A `FixedSizeCodec<void, void, 0>`, representing an empty codec.
+ *
+ * @example
+ * Encoding and decoding a `void` value.
+ * ```ts
+ * const codec = getUnitCodec();
+ *
+ * codec.encode(undefined); // Produces an empty byte array.
+ * codec.decode(new Uint8Array([])); // Returns `undefined`.
+ * ```
+ *
+ * @example
+ * Using unit codecs as empty variants in a discriminated union.
+ * ```ts
+ * type Message =
+ *   | { __kind: 'Enter' }
+ *   | { __kind: 'Leave' }
+ *   | { __kind: 'Move'; x: number; y: number };
+ *
+ * const messageCodec = getDiscriminatedUnionCodec([
+ *   ['Enter', getUnitCodec()], // <- No-op codec for empty data
+ *   ['Leave', getUnitCodec()], // <- No-op codec for empty data
+ *   ['Move', getStructCodec([...])]
+ * ]);
+ * ```
+ *
+ * @remarks
+ * Separate {@link getUnitEncoder} and {@link getUnitDecoder} functions are available.
+ *
+ * ```ts
+ * const bytes = getUnitEncoder().encode();
+ * const value = getUnitDecoder().decode(bytes);
+ * ```
+ *
+ * @see {@link getUnitEncoder}
+ * @see {@link getUnitDecoder}
+ */
+export function getUnitCodec(): FixedSizeCodec<void, void, 0> {
+    return combineCodec(getUnitEncoder(), getUnitDecoder());
+}

package/src/utils.ts

@@ -0,0 +1,32 @@
+import { isFixedSize } from '@solana/codecs-core';
+
+/**
+ * Functionally, this type helper is equivalent to the identity type — i.e. `type Identity<T> = T`.
+ * However, wrapping generic object mappings in this type significantly reduces the number
+ * of instantiation expressions processed, which increases TypeScript performance and
+ * prevents "Type instantiation is excessively deep and possibly infinite" errors.
+ *
+ * This works because TypeScript doesn't create a new level of nesting when encountering conditional generic types.
+ * @see https://github.com/microsoft/TypeScript/issues/34933
+ * @see https://github.com/kysely-org/kysely/pull/483
+ */
+export type DrainOuterGeneric<T> = [T] extends [unknown] ? T : never;
+
+export function maxCodecSizes(sizes: (number | null)[]): number | null {
+    return sizes.reduce(
+        (all, size) => (all === null || size === null ? null : Math.max(all, size)),
+        0 as number | null,
+    );
+}
+
+export function sumCodecSizes(sizes: (number | null)[]): number | null {
+    return sizes.reduce((all, size) => (all === null || size === null ? null : all + size), 0 as number | null);
+}
+
+export function getFixedSize(codec: { fixedSize: number } | { maxSize?: number }): number | null {
+    return isFixedSize(codec) ? codec.fixedSize : null;
+}
+
+export function getMaxSize(codec: { fixedSize: number } | { maxSize?: number }): number | null {
+    return isFixedSize(codec) ? codec.fixedSize : (codec.maxSize ?? null);
+}