import type { TextInput, LongTextInput, NumberInput, BooleanInput, ColorInput, FileInput, LexicalInput, SelectInput, RadioInput, ObjectInput, DateTimeInput, ComponentInput, TagsInput, SlotInput, ContentEntryInput } from "./types.js"; import { functionConverter } from "~/FunctionConverter.js"; export type InputFactory = | ReturnType> | ReturnType> | ReturnType> | ReturnType> | ReturnType> | ReturnType> | ReturnType> | ReturnType> | ReturnType> | ReturnType> | ReturnType> | ReturnType> | ReturnType> | ReturnType>; /** * TypeScript Overload Resolution and Input Factory Design * * Each input factory (e.g., createTextInput) is defined with two TypeScript overload signatures: * 1. One overload requires a `name` property in the input (used for array-based APIs, where inference is needed). * 2. The other overload omits the `name` property (used for object-based APIs, where the key provides the name). * * TypeScript resolves overloads by scanning from top to bottom and picking the first matching signature. * The implementation signature uses `any` for the argument, and the return type is unified to match all overloads. * * In array mode, the `name` must be explicitly provided in the input object, so inference for `TName` works. * In object mode, the input does not require a `name` property; instead, the key in the object (e.g., `{ foo: createTextInput({ ... }) }`) * provides the name via contextual typing from the consuming function (such as `createComponent`). TypeScript uses this context * to resolve the correct type for `TName` even when `name` is omitted from the input. * * This pattern ensures that all returned input objects are typed as `{ name: TName }`, whether `name` is provided explicitly or inferred, * so consumers of these factories do not need to worry about the presence of the `name` property in the result. */ // Text export function createTextInput( input: { name: TName } & Omit ): TextInput & { name: TName }; export function createTextInput( input: Omit ): TextInput & { name: TName }; export function createTextInput(input: any): TextInput & { name: TName } { return createInput({ type: "text", renderer: "Webiny/Input", ...input }) as TextInput & { name: TName }; } // Long Text export function createLongTextInput( input: { name: TName } & Omit ): LongTextInput & { name: TName }; export function createLongTextInput( input: Omit ): LongTextInput & { name: TName }; export function createLongTextInput( input: any ): LongTextInput & { name: TName } { return createInput({ type: "longText", renderer: "Webiny/Textarea", ...input }) as LongTextInput & { name: TName }; } // Number export function createNumberInput( input: { name: TName } & Omit ): NumberInput & { name: TName }; export function createNumberInput( input: Omit ): NumberInput & { name: TName }; export function createNumberInput(input: any): NumberInput & { name: TName } { return createInput({ type: "number", renderer: "Webiny/Number", ...input }) as NumberInput & { name: TName }; } // Boolean export function createBooleanInput( input: { name: TName } & Omit ): BooleanInput & { name: TName }; export function createBooleanInput( input: Omit ): BooleanInput & { name: TName }; export function createBooleanInput( input: any ): BooleanInput & { name: TName } { return createInput({ type: "boolean", renderer: "Webiny/Switch", ...input }) as BooleanInput & { name: TName }; } // Color export function createColorInput( input: { name: TName } & Omit ): ColorInput & { name: TName }; export function createColorInput( input: Omit ): ColorInput & { name: TName }; export function createColorInput(input: any): ColorInput & { name: TName } { return createInput({ type: "color", renderer: "Webiny/ColorPicker", ...input }) as ColorInput & { name: TName }; } // File export function createFileInput( input: { name: TName } & Omit ): FileInput & { name: TName }; export function createFileInput( input: Omit ): FileInput & { name: TName }; export function createFileInput(input: any): FileInput & { name: TName } { return createInput({ type: "file", renderer: "Webiny/FileManager", ...input }) as FileInput & { name: TName }; } // Date export function createDateInput( input: { name: TName } & Omit ): DateTimeInput & { name: TName }; export function createDateInput( input: Omit ): DateTimeInput & { name: TName }; export function createDateInput(input: any): DateTimeInput & { name: TName } { return createInput({ type: "datetime", renderer: "Webiny/DateTime", ...input }) as DateTimeInput & { name: TName }; } // Rich Text export function createLexicalInput( input: { name: TName } & Omit ): LexicalInput & { name: TName }; export function createLexicalInput( input: Omit ): LexicalInput & { name: TName }; export function createLexicalInput( input: any ): LexicalInput & { name: TName } { return createInput({ type: "lexical", renderer: "Webiny/Lexical", ...input }) as LexicalInput & { name: TName }; } // Select export function createSelectInput( input: { name: TName } & Omit ): SelectInput & { name: TName }; export function createSelectInput( input: Omit ): SelectInput & { name: TName }; export function createSelectInput(input: any): SelectInput & { name: TName } { return createInput({ type: "select", renderer: "Webiny/Select", ...input }) as SelectInput & { name: TName }; } // Radio export function createRadioInput( input: { name: TName } & Omit ): RadioInput & { name: TName }; export function createRadioInput( input: Omit ): RadioInput & { name: TName }; export function createRadioInput(input: any): RadioInput & { name: TName } { return createInput({ type: "radio", renderer: "Webiny/RadioGroup", ...input }) as RadioInput & { name: TName }; } // Object export function createObjectInput( input: { name: TName } & Omit ): ObjectInput & { name: TName }; export function createObjectInput( input: Omit ): ObjectInput & { name: TName }; export function createObjectInput(input: any): ObjectInput & { name: TName } { return createInput({ type: "object", renderer: "Webiny/Object", ...input }) as ObjectInput & { name: TName }; } // Tags export function createTagsInput( input: { name: TName } & Omit ): TagsInput & { name: TName }; export function createTagsInput( input: Omit ): TagsInput & { name: TName }; export function createTagsInput(input: any): TagsInput & { name: TName } { return createInput({ type: "text", list: true, renderer: "Webiny/Tags", ...input }) as TagsInput & { name: TName }; } export function createSlotInput( input: { name: TName } & Omit ): SlotInput & { name: TName }; export function createSlotInput( input: Omit ): SlotInput & { name: TName }; export function createSlotInput(input: any): SlotInput & { name: TName } { return createInput({ type: "slot", list: true, renderer: "Webiny/Slot", defaultValue: [], ...input }) as SlotInput & { name: TName }; } // Content Entry export function createContentEntryInput( input: { name: TName } & Omit ): ContentEntryInput & { name: TName }; export function createContentEntryInput( input: Omit ): ContentEntryInput & { name: TName }; export function createContentEntryInput( input: any ): ContentEntryInput & { name: TName } { return createInput({ type: "contentEntry", renderer: "Webiny/ContentEntry", ...input }) as ContentEntryInput & { name: TName }; } // Implementation export function createInput(input: ComponentInput): ComponentInput { if (input.onChange) { // @ts-expect-error We don't use this function on the frontend, so this is ok. input.onChange = functionConverter.serialize(input.onChange!); } return input; }