restate / v1.0.0

మీరు నిర్ణయించినప్పుడు సేవ్ చేయండి

స్టోర్‌ను IndexedDB లేదా MMKV-లో ఉంచి, ప్రారంభంలో ఒకసారి లోడ్ చేసి, స్పష్టంగా లేదా స్వయంచాలకంగా సేవ్ చేసి, సేవ్ కాని మార్పులను చూపించండి.

ఈ పేజీలోసేవ్ అయ్యే స్టోర్‌ను ప్రకటించడంప్రారంభంలో ఒకసారి వేచి ఉండండిసేవ్, రద్దు, రీసెట్సేవ్ కాని మార్పులు, పురోగతిని చూపించడంప్రయత్నించండిఆటో-సేవ్పేజీ మూసే ముందుస్టోరేజ్ లోపాలను నిర్వహించడం

సేవ్ అయ్యే స్టోర్‌ను ప్రకటించడం

restate-ను persistedRestate‌గా మార్చి ఒక key ఇవ్వండి. కాంపోనెంట్లు అదే హుక్, అదే set వాడుతూనే ఉంటాయి.

సృష్టించిన తర్వాత సేవ్ చేసిన విలువ స్వయంచాలకంగా పునరుద్ధరించబడుతుంది. సవరణ మెమరీని మారుస్తుంది; మీరు సేవ్ చేసే వరకు లేదా autoSave ఆన్ చేసే వరకు ఏదీ రాయబడదు.

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

export const useDraft = persistedRestate('', {
  key: 'article-draft',
  validate: (value) => typeof value === 'string',
});

ప్రారంభంలో ఒకసారి వేచి ఉండండి

క్లయింట్ ఎంట్రీ పాయింట్‌లో యాప్‌ను, దాని స్టోర్‌లను import చేసి, రెండర్ చేసే ముందు restateManager.ready కోసం వేచి ఉండండి. ఆ తర్వాత కాంపోనెంట్లు సేవ్ చేసిన విలువలను నేరుగా చదవగలవు.

అందుబాటులో లేని స్టోరేజ్ — సర్వర్ రెండరింగ్‌లో లేదా దాన్ని బ్లాక్ చేసే బ్రౌజర్‌లో — లోపం కాదు: అలాంటి స్టోర్‌లు మెమరీలో పనిచేస్తాయి. రికార్డులను చదవలేనప్పుడు, మార్చలేనప్పుడు లేదా ధ్రువీకరించలేనప్పుడు మాత్రమే ready తిరస్కరించబడుతుంది.

JavaScript / JSX
import { createRoot } from 'react-dom/client';
import { restateManager } from '@kkwaenggwari/restate';
import App from './App';

async function start() {
  const root = createRoot(document.getElementById('root'));
  try {
    await restateManager.ready;
    root.render(<App />);
  } catch (error) {
    root.render(<p>Could not load saved data.</p>);
    console.error(error);
  }
}
start();

సేవ్, రద్దు, రీసెట్

save ప్రస్తుత విలువను రాస్తుంది, restore సేవ్ చేసిన విలువకు తిరిగి వెళ్తుంది, resetAll మెమరీని, స్టోరేజ్‌ను క్లియర్ చేస్తుంది. ప్రతి ఒక్కటి Promise ఇస్తుంది.

JavaScript / JSX
await useDraft.save(); // write the current value
await useDraft.restore(); // return to the saved value
await useDraft.resetAndClearStorage(); // initial value in memory, record removed

సేవ్ కాని మార్పులు, పురోగతిని చూపించడం

సేవ్ స్థితి మారినప్పుడు useStatus మళ్లీ రెండర్ అవుతుంది. చివరిగా లోడ్ చేసిన, సేవ్ చేసిన లేదా పునరుద్ధరించిన విలువ నుండి మెమరీ భిన్నంగా ఉన్నంత వరకు dirty true. operation ప్రస్తుత స్టోరేజ్ ఆపరేషన్ పేరును చెబుతుంది.

ఒక ఫీల్డ్ మారినప్పుడే మళ్లీ రెండర్ కావడానికి selector ఇవ్వండి.

JavaScript / JSX
function SaveButton() {
  const { dirty, operation, error } = useDraft.useStatus();
  const saving = operation === 'save';

  return (
    <>
      <button disabled={!dirty || saving} onClick={() => useDraft.save().catch(() => {})}>
        {saving ? 'Saving…' : 'Save'}
      </button>
      {error != null && <p>Could not save your draft.</p>}
    </>
  );
}

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

టైప్ చేసి, స్టోరేజ్ ఆలస్యాన్ని పెంచి, సేవ్ చేయండి. పునరుద్ధరించిన డ్రాఫ్ట్‌ను చూడటానికి ఉదాహరణను మళ్లీ రన్ చేయండి.

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

ఆటో-సేవ్

ఎల్లప్పుడూ సేవ్ కావాల్సిన సెట్టింగ్‌లు, డ్రాఫ్ట్‌ల కోసం ఒకసారి ఆన్ చేయండి. autoSave: true ప్రతి మార్పు తర్వాత సేవ్ చేస్తుంది; { delayMs } మార్పులు ఆగే వరకు వేచి ఉంటుంది.

వరుస మార్పులు ఒకే రాతగా మారతాయి; సేవ్ చేసిన విలువకు తిరిగి వెళ్తే ఏదీ రాయబడదు. లోపాలు status().error-లో కనిపిస్తాయి. కాంపోనెంట్ scope అన్‌మౌంట్ సమయంలో పెండింగ్ మార్పును రాస్తుంది.

JavaScript / JSX
export const useTheme = persistedRestate('light', { key: 'theme', autoSave: true });

export const useDraft = persistedRestate('', {
  key: 'article-draft',
  autoSave: { delayMs: 500 },
});

పేజీ మూసే ముందు

అదే స్థితిని React బయట చదవండి. వెళ్లిపోయే ముందు సేవ్ కాని మార్పుల గురించి హెచ్చరించండి, లేదా పేజీ దాగినప్పుడు అన్నీ సేవ్ చేయండి.

JavaScript / JSX
window.addEventListener('beforeunload', (event) => {
  if (useDraft.status().dirty) event.preventDefault();
});

window.addEventListener('pagehide', () => {
  restateManager.saveAll();
});

స్టోరేజ్ లోపాలను నిర్వహించడం

స్టోరేజ్ లోపాలు ఆపరేషన్ Promise-ను తిరస్కరిస్తాయి. ప్రతి restate లోపానికి code ఉంటుంది; సేవ్ అయ్యే స్టోర్‌లకు రికార్డు key కూడా ఉంటుంది.

JavaScript / JSX
try {
  await useDraft.save();
} catch (error) {
  if (error.code === 'STORAGE_UNAVAILABLE') showNotice('Saving is off in this browser.');
  else if (error.code === 'STORAGE_VALUE_TOO_LARGE') showNotice('This draft is too large.');
  else showNotice(`Could not save "${error.key ?? 'draft'}".`);
}

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

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