restate / v1.0.0
கம்போனென்டுக்குச் சொந்தமான ஸ்டேட்
ஒவ்வொரு ஆவணம், உரையாடல், கோரிக்கைக்கும் தனி ஸ்டோர்களைக் கொடுங்கள்; அவை கம்போனென்டுடன் உருவாகி, அது அன்மவுன்ட் ஆன பிறகு விடுவிக்கப்படும்.
இந்தப் பக்கத்தில்
useRestateScopefactory விதிகள்props-இலிருந்து தொடக்க மதிப்புகள்சர்வர் ரெண்டரிங்ஆவணத்தின் சேமித்த தரவுக்குக் காத்திருத்தல்முயன்று பாருங்கள்React-க்கு வெளியேயான உரிமையாளர்கள்useRestateScope
factory ஸ்டோர்களை அறிவித்துத் தருகிறது. restate ரெண்டர்களுக்கு இடையே முடிவைத் தக்கவைத்து, கம்போனென்ட் அன்மவுன்ட் ஆன பிறகு scope-ஐ அழிக்கிறது. மூடும் ஃபங்ஷனோ சுத்தம் செய்யும் effect-ஓ எழுத வேண்டியதில்லை.
இரண்டு Document உறுப்புகளுக்குத் தனித்தனி ஸ்டேட் உள்ளது. ஒரு ஆவணத்தைக் குழந்தைகளுடன் பகிர, திருப்பித் தரப்பட்ட ஹூக்குகளை props அல்லது உங்கள் சொந்த context மூலம் அனுப்புங்கள்.
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-ஐயும் பயன்படுத்துங்கள்.
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-இல் இருக்கும்; அதுவும் சர்வரில் ரெண்டர் ஆகிறது.
'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-க்குக் காத்திருங்கள்.
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-ஐ அழிப்பது சேமித்த பதிவுகளை ஒருபோதும் நீக்காது.
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(),
};
}