Skip to content

ChronicStone/nuxt-ui-tools / skills/consumer/query-state

nuxt-ui-tools-query-state

Verified

Use this skill when building or debugging URL-backed state with nuxt-ui-tools as a package consumer. Covers codecs, useQueryState, useQueryStates, dynamicQueryState, grouped state, dynamic keys, and practical query-string examples.

references/complex-patterns.md

View on GitHub
# Complex Query State Patterns

## Grouped Pagination

```ts
const pagination = useQueryStates({
  prefix: 'p',
  schema: {
    pageIndex: { urlKey: 'page', codec: numberCodec, defaultValue: 1 },
    pageSize: { urlKey: 'size', codec: numberCodec, defaultValue: 20 },
  },
})
```

URL:

```txt
?p.page=2&p.size=50
```

## Grouped Sorting

```ts
const sorting = useQueryStates({
  prefix: 's',
  schema: {
    key: { codec: stringCodec, defaultValue: '' },
    dir: { codec: createEnumCodec(['asc', 'desc']), defaultValue: 'asc' },
  },
})
```

URL:

```txt
?s.key=hiredAt&s.dir=desc
```

## Mixed Static + Dynamic Groups

You can combine fixed grouped keys with a dynamic state entry inside the same grouped abstraction.

```ts
const filters = useQueryStates({
  prefix: 'f',
  schema: {
    search: { codec: stringCodec, defaultValue: '' },
    ui: dynamicQueryState({
      urlPrefix: 'ui',
      definitions: () => filterDefinitions.value,
      defaultValue: [],
      resolve(definition) {
        return definition.operators.map((operator) => ({
          urlKey:
            operator === definition.defaultOperator
              ? definition.key
              : `${definition.key}~${operator}`,
          codec: definition.codec,
        }))
      },
      parse(entries, definitions) {
        return definitions.flatMap((definition) =>
          definition.operators.flatMap((operator) => {
            const urlKey =
              operator === definition.defaultOperator
                ? definition.key
                : `${definition.key}~${operator}`
            const value = entries.get(urlKey)
            return value == null ? [] : [{ key: definition.key, operator, value }]
          }),
        )
      },
      serialize(rules, definitions) {
        return new Map(
          rules.flatMap((rule) => {
            const definition = definitions.find((item) => item.key === rule.key)
            if (!definition) return []

            const urlKey =
              rule.operator === definition.defaultOperator
                ? rule.key
                : `${rule.key}~${rule.operator}`

            return [[urlKey, rule.value]]
          }),
        )
      },
    }),
  },
})
```

This yields a URL shape like:

```txt
?f.search=emma&f.ui.department=Engineering&f.ui.salary~gte=100000
```
brainstormingobra/superpowersYou MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation).Stars: 322kUpdated Claude CodeCodexVerifiedInstall
brand-guidelinesanthropics/skillsApplies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
frontend-designanthropics/skillsGuidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
mcp-builderanthropics/skillsGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).Stars: 198kUpdated Claude CodeCodexVerifiedInstall