restate / v1.0.0
ನೀವು ನಿರ್ಧರಿಸಿದಾಗ ಉಳಿಸಿ
ಸ್ಟೋರ್ ಅನ್ನು IndexedDB ಅಥವಾ MMKV ನಲ್ಲಿ ಇಡಿ, ಪ್ರಾರಂಭದಲ್ಲಿ ಒಮ್ಮೆ ಲೋಡ್ ಮಾಡಿ, ಸ್ಪಷ್ಟವಾಗಿ ಅಥವಾ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಉಳಿಸಿ, ಮತ್ತು ಉಳಿಸದ ಬದಲಾವಣೆಗಳನ್ನು ತೋರಿಸಿ.
ಈ ಪುಟದಲ್ಲಿ
ಉಳಿಸಲಾಗುವ ಸ್ಟೋರ್ ಘೋಷಿಸುವುದುಪ್ರಾರಂಭದಲ್ಲಿ ಒಮ್ಮೆ ಕಾಯಿರಿಉಳಿಸಿ, ರದ್ದುಮಾಡಿ, ಮರುಹೊಂದಿಸಿಉಳಿಸದ ಬದಲಾವಣೆಗಳು ಮತ್ತು ಪ್ರಗತಿ ತೋರಿಸುವುದುಪ್ರಯತ್ನಿಸಿಸ್ವಯಂ-ಉಳಿಕೆಪುಟ ಮುಚ್ಚುವ ಮೊದಲುಸ್ಟೋರೇಜ್ ದೋಷಗಳ ನಿರ್ವಹಣೆಉಳಿಸಲಾಗುವ ಸ್ಟೋರ್ ಘೋಷಿಸುವುದು
restate ಅನ್ನು persistedRestate ನಿಂದ ಬದಲಿಸಿ ಮತ್ತು key ಕೊಡಿ. ಕಾಂಪೊನೆಂಟ್ಗಳು ಅದೇ ಹುಕ್ ಮತ್ತು ಅದೇ set ಬಳಸುತ್ತಲೇ ಇರುತ್ತವೆ.
ರಚನೆಯ ನಂತರ ಉಳಿಸಿದ ಮೌಲ್ಯ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮರುಸ್ಥಾಪನೆಯಾಗುತ್ತದೆ. ಸಂಪಾದನೆ ಮೆಮೊರಿಯನ್ನು ಬದಲಿಸುತ್ತದೆ; ನೀವು ಉಳಿಸುವವರೆಗೆ ಅಥವಾ autoSave ಆನ್ ಮಾಡುವವರೆಗೆ ಏನೂ ಬರೆಯಲಾಗುವುದಿಲ್ಲ.
import { persistedRestate } from '@kkwaenggwari/restate';
export const useDraft = persistedRestate('', {
key: 'article-draft',
validate: (value) => typeof value === 'string',
});ಪ್ರಾರಂಭದಲ್ಲಿ ಒಮ್ಮೆ ಕಾಯಿರಿ
ಕ್ಲೈಂಟ್ ಪ್ರವೇಶ ಬಿಂದುವಿನಲ್ಲಿ ಆ್ಯಪ್ ಮತ್ತು ಅದರ ಸ್ಟೋರ್ಗಳನ್ನು import ಮಾಡಿ, ರೆಂಡರ್ ಮಾಡುವ ಮೊದಲು restateManager.ready ಗಾಗಿ ಕಾಯಿರಿ. ನಂತರ ಕಾಂಪೊನೆಂಟ್ಗಳು ಉಳಿಸಿದ ಮೌಲ್ಯಗಳನ್ನು ನೇರವಾಗಿ ಓದಬಹುದು.
ಲಭ್ಯವಿಲ್ಲದ ಸ್ಟೋರೇಜ್ — ಸರ್ವರ್ ರೆಂಡರಿಂಗ್ನಲ್ಲಿ ಅಥವಾ ಅದನ್ನು ತಡೆಯುವ ಬ್ರೌಸರ್ನಲ್ಲಿ — ದೋಷವಲ್ಲ: ಅಂತಹ ಸ್ಟೋರ್ಗಳು ಮೆಮೊರಿಯಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತವೆ. ದಾಖಲೆಗಳನ್ನು ಓದಲು, ಪರಿವರ್ತಿಸಲು ಅಥವಾ ಪರಿಶೀಲಿಸಲು ಆಗದಿದ್ದಾಗ ಮಾತ್ರ ready ತಿರಸ್ಕೃತವಾಗುತ್ತದೆ.
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 ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
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 ಕೊಡಿ.
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 ಅನ್ಮೌಂಟ್ ಸಮಯದಲ್ಲಿ ಬಾಕಿ ಬದಲಾವಣೆಯನ್ನು ಬರೆಯುತ್ತದೆ.
export const useTheme = persistedRestate('light', { key: 'theme', autoSave: true });
export const useDraft = persistedRestate('', {
key: 'article-draft',
autoSave: { delayMs: 500 },
});ಪುಟ ಮುಚ್ಚುವ ಮೊದಲು
ಅದೇ ಸ್ಥಿತಿಯನ್ನು React ಹೊರಗೆ ಓದಿ. ಹೊರಡುವ ಮೊದಲು ಉಳಿಸದ ಬದಲಾವಣೆಗಳ ಬಗ್ಗೆ ಎಚ್ಚರಿಸಿ, ಅಥವಾ ಪುಟ ಮರೆಯಾದಾಗ ಎಲ್ಲವನ್ನೂ ಉಳಿಸಿ.
window.addEventListener('beforeunload', (event) => {
if (useDraft.status().dirty) event.preventDefault();
});
window.addEventListener('pagehide', () => {
restateManager.saveAll();
});ಸ್ಟೋರೇಜ್ ದೋಷಗಳ ನಿರ್ವಹಣೆ
ಸ್ಟೋರೇಜ್ ದೋಷಗಳು ಕಾರ್ಯದ Promise ಅನ್ನು ತಿರಸ್ಕರಿಸುತ್ತವೆ. ಪ್ರತಿ restate ದೋಷಕ್ಕೆ code ಇರುತ್ತದೆ, ಮತ್ತು ಉಳಿಸಲಾಗುವ ಸ್ಟೋರ್ಗಳಿಗೆ ದಾಖಲೆಯ key ಕೂಡ.
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'}".`);
}