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(),
  };
}

ஆவணங்களில் தேடு

எல்லா வழிகாட்டிகளின் தலைப்புகள், விளக்கங்கள், உள்ளடக்கத்தில் தேடுங்கள்.