విలీనం ​

మీరు సవరిస్తుండగా ఇతర మార్పులు భద్రపరిస్తే ప్రారంభ సంస్కరణ ఆధారంగా రెండు వైపులా కలపండి. స్వయంగా కలపగల మార్పులన్నీ ముందే వర్తిస్తాయి; ఒకదానిపై ఒకటి పడే మార్పులే వైరుధ్యాలు. ఇది nabi-note/merge స్వతంత్ర వీక్షణ, wing కాదు.

మధ్యలో సాధారణ ఎడిటర్‌లా పాఠ్యం, ఆకృతి, పట్టిక, జాబితా, చిత్రం మార్చవచ్చు. ఇచ్చిన wings సదుపాయాలను నిర్ణయిస్తాయి. వైరుధ్య గుర్తులు, పరిష్కార స్థితి భద్రపరిచే విషయంతో కలవవు.

పూర్తిగా స్వయంచాలక విలీనం ఉదాహరణ ​

మీరు సమావేశ సమయం ఉదయం 11 గంటలు, మరొకరు స్థలం మూడో అంతస్తు సమావేశ గది చేశారు. వేర్వేరు పేరాలు కాబట్టి మధ్య ఫలితంలో రెండూ వస్తాయి.

వైరుధ్యాలు లేవు కాబట్టి వెంటనే నిర్ధారించండి నొక్కవచ్చు లేదా ముందుగా మధ్య పాఠ్యం మెరుగుపరచవచ్చు. కింద చివరి పత్రం నిర్ధారణ callback పొందిన అసలు ఫలితం.

పాక్షిక స్వయంచాలక విలీనం ఉదాహరణ ​

ఈసారి మీరు సమయం ఉదయం 11 గంటలు, మరొకరు మధ్యాహ్నం 2 గంటలు చేశారు. ఒకే పేరాలో వేర్వేరు మార్పులతో సమయం వైరుధ్యంగా ఉంటుంది. నిర్వాహకులను జిమిన్ మరియు సోయోన్, స్థలాన్ని మూడో అంతస్తు సమావేశ గది చేసిన మార్పులు స్వయంగా వర్తిస్తాయి.

వైరుధ్యాన్ని ఇలా పరిష్కరించండి:

• ఎడమ >>: ప్రారంభ సంస్కరణ సంబంధిత విషయం తీసుకోండి.
• కుడి <<: కొత్తగా భద్రపరిచిన సంస్కరణ సంబంధిత విషయం తీసుకోండి.
• ప్రస్తుత విషయంతో పరిష్కరించండి: మధ్యది ఉంచి లేదా మార్చి పరిష్కారమైనట్లు గుర్తించండి.

మధ్య సమయం వాక్యం మార్చి ప్రస్తుత విషయంతో పరిష్కరించండి నొక్కండి. అన్ని వైరుధ్యాలు తీరితేనే నిర్ధారణ సాధ్యం.

పరిష్కారమైన ప్రాంతాన్ని మళ్లీ సవరించినా స్థితి ఉంటుంది. పరిష్కారాన్ని రద్దుచేస్తే స్థితీ వెనక్కి వెళ్తుంది; పునరావృతం పునరుద్ధరిస్తుంది. కేవలం పాఠ్యం తొలగించడం లేదా మార్చడం తెరిచిన వైరుధ్యాన్ని స్వయంగా తీర్చదు.

స్వయంచాలక విలీనం, వైరుధ్య నియమాలు ​

ప్రారంభ పత్రం నుంచి మీ పత్రానికి, అదే ప్రారంభం నుంచి కొత్త సంస్కరణకు మార్పులను పోలుస్తారు. ఒకవైపు మార్పులు, రెండు వైపుల ఒకే మార్పులు స్వయంగా వర్తిస్తాయి. వేరు పేరాలు లేదా పంక్తుల మార్పులూ కలుస్తాయి.

Git పాఠ్య విలీనంలా పేరా, పంక్తి ఆధారంగా అతివ్యాప్తి నిర్ణయిస్తారు. ఒకే పంక్తిలో వేర్వేరు పదాలు మార్చినా వైరుధ్యం ఉంటుంది. ఒకే చోట వేరు చేర్పులు లేదా మరోవైపు తొలగించినదాన్ని సవరించడానికీ నిర్ణయం కావాలి.

పట్టిక, జాబితా, float వంటి నిర్మాణ బ్లాక్ రెండు వైపుల వేరుగా మారితే మొత్తం నిర్మాణం వైరుధ్యం. సెల్‌లు, జాబితా అంశాలు యాదృచ్ఛికంగా కలవవు; విషయం ఎంచుకోండి లేదా మధ్య సవరించండి. కదలిక, సవరణ అతివ్యాప్తిలో స్థానం ఖచ్చితం కాకపోతే అవీ స్వయంగా వర్తించవు.

స్వతంత్ర విలీన వీక్షణ కలపడం ​

base, local, incoming కు భద్రపరిచిన NABI TREE JSON లేదా HTML స్ట్రింగ్‌లు ఇవ్వండి. అసలు ఎడిటర్ wings, ఎంపికలు వాడండి. mountMerge() మధ్య ఎడిటర్, టూల్‌బార్, రెండు మూలాలు, వైరుధ్య ఎంపిక, నిర్ధారణ బటన్ సృష్టిస్తుంది.

import { wings } from 'nabi-note'
import { mountMerge } from 'nabi-note/merge'
import 'nabi-note/nabi.css'

const merge = mountMerge({
  root: document.querySelector('#merge')!,
  base: editingStartedDocument,
  local: myEditedDocument,
  incoming: latestDocument,
  wings: wings().allBasic().build(),
  locale: 'te',
  incomingVersion: latestVersion,
  async onConfirm({ json, html, incomingVersion, signal }) {
    return saveDocument({ json, html, expectedVersion: incomingVersion, signal })
  },
  onError(error) {
    showError(error)
  },
})

onConfirm పూర్తిగా పరిష్కారమైన ప్రస్తుత ఫలితపు JSON, ప్రచురణ HTML, సవరణ revision, incomingVersion పొందుతుంది. false ఇస్తే నిర్ధారణ పూర్తికాదు. Promise పెండింగ్‌లో సవరణ, వైరుధ్య ఎంపిక, మళ్లీ నిర్ధారణ ఆగుతాయి. వీక్షణ తీస్తే ఫలితపు signal రద్దవుతుంది. కొరియన్ IME అక్షర సంయోజనం ముగిశాకే నిర్ధారించవచ్చు.

చిత్ర ఎంపిక, అప్‌లోడ్ వంటి సేవా పనులను సాధారణ ఎడిటర్‌లా కలపండి. toolbarOptions లో ప్యానెల్‌లు, హోస్ట్ చర్యలు; surfaceOptions లో సవరణ ఉపరితల ఎంపికలు ఇవ్వండి.

incomingVersion సేవ ఇచ్చిన విలువనే తిరిగిస్తుంది. భద్రపరిచేటప్పుడు సేవ తాజా సర్వర్ సంస్కరణతో పోల్చాలి. విలీనం మధ్య కొత్త సంస్కరణ భద్రపరిస్తే పాత ఫలితం దానిపై రాయకండి; తాజా పత్రం తీసుకుని కొత్త విలీనం ప్రారంభించండి.

వీక్షణ బయటనుంచీ స్థితి చదవవచ్చు లేదా నిర్ధారణ పిలవవచ్చు.

const stop = merge.session.onChange((state) => {
  updateRemainingCount(state.unresolvedCount)
})

const canConfirm = merge.session.getState().canConfirm
const confirmed = await merge.confirm()

stop()
merge.unmount()

ఫలితం merge.nabi.getJson(), merge.nabi.getHtml() తో చదవండి. సవరణ DOM లేదా getEditorHtml() భద్రపరచవద్దు. రెండు సంస్కరణల్లో ఎంచుకున్న పాత విషయం మాత్రమే వర్తింపజేయడానికి పోలిక క్లిక్ విలీనం వాడండి.

అప్‌లోడ్ పూర్తయ్యాక నిర్ధారణ ​

ఫైల్ బటన్, పేస్ట్, డ్రాగ్ డ్రాప్ కోసం upload wing, mountUpload() కలపండి. sendUpload ఫైల్ సర్వర్‌కు పంపి { uri } ఇస్తుంది. పూర్తి కనెక్షన్, పురోగతి ఉదాహరణ ఫైల్ అప్‌లోడ్లో చూడండి.

పత్రంలోకి ఇంకా రాని అప్‌లోడ్ వంటి అసమకాలిక పనిలో merge.session.hold() తో నిర్ధారణ, వైరుధ్య ఎంపిక నిలిపివేయండి. పూర్తి, రద్దు లేదా వీక్షణ తొలగింపులో తిరిగిచ్చిన ఫంక్షన్ పిలవండి. పత్రంలో చేర్చాక విడుదల చేయండి, సర్వర్ అప్‌లోడ్ కాగానే కాదు; అప్పుడు ఫైల్ చివరి ఫలితంలో ఉంటుంది.

import { mountUpload, wings, type UploadMount } from 'nabi-note'
import { mountMerge } from 'nabi-note/merge'

let upload: UploadMount | undefined
let releaseUpload: (() => void) | undefined

const merge = mountMerge({
  root,
  base,
  local,
  incoming,
  wings: wings().allBasic().use('upload').build(),
  locale: 'te',
  incomingVersion: latestVersion,
  toolbarOptions: { onFiles: (files) => upload?.take(files) },
  surfaceOptions: { fileSink: (files) => upload?.take(files) },
  onConfirm: ({ json, html, incomingVersion, signal }) =>
    saveDocument({ json, html, expectedVersion: incomingVersion, signal }),
})

upload = mountUpload({
  nabi: merge.nabi,
  root: merge.content,
  locale: 'te',
  uploader: sendUpload,
  onStart() {
    releaseUpload = merge.session.hold()
  },
  onDone() {
    releaseUpload?.()
    releaseUpload = undefined
  },
})

function dispose() {
  upload?.unmount()
  releaseUpload?.()
  merge.unmount()
}

merge.content మధ్య సవరణ DOM; merge.surface, merge.toolbar ఇప్పటికే కలిపారు. అదే చోట మరో ఉపరితలం లేదా టూల్‌బార్ చేయవద్దు. ముందుగా అదనపు అప్‌లోడ్, పురోగతి mount తీసి చివరగా merge.unmount() పిలవండి.