DeReplicateStatic

[sroussey]

I have a utility TypeReplicateArray that generates a union of a type and an array of that type (so string => string | string[] etc). With the keyword replicate in there so at runtime I can do something special. This all works fine.

export const TypeReplicateArray = <T extends TSchema>(
  type: T,
  annotations: Record<string, unknown> = {}
) =>
  Type.Union([type, Type.Array(type)], {
    title: type.title,
    description: type.description,
    ...annotations,
    replicate: true,
  });

So

export const Example = Type.Object({
  name: TypeReplicateArray(
    Type.String({
      title: "Name"
    })
  ),
  company: Type.Union([Type.String(), Type.Array(Type.String())],{
     title: "Company"
   })
})

type TypeExample = Static<typeof Example>;

And the type of TypeExample is

type TypeExample = {
   name: string | string[];
   company: string | string[];
}

This is fine. But I want a version where I simplify the ones marked replicate from string|string[] back to just string

type UnwrapArrayUnion<T> = T extends Array<infer U> | infer U ? U : T;
export type DeReplicateStatic<T extends TSchema> = {
  [K in keyof Static<T>]: UnwrapArrayUnion<Static<T>[K]>;
};
type TypeExample2 = DeReplicateStatic<typeof Example>;

gives me

type TypeExample2 = {
    name: string;
    company: string;
}

But I am having a hard figuring out how to do it just for the one using TypeReplicateArray (marking with replicate:true). What I want is:

type TypeExample2 = {
    name: string;
    company: string | string[];
}

Sometimes I want name: string and sometimes I want name: string | string[]. I have not been able to find a way.

Should I register a new type with [Kind]: "ReplicateOptionalArray" or something? I would like to find a "TypeBox" way.

[sroussey]

Well, after I wrote this all up, I decided to let AI have a crack and it gave me this:

export function TypeReplicateArray<T extends TSchema>(
  type: T,
  annotations?: SchemaOptions
): TUnion<[T, TArray<T>]> & { replicate: true } {
  return Type.Union([type, Type.Array(type)], {
    ...(annotations as object),
    replicate: true,
  }) as any;
}

type UnwrapArrayUnion<T> = T extends Array<infer U> | infer U ? U : T;
type Properties<S extends TObject<any>> = S extends TObject<infer P> ? P : never;
export type DeReplicateStatic<S extends TObject<any>> = {
  [K in keyof Properties<S>]: Properties<S>[K] extends { replicate: true }
    ? UnwrapArrayUnion<Static<Properties<S>[K]>>
    : Static<Properties<S>[K]>;
};

Which does indeed give me the TypeExample and TypeExample2 types I want. Any thoughts?