Habilidades create-adaptable-composable
📦

create-adaptable-composable

Seguro

Criar Vue Composable Adaptável

Criar Vue composables com tipos de entrada flexíveis é desafiador. Esta skill fornece um padrão para construir composables de nível de biblioteca que aceitam entradas reativas e não reativas usando tipos MaybeRef e MaybeRefOrGetter.

Suporta: Claude Codex Code(CC)
⚠️ 68 Ruim
1

Baixar o ZIP da skill

2

Upload no Claude

Vá em Configurações → Capacidades → Skills → Upload skill

3

Ative e comece a usar

Testar

A utilizar "create-adaptable-composable". Criar um composable useDocumentTitle que aceita um MaybeRefOrGetter para o título

Resultado esperado:

  • import { watch, toRef } from 'vue'
  • import type { MaybeRefOrGetter } from 'vue'
  •  
  • export function useDocumentTitle(title: MaybeRefOrGetter<string>) {
  • watch(toRef(title), (t) => {
  • document.title = t
  • }, { immediate: true })
  • }

A utilizar "create-adaptable-composable". Build um composable useCounter com MaybeRef para contagem inicial

Resultado esperado:

  • import { watch, toRef } from 'vue'
  • import type { MaybeRef } from 'vue'
  •  
  • function useCounter(count: MaybeRef<number>) {
  • const countRef = toRef(count)
  • function add() {
  • countRef.value++
  • }
  • return { add }
  • }

Auditoria de Segurança

Seguro
v1 • 2/9/2026

Static analyzer flagged TypeScript template literals as shell backticks and random text patterns as cryptographic algorithms. All findings are false positives. The skill contains only Vue.js documentation with TypeScript code examples for creating composables. No shell commands, cryptographic code, or security risks exist.

1
Arquivos analisados
77
Linhas analisadas
3
achados
1
Total de auditorias

Problemas de Alto Risco (2)

False Positive: Cryptographic Algorithm Detection
Static analyzer incorrectly flagged text patterns as cryptographic code. Analysis confirms this is Vue.js documentation describing composable design patterns. No MD5, SHA1, DES, or other weak cryptographic algorithms exist in this file.
False Positive: Shell Command Detection
Static analyzer flagged backticks as Ruby/shell command execution. These are TypeScript template literals used throughout the code examples. No shell commands, exec(), system(), or backtick invocation exists.
Problemas de Risco Médio (1)
False Positive: Template Literal Detection
TypeScript template literals flagged as potential external commands. TypeScript uses backticks for multi-line strings and template expressions in code examples.
Auditado por: claude

Pontuação de qualidade

38
Arquitetura
100
Manutenibilidade
87
Conteúdo
32
Comunidade
80
Segurança
91
Conformidade com especificações

O Que Você Pode Construir

Construindo um Gerenciador de Título Somente Leitura

Criar um composable que define o título do documento e aceita título como MaybeRefOrGetter, permitindo strings simples, refs ou funções getter.

Criando um Composable de Contador Gravável

Build a counter composable with MaybeRef input for the initial count, enabling two-way binding with reactive and non-reactive values.

Projetando um Manipulador de Entrada de Formulário Flexível

Projetar composables que aceitam elementos DOM ou destinos computed como MaybeRefOrGetter para manipulação de entrada flexível em vários contextos.

Tente Estes Prompts

Solicitação Básica de Composable
Criar um composable adaptável chamado useUserPreferences que aceita um MaybeRefOrGetter para configuração de tema. O composable deve observar o valor e aplicar o tema ao corpo do documento.
Solicitação de Ligação Bidirecional
Build um composable useLocalStorage que aceita um MaybeRef para o valor inicial e chave. O composable deve sincronizar o valor do ref com localStorage e retornar um ref gravável.
Padrão de Entrada Computed
Criar um composable useDebouncedValue onde a entrada é MaybeRefOrGetter. Usar watch() com toRef() para fontes reativas e retornar um valor computed que atualiza com debounce.
Composable Multi-Entrada
Projetar um composable useFormValidator que aceita múltiplas entradas MaybeRef para valores de campos de formulário e um MaybeRefOrGetter para regras de validação. Normalizar todas as entradas e retornar estado de validação.

Melhores Práticas

  • Usar MaybeRefOrGetter para entradas somente leitura, compatíveis com computed, para aceitar refs, getters ou valores simples
  • Usar toRef() dentro de fontes watch/watchEffect para resolver adequadamente dependências reativas
  • Usar toValue() para normalização de valores não reativos para extrair valores reais
  • Evitar MaybeRefOrGetter para parâmetros de função que podem ser funções de callback para evitar invocação acidental

Evitar

  • Não passar callbacks fornecidos pelo usuário diretamente para MaybeRefOrGetter sem guardas de tipo
  • Não normalizar entradas fora de contextos reativos como watch ou watchEffect
  • Não misturar toRef() e toValue() inconsistentemente dentro do mesmo composable
  • Não assumir que todos os parâmetros devem ser MaybeRef - usar tipos simples quando reatividade não é necessária

Perguntas Frequentes

Qual é a diferença entre MaybeRef e MaybeRefOrGetter?
MaybeRef aceita valores, refs, shallowRefs e computed refs graváveis. MaybeRefOrGetter adiciona ComputedRef e funções getter. Usar MaybeRef para parâmetros graváveis e MaybeRefOrGetter para entradas somente leitura.
Quando devo usar toRef() vs toValue()?
Usar toRef() para fontes watch/watchEffect para manter reatividade. Usar toValue() para extrair valores simples de refs, getters ou entradas não reativas em contextos não reativos.
Posso usar esses composables no Nuxt 3?
Sim, Nuxt 3 é construído sobre Vue 3 e suporta totalmente a API de Composição incluindo MaybeRef, MaybeRefOrGetter, toRef() e toValue().
Como lidar com valores undefined ou null?
Incluir explicitamente null ou undefined na definição de tipo como MaybeRef<T | null>. A função toValue() lida apropriadamente com null/undefined.
Devo usar MaybeRefOrGetter para manipuladores de eventos?
Não, evitar MaybeRefOrGetter para callbacks. Callbacks são funções, não getters. Usar MaybeRefOrGetter pode invocá-los acidentalmente. Usar tipos de função explícitos em vez disso.
Como criar composables com múltiplos parâmetros MaybeRef?
Aplicar o padrão a cada parâmetro individualmente. Usar toRef() ou toValue() em watch/watchEffect para normalizar cada entrada. Exemplo: watch([toRef(a), toRef(b)], ([newA, newB]) => {...})

Detalhes do Desenvolvedor

Estrutura de arquivos

📄 SKILL.md