Aller au contenu principal
NouveauSolid 2.0 est disponible. Lire les dernières nouvelles

Réactivité à grain fin.Pas de DOM virtuel.Asynchrone intégré.

Une réactivité simple et performante pour créer des interfaces utilisateur. Solid 2.0 ajoute l'asynchrone de premier ordre, les actions optimistes et les stores à brouillon.

npm create solid@latest

Solid 2.0.0 est la version actuelle.

Pourquoi Solid

Pourquoi Solid 2.0 ?

Des signaux, avec l'asynchrone et les mutations dans le même graphe.

Pas de DOM virtuel

Réactivité à grain fin

Les composants ne s'exécutent qu'une fois. Pas de nouveau rendu, pas de mémoïsation, pas de tableaux de dépendances : les signaux mettent à jour exactement les nœuds du DOM qui les lisent, jusqu'à un seul nœud de texte.


Asynchrone par conception

L'asynchrone fait partie du graphe

Un mémo qui renvoie une promesse reste une simple valeur : pas d'indicateurs de chargement, pas de clés de cache et pas de undefined dans vos types. Vous pouvez charger des données dans n'importe quel composant et afficher un état de chargement où vous le souhaitez. Les composants intermédiaires n'ont pas besoin de le savoir.

user()
la valeur, jamais undefined
isPending(user)
vrai pendant qu'un rafraîchissement est en cours
<Loading>
contenu de repli au premier chargement seulement
<Errored>
intercepte un rejet

Des mises à jour cohérentes

L'interface n'affiche jamais une mise à jour à moitié faite

L'ancien contenu reste à l'écran jusqu'à ce que les nouvelles données soient prêtes. Utilisez isPending et latest là où vous avez besoin d'afficher un état en attente ou la dernière valeur.

  1. setTab("posts")l'entrée change
  2. isPending(() => posts())à demander là où le design en a besoin
  3. latest(tab)la valeur la plus récente, en cours de route
  4. settledla nouvelle réponse arrive en entier

Mutations sûres

Une interface optimiste à partir de l'écriture que vous faites déjà

Enveloppez une mutation dans une action, et l'écriture sur brouillon que vous feriez dans une application purement cliente devient la prédiction optimiste. Pas d'instantanés ni de code d'annulation : quand le serveur répond, l'hypothèse s'efface d'elle-même, en cas de succès comme d'échec.

  1. setTodos(list => …)l'écriture optimiste s'affiche immédiatement
  2. yield api.add(todo)la requête est en cours
  3. refresh(todos)réconcilier avec le serveur
  4. settledl'hypothèse cède la place aux données du serveur

Full stack

Des fonctions serveur qui diffusent des valeurs en direct

Marquez une fonction "use server" et appelez-la comme n'importe quelle autre. Renvoyez un générateur asynchrone et elle devient temps réel : live() garde la valeur à jour dans le graphe réactif, et broadcast() donne la même réponse à chaque visiteur quand elle change.

  1. "use server"RPC typé, sans génération de code
  2. await getUser(id)dans le même processus pendant le SSR
  3. live(messages)un générateur asynchrone reste à jour
  4. broadcast(room)chaque visiteur reçoit la même réponse

Open source

Sous licence MIT et utilisé en production

Sous licence MIT et utilisé en production. Ces chiffres viennent en direct de npm et de GitHub.

Téléchargements npm / semaine

—

36,3 k Étoiles GitHub198 contributeurs


Regarder

Solid 2.0 en neuf minutes

Better Stack passe en revue les changements : l'asynchrone dans le graphe réactif, les nouvelles frontières Loading et Errored, les mises à jour optimistes et le mode Start.

Open in new tab (s'ouvre dans un nouvel onglet)

Solid 2.0

Nouveautés de Solid 2.0

Solid 2.0 ajoute l'asynchrone dans le graphe réactif, des stores à brouillon et des actions pour une interface optimiste. Modifiez n'importe quel exemple pour le voir se mettre à jour.

L'asynchrone se lit comme une valeur ordinaire

Les mémos asynchrones se lisent comme de simples valeurs, même quand l'un dépend de l'autre. Choisissez un État : l'ancienne liste de villes reste à l'écran pendant que la nouvelle se charge, la ville se réinitialise d'elle-même, et aucun effet n'est nécessaire pour les garder synchronisées.

Modifiez le code et l'aperçu se met à jour en direct.

import { createMemo, createSignal, For, isPending, Loading } from "solid-js";
import { render } from "@solidjs/web";

const CITIES: Record<string, string[]> = {
  California: ["Los Angeles", "San Francisco", "San Diego"],
  Florida: ["Miami", "Orlando", "Tampa"],
  "New York": ["New York City", "Buffalo", "Rochester"],
  Texas: ["Houston", "Dallas", "Austin"],
};

// Stand-ins for network requests.
const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
const getStates = async () => (await sleep(500), Object.keys(CITIES));
const getCities = async (state: string) => (await sleep(500), CITIES[state] ?? []);

function App() {
  // Async memos read like plain values, even when one depends on another.
  const states = createMemo(getStates);
  const [state, setState] = createSignal(() => states()[0]);
  const cities = createMemo(() => getCities(state()));
  // A writable signal derived from the list: picking a new state resets the
  // city on its own, with no effect to keep them in sync.
  const [city, setCity] = createSignal(() => cities()[0]);

  return (
    <Loading fallback={<p>Loading…</p>}>
      <select onChange={(e) => setState(e.currentTarget.value)}>
        <For each={states()}>{(name) => <option>{name}</option>}</For>
      </select>{" "}
      <select disabled={isPending(cities)} onChange={(e) => setCity(e.currentTarget.value)}>
        <For each={cities()}>{(name) => <option>{name}</option>}</For>
      </select>
      <p>
        Selection: {city()}, {state()}
      </p>
    </Loading>
  );
}

render(() => <App />, document.getElementById("app")!);

Communauté

Construit au grand jour

Solid est sous licence MIT et développé sur GitHub. Les questions et l'entraide se passent sur Discord.

  • Discord

    Posez vos questions et discutez avec la communauté et l'équipe principale.

  • GitHub

    Lisez le code source, ouvrez des tickets et participez aux discussions.

  • Équipe et contributeurs

    Rencontrez les personnes qui construisent et maintiennent Solid.

  • Code de conduite

    Comment nous gardons la communauté accueillante pour tous.

Parrains

Merci à nos soutiens

Les parrains financent les mainteneurs, l'infrastructure et les événements.

Soutiens

Blog

Dernières nouvelles du blog

Versions, feuilles de route et nouvelles de la communauté par l'équipe de Solid.

  • Version

    Solid 2.0 - The Long Hold

    Solid 2.0 reaches stable after five years: async in the reactive graph, server functions, diagnostics built for agents, and a smaller API.

  • Solid 2.0

    Async Solid - One Graph, Two Machines

    Part three of a deep dive into how Solid 2.0 handles async: server functions, streaming, live sources, and recovery, all riding the same reactive graph.

  • Solid 2.0

    Async Solid - Write Sync, Run Async

    Part two of a deep dive into how Solid 2.0 handles async: how optimistic writes fall out of the client-side app you already wrote.

Suivre l'actualité de Solid

Les annonces de versions et les nouvelles de la communauté paraissent d'abord sur le blog, puis sur nos réseaux sociaux.

Affichez Solid avec des autocollants et des goodies

T-shirts, autocollants, mugs et plus encore dans la boutique Solid. Tous les bénéfices vont à l'Open Collective de Solid.

Visiter la boutique Solid