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