restate / v1.0.0

కాంపోనెంట్‌కు చెందిన స్టేట్

ప్రతి పత్రం, డైలాగ్, అభ్యర్థనకు ప్రత్యేక స్టోర్‌లు ఇవ్వండి; అవి కాంపోనెంట్‌తో పుట్టి, అది అన్‌మౌంట్ అయిన తర్వాత విడుదల అవుతాయి.

ఈ పేజీలోuseRestateScopefactory నియమాలుprops నుండి ప్రారంభ విలువలుసర్వర్ రెండరింగ్పత్రం యొక్క సేవ్ చేసిన డేటా కోసం వేచి ఉండటంప్రయత్నించండిReact బయటి యజమానులు

useRestateScope

factory స్టోర్‌లను ప్రకటించి తిరిగి ఇస్తుంది. restate రెండర్‌ల మధ్య ఫలితాన్ని నిలుపుకుని, కాంపోనెంట్ అన్‌మౌంట్ అయిన తర్వాత scope-ను నాశనం చేస్తుంది. మూసే ఫంక్షన్ గానీ క్లీనప్ effect గానీ రాయాల్సిన అవసరం లేదు.

రెండు Document ఎలిమెంట్లకు వేర్వేరు స్టేట్ ఉంటుంది. ఒక పత్రాన్ని పిల్లలతో పంచుకోవడానికి, తిరిగి వచ్చిన హుక్‌లను props లేదా మీ సొంత context ద్వారా పంపండి.

JavaScript / JSX
import { restate, useRestateScope } from '@kkwaenggwari/restate';

function Document() {
  const { useDraft, useSelection } = useRestateScope((scope) => ({
    useDraft: restate('', { scope }),
    useSelection: restate(0, { scope }),
  }));
  const text = useDraft();
  const selection = useSelection();

  return (
    <section>
      <input value={text} onChange={(event) => useDraft.set(event.target.value)} />
      <button onClick={() => useSelection.set((n) => n + 1)}>Selection: {selection}</button>
    </section>
  );
}

factory నియమాలు

React factory-ని అనేకసార్లు కాల్ చేసి ఫలితాలను వదిలేయవచ్చు; అందువల్ల దాన్ని synchronous‌గా, స్వచ్ఛంగా ఉంచండి.

  • స్టోర్‌లను factory లోపల ప్రకటించండి; తిరిగి వచ్చిన హుక్‌లను కాంపోనెంట్ పై స్థాయిలో కాల్ చేయండి.
  • ప్రారంభ props useState ఇనిషియలైజర్ లాగే ఒకసారి చదవబడతాయి.
  • వేరే పత్రానికి కొత్త స్టేట్ అవసరమైనప్పుడు కాంపోనెంట్‌కు key ఇవ్వండి.
  • factory లేని useRestateScope(), తర్వాత effect-లలో లేదా హ్యాండ్లర్లలో మీరు సృష్టించే స్టోర్‌ల కోసం స్థిరమైన scope-ను ఇస్తుంది.

props నుండి ప్రారంభ విలువలు

props-ను ప్రారంభ విలువలుగా, వేరే పత్రంతో కొత్తగా ప్రారంభించడానికి React key-ని వాడండి.

JavaScript / JSX
function Editor({ document }) {
  // The initial value is captured once, like a useState initializer.
  const useTitle = useRestateScope((scope) => restate(document.title, { scope }));
  const title = useTitle();
  return <input value={title} onChange={(event) => useTitle.set(event.target.value)} />;
}

// A different document gets fresh state.
<Editor key={document.id} document={document} />;

సర్వర్ రెండరింగ్

సర్వర్ route-లో డేటాను లోడ్ చేసి prop‌గా పంపండి. ప్రారంభ విలువే సర్వర్ స్నాప్‌షాట్ కూడా. Next.js App Router-లో ఈ హుక్ Client Component-లో ఉంటుంది; అది కూడా సర్వర్‌లో రెండర్ అవుతుంది.

JavaScript / JSX
'use client';

import { restate, useRestateScope } from '@kkwaenggwari/restate';

export default function Profile({ user }) {
  const useProfile = useRestateScope((scope) => restate(user, { scope }));
  const profile = useProfile();
  return <p>{profile.name}</p>;
}

పత్రం యొక్క సేవ్ చేసిన డేటా కోసం వేచి ఉండటం

scope-లోని సేవ్ అయ్యే స్టోర్‌లు క్లయింట్‌లో కాంపోనెంట్ commit అయినప్పుడు పునరుద్ధరణను ప్రారంభిస్తాయి; అవి గ్లోబల్ restateManager.ready-లో భాగం కావు. లోడింగ్ సరిహద్దులో scope సొంత manager.ready కోసం వేచి ఉండండి.

JavaScript / JSX
import { useEffect, useState } from 'react';
import { persistedRestate, useRestateScope } from '@kkwaenggwari/restate';

function Document({ documentId }) {
  const { manager, useDraft } = useRestateScope((scope) => ({
    manager: scope.manager,
    useDraft: persistedRestate('', { scope, namespace: 'documents', key: documentId }),
  }));
  const [state, setState] = useState('loading');

  useEffect(() => {
    let active = true;
    manager.ready.then(
      () => active && setState('ready'),
      () => active && setState('error'),
    );
    return () => {
      active = false;
    };
  }, [manager]);

  if (state === 'error') return <p>Could not load this document.</p>;
  if (state === 'loading') return <p>Loading document…</p>;
  return <Editor useDraft={useDraft} />;
}

ప్రయత్నించండి

పత్రాలను తెరిచి మూసి, వాటి స్టేట్ ఎలా మళ్లీ మొదలవుతుందో చూడండి.

ఉదాహరణ సిద్ధమవుతోంది…

React బయటి యజమానులు

స్టేట్ ఒక సర్వీసుకు లేదా సర్వర్ అభ్యర్థనకు చెందినప్పుడు, scope-ను మీరే సృష్టించి చివరలో destroy() కాల్ చేయండి. scope-ను నాశనం చేయడం సేవ్ చేసిన రికార్డులను ఎప్పుడూ తొలగించదు.

JavaScript / JSX
import { createRestateScope, persistedRestate } from '@kkwaenggwari/restate';

export function createDocument(documentId) {
  const scope = createRestateScope();
  const useDraft = persistedRestate('', {
    scope,
    namespace: 'documents',
    key: documentId,
  });
  return {
    useDraft,
    manager: scope.manager,
    save: () => scope.manager.saveAll(),
    destroy: () => scope.destroy(),
  };
}

డాక్యుమెంటేషన్‌లో వెతకండి

అన్ని గైడ్‌ల శీర్షికలు, వివరణలు, విషయంలో వెతకండి.