selectizeInput

Web Val: HTTP real, query params, body JSON, respuesta JSON con schema estable. Pensado para escalar a UI + API.

Flujo:

R / Python  →  Web Val (HTTP real)  →  JSON (schema estable)  →  Widget reutilizable

Web Val

HTTP real: GET y POST al val (URL web de Val Town, no api.val.town/v1/run/...).
Query params: GET con ?inputId=...&choices=...&selected=...&min_items=...&max_items=... (choices y selected en JSON string).
Body JSON: POST con el mismo contrato en el body.
Respuesta: siempre JSON (no HTML). El widget se renderiza donde consumas ese JSON (R, Python, UI, etc.).

Rutas

Método	Ruta	Uso
GET	`/`	API con query params
POST	`/`	API con body JSON
GET	`/api/selectize`	Mismo contrato (escalable)
POST	`/api/selectize`	Mismo contrato (escalable)

Contrato de entrada (R / Python)

Campo	Tipo	Requerido	Descripción
`inputId`	string \| null	No	Id del control (default: `"selectize"`)
`choices`	ver abajo	Sí	Vector, lista de `{value, label?}`, o diccionario nombrado
`selected`	string \| string[] \| null	No	Valor o valores seleccionados (default: `[]`)
`min_items`	number \| null	No	Mínimo de ítems (default: `0`)
`max_items`	number \| null	No	Máximo (default: número de opciones)

Formas de choices: vector ["a","b"], objetos [{value:"a",label:"A"}], o dict {"a":"A","b":"B"}. Se tolera NULL/None en opcionales.

Schema estable de respuesta (JSON)

Éxito (200):

{
  "ok": true,
  "data": {
    "inputId": "string",
    "options": [
      { "value": "string", "label": "string", "selected": true }
    ],
    "min_items": 0,
    "max_items": 3
  }
}

Error (400):

{
  "ok": false,
  "error": {
    "code": "INVALID_SELECTION",
    "message": "Selected value(s) not in choices: ..."
  }
}

Códigos de error: MIN_MAX_INCOHERENT, MAX_EXCEEDS_OPTIONS, INVALID_SELECTION, BELOW_MIN_ITEMS, ABOVE_MAX_ITEMS, PARSE_ERROR, MISSING_CHOICES, INVALID_BODY.

Ejemplo R

base <- "https://TU_USUARIO-selectizeInput.web.val.run"

body <- list(
  inputId = "mi_selector",
  choices = list(a = "Opción A", b = "Opción B", c = "Opción C"),
  selected = c("a", "b"),
  min_items = 1L,
  max_items = 3L
)

res <- httr::POST(paste0(base, "/"), body = body, encode = "json")
json <- httr::content(res, "parsed")

# json$ok == TRUE → json$data (inputId, options, min_items, max_items)
# json$ok == FALSE → json$error (code, message)
# Con json$data puedes renderizar el widget donde quieras

Ejemplo Python

import requests

base = "https://TU_USUARIO-selectizeInput.web.val.run"
payload = {
    "inputId": "mi_selector",
    "choices": {"a": "Opción A", "b": "Opción B", "c": "Opción C"},
    "selected": ["a", "b"],
    "min_items": 1,
    "max_items": 3,
}

r = requests.post(f"{base}/", json=payload)
data = r.json()

# data["ok"] → data["data"] (inputId, options, min_items, max_items)
# data["ok"] == False → data["error"] (code, message)

Estructura del repo

selectizeInput.http.ts: Web Val autocontenido (sin imports relativos; único archivo que sube Val Town).
shared/types.ts: Contrato y modelos internos (desarrollo local).
shared/api-schema.ts: Schema estable de la respuesta API (desarrollo local).
backend/: Normalización, validación, render (desarrollo local; el val inlined todo en un solo archivo).

Escalar a UI + API

El mismo endpoint devuelve JSON. Puedes:

Consumir desde R/Python y construir tu propio widget con data.options, data.inputId, etc.
Añadir después una ruta (ej. /widget o /ui) que devuelva HTML generado a partir del mismo flujo, o un front que llame a / o /api/selectize y renderice con el JSON.