Why can't I infer Type like more basic generic objects, without hoisting generics?

[inducingchaos]

I apologize if this is unclear, I don't really know how to specify this lol. Most of the code is just contextual complexity, demonstrating the difference I'm highlighting - but I simplified it to only depend on TypeScript and ArkType.

I want to use Type, Type["infer"], and type in a very similar way that I use DynamicType and createDynamicType below.

In my mind, this should just work... maybe ArkType's internals (I saw some NoInfer's somewhere) prevent this. I achieved genericness like this before by generic-drilling all the way down from the create function, but unfortunately with records, this is an impossible feat if you want separate types for separate keys.

The solution (for my basic implementation) was to NOT use generics, and use a validator type in the function only - read more about this here.

Am I missing something here, maybe an alias type or pattern specific to ArkType?

P.S. I switched from Zod for the serializable aspect and I ❤️ it so far. You guys are killing it.

import { type, Type } from "arktype"

/**
 * Expands branded types for better readability. Preserves built-in types.
 */
export type Expand<Type, Except = never> = Type extends Except
    ? Type
    : Type extends Array<infer Item>
      ? Array<Expand<Item, Except>>
      : Type extends (...args: never[]) => unknown
        ? Type
        : Type extends Date
          ? Date
          : Type extends RegExp
            ? RegExp
            : Type extends Map<infer Key, infer Value>
              ? Map<Expand<Key, Except>, Expand<Value, Except>>
              : Type extends Set<infer Item>
                ? Set<Expand<Item, Except>>
                : Type extends object
                  ? {
                        [Key in keyof Type as Key extends string ? (string extends Key ? never : Key) : Key]: Expand<
                            Type[Key],
                            Except
                        >
                    }
                  : Type

//  Drop-in replacement to mock the behavior of an ArkType `Type`, for demonstration purposes.

type DynamicTypePrimitiveMap = {
    string: string
    number: number
    boolean: boolean
    unknown: unknown
}

type DynamicTypePrimitiveName = Expand<keyof DynamicTypePrimitiveMap>
type DynamicTypeArrayName = `${DynamicTypePrimitiveName}[]`
type DynamicTypeName = DynamicTypePrimitiveName | DynamicTypeArrayName

type InferDynamicType<Name extends DynamicTypeName> = Name extends `${infer InferredName extends DynamicTypePrimitiveName}[]`
    ? DynamicTypePrimitiveMap[InferredName][]
    : Name extends DynamicTypePrimitiveName
      ? DynamicTypePrimitiveMap[Name]
      : never

/* --- START IMPORTANT --- */

//  1 - Demo implementation of a `DynamicType` that is not based on ArkType.

// type DynamicType<Name extends DynamicTypeName = DynamicTypeName> = {
//     name: Name
//     infer: InferDynamicType<Name>
// }

// function createDynamicType<Name extends DynamicTypeName>(name: Name): DynamicType<Name> {
//     return { name } as DynamicType<Name>
// }

//  2 - Workaround to carry an ArkType schema.

type DynamicType<Name extends DynamicTypeName = DynamicTypeName> = {
    name: Name
    infer: InferDynamicType<Name>
    schema: Type<InferDynamicType<Name>>
}

function createDynamicType<Name extends DynamicTypeName>(name: Name): DynamicType<Name> {
    return { name, schema: type(name as Parameters<typeof type>[0]) } as DynamicType<Name>
}

//  3 - Try uncommenting the following aliases... they should work (in the same way that the previous implementation does, but they don't). All parameters are inferred as `unknown` - see errors.

// type DynamicType = Type
// const createDynamicType = type

/* --- END IMPORTANT --- */

//  Types for the `DataConstraint` parameter configurations.

type DataConstraintParamConfigBase = { name: string; description: string }

type ValueDataConstraintParamConfigBase = { type: "value"; schema: DynamicType }
type OptionalValueDataConstraintParamConfig = DataConstraintParamConfigBase &
    ValueDataConstraintParamConfigBase & { required: false; default: DynamicType["infer"] | null }
type RequiredValueDataConstraintParamConfig = DataConstraintParamConfigBase &
    ValueDataConstraintParamConfigBase & { required: true }
type ValueDataConstraintParamConfig = OptionalValueDataConstraintParamConfig | RequiredValueDataConstraintParamConfig

type GroupDataConstraintParamConfig = DataConstraintParamConfigBase & {
    type: "group"
    required: boolean
    options: Record<string, DataConstraintParamConfig>
}

type DataConstraintParamConfig = ValueDataConstraintParamConfig | GroupDataConstraintParamConfig
type DataConstraintParamsConfig = Record<string, DataConstraintParamConfig>

/**
 * Re-maps the named keys of the parameter configurations to their respective inferred values.
 */
type InferDataConstraintParams<Params extends DataConstraintParamsConfig> = Expand<{
    [Key in keyof Params]: Params[Key] extends ValueDataConstraintParamConfig
        ? Params[Key]["required"] extends true
            ? Params[Key]["schema"]["infer"]
            : Params[Key]["schema"]["infer"] | null
        : Params[Key] extends GroupDataConstraintParamConfig
          ? Params[Key]["required"] extends true
              ? InferDataConstraintParams<Params[Key]["options"]>
              : InferDataConstraintParams<Params[Key]["options"]> | null
          : never
}>

//  The core constraint configuration.

type DataConstraintConfig<
    ParamsConfig extends DataConstraintParamsConfig = DataConstraintParamsConfig,
    Type extends DynamicType = DynamicType,
    Params = InferDataConstraintParams<ParamsConfig>
> = {
    name: string
    type: Type
    params: ParamsConfig
    label?: (props: { config: DataConstraintConfig<ParamsConfig, Type, Params>; params: Params }) => string
    instructions?: (props: { config: DataConstraintConfig<ParamsConfig, Type, Params>; params: Params }) => string
    validate?: (props: {
        config: DataConstraintConfig<ParamsConfig, Type, Params>
        params: Params
    }) => (value: Type["infer"]) => boolean
}

type ValidateDataConstraintParamConfig<Param extends DataConstraintParamConfig> = Param extends ValueDataConstraintParamConfig
    ? Param extends RequiredValueDataConstraintParamConfig
        ? Omit<Param, "default"> & { default?: `\`never\` when \`required\` is set to \`true\`` }
        : Omit<ValueDataConstraintParamConfig, "default"> & { default: Param["schema"]["infer"] | null }
    : Param extends GroupDataConstraintParamConfig
      ? Omit<GroupDataConstraintParamConfig, "options"> & { options: ValidateDataConstraintParamsConfig<Param["options"]> }
      : DataConstraintParamConfig

/**
 * Recursively validates all parameter configurations.
 */
type ValidateDataConstraintParamsConfig<Params extends DataConstraintParamsConfig> = {
    [Key in keyof Params]: ValidateDataConstraintParamConfig<Params[Key]>
}

function createDataConstraintConfig<
    Type extends DynamicType,
    Params extends ValidateDataConstraintParamsConfig<Params>,
    Result extends Expand<DataConstraintConfig<Params, Type>, DynamicType>
>(props: DataConstraintConfig<Params, Type>): Result {
    return props as Result
}

//  The implementation.

export const enumConstraintConfig = createDataConstraintConfig({
    name: "Enum",
    type: createDynamicType("string"),
    params: {
        options: {
            name: "Options",
            description: "The allowed options for the value. ",
            type: "value",
            required: true,
            schema: createDynamicType("string[]")
        },
        caseSensitive: {
            name: "Case Sensitive",
            description: "Whether the options should be case sensitive.",
            type: "value",
            required: false,
            schema: createDynamicType("boolean"),
            default: true
        },
        multipleOptions: {
            name: "Multiple Options",
            description: "Whether more than one option can be specified.",
            type: "group",
            required: false,
            options: {
                limit: {
                    name: "Limit",
                    description: "The maximum number of options that can be specified.",
                    type: "value",
                    required: false,
                    schema: createDynamicType("number"),
                    default: 1
                },
                separators: {
                    name: "Separators",
                    description: "The allowed delimiters for separating the options.",
                    type: "value",
                    required: false,
                    schema: createDynamicType("string[]"),
                    default: [", ", " "]
                }
            }
        }
    },
    label: ({ config, params }) => `${config.name}: ${params.options.join(", ")}`,
    instructions: ({ config, params }) =>
        `The value can contain ${params.multipleOptions?.limit ? `up to ${params.multipleOptions?.limit}` : params.multipleOptions?.limit === 1 ? "one" : "any"} of the following options${params.multipleOptions?.limit ? `, separated by '${(params.multipleOptions?.separators ?? config.params.multipleOptions.options.separators.default).join("', '")}'` : ""}: ${params.options.join(", ")}`,
    validate:
        ({ config, params }) =>
        value => {
            const separators = params.multipleOptions?.separators ?? config.params.multipleOptions.options.separators.default
            const options = separators.flatMap(separator => value.split(separator))
            const casedOptions = params.caseSensitive ? options : options.map(option => option.toLowerCase())

            const allowedOptions = params.options
            const casedAllowedOptions = params.caseSensitive
                ? allowedOptions
                : allowedOptions.map(option => option.toLowerCase())

            const isMatching = casedOptions.every(option => casedAllowedOptions.includes(option))

            const limit = params.multipleOptions?.limit ?? config.params.multipleOptions.options.limit.default
            const isLimitReached = !!limit && options.length > limit

            return isMatching && !isLimitReached
        }
})

[inducingchaos]

Just looking back on this, to make it a bit clearer:

ArkType's Type and type should be a drop-in replacement. How can I get them to work properly?

For example with my original workaround, in my instructions function, params.multipleOptions is inferred as

(property) multipleOptions: {
    limit: number | null;
    separators: string[] | null;
} | null

But when I uncomment the aliases, I get:

(property) multipleOptions: {
    limit: unknown;
    separators: unknown;
} | null

Any ideas?