A Valós Idejű Frontend Erő Felszabadítása: Mélymerülés a Fájlrendszer Könyvtármonitorozásába

Képzeljen el egy webalapú kódszerkesztőt, amely azonnal tükrözi a helyi lemezen lévő projektmappában végzett változtatásokat. Gondoljon egy böngészőalapú fotógalériára, amely automatikusan frissül, amikor új képeket ad hozzá a fényképezőgépéről. Vagy vegyen egy adatvizualizációs eszközt, amely valós időben rajzolja újra a diagramjait, amint egy helyi naplófájl frissül. Évtizedekig a helyi fájlrendszerrel való ilyen szintű integráció a natív asztali alkalmazások kizárólagos területe volt. A böngészőt biztonsági okokból biztonságos távolságban, a saját homokozójában tartották.

Ma ez a paradigma drámaian megváltozik. A modern böngésző API-knak köszönhetően a webes és asztali alkalmazások közötti határvonal elmosódik. Az egyik legerősebb eszköz, amely ezt a változást vezeti, a File System Access API, amely engedélyalapú hozzáférést biztosít a webalkalmazásoknak a felhasználó helyi fájljainak és könyvtárainak olvasásához, írásához, és ami a legfontosabb a mi szempontunkból, a változások figyeléséhez. Ez a képesség, amelyet könyvtárfigyelésnek vagy fájlváltozás-monitorozásnak neveznek, új távlatokat nyit a hatékony, reszponzív és magasan integrált webes élmények létrehozásában.

Ez az átfogó útmutató mélyrehatóan bemutatja a frontend fájlrendszer-könyvtármonitorozás világát. Felfedezzük a mögöttes API-t, elemezzük a robusztus figyelő nulláról történő felépítésének technikáit, megvizsgáljuk a valós felhasználási eseteket, és eligazodunk a teljesítmény, a biztonság és a felhasználói élmény kritikus kihívásaiban. Akár a következő nagyszerű webalapú IDE-t építi, akár egy egyszerű segédeszközt, ennek a technológiának a megértése kulcsfontosságú a modern web teljes potenciáljának felszabadításához.

A Fejlődés: Az Egyszerű Fájlbemenetektől a Valós Idejű Monitorozásig

Ahhoz, hogy teljes mértékben értékelni tudjuk a File System Access API jelentőségét, érdemes visszatekinteni a fájlkezelés fejlődésére a weben.

A Klasszikus Megközelítés: <input type="file">

Hosszú ideig az egyetlen kapunk a felhasználó fájlrendszeréhez a szerény <input type="file"> elem volt. Megbízható igásló volt és maradt az egyszerű fájlfeltöltésekhez. Korlátai azonban jelentősek:

• Felhasználó által kezdeményezett és egyszeri: A felhasználónak minden egyes alkalommal manuálisan kell egy gombra kattintania és kiválasztania egy fájlt. Nincs perzisztencia.
• Csak fájlok: Kiválaszthatott egy vagy több fájlt, de soha nem választhatott ki egy egész könyvtárat.
• Nincs monitorozás: Miután egy fájlt kiválasztottak, a böngészőnek nem volt tudomása arról, hogy mi történt az eredeti fájllal a lemezen. Ha módosították vagy törölték, a webalkalmazás mit sem sejtett.

Egy Lépés Előre: A Drag and Drop API

A Drag and Drop API sokkal jobb felhasználói élményt nyújtott, lehetővé téve a felhasználók számára, hogy fájlokat és mappákat húzzanak közvetlenül egy weboldalra. Ez intuitívabbnak és asztali alkalmazásokhoz hasonlóbbnak érződött. Mégis, egy alapvető korlátozásban osztozott a fájlbemenettel: ez egy egyszeri esemény volt. Az alkalmazás egy pillanatképet kapott a behúzott elemekről abban a konkrét pillanatban, és nem volt folyamatos kapcsolata a forráskönyvtárral.

A Játékszabályokat Átíró Újítás: A File System Access API

A File System Access API alapvető ugrást jelent előre. Úgy tervezték, hogy a webalkalmazásoknak a natív alkalmazásokéval vetekedő képességeket biztosítson, lehetővé téve számukra, hogy perzisztens és hatékony módon lépjenek kapcsolatba a felhasználó helyi fájlrendszerével. Alapelvei a biztonságra, a felhasználói hozzájárulásra és a képességekre épülnek:

• Felhasználóközpontú biztonság: A hozzáférés soha nem adható meg csendben. A felhasználót mindig egy natív böngésző párbeszédablak kéri fel, hogy adjon engedélyt egy adott fájlhoz vagy könyvtárhoz.
• Perzisztens „handle”-ök: Az alkalmazás nem egy egyszeri adatblobot kap, hanem egy speciális objektumot, egy úgynevezett handle-t (egy FileSystemFileHandle-t vagy FileSystemDirectoryHandle-t). Ez a handle egy állandó mutatóként működik a lemezen lévő tényleges fájlra vagy könyvtárra.
• Könyvtárszintű hozzáférés: Ez a kulcsfontosságú funkció. Az API lehetővé teszi a felhasználó számára, hogy egy alkalmazásnak hozzáférést adjon egy egész könyvtárhoz, beleértve annak összes alkönyvtárát és fájlját.

Ez a perzisztens könyvtár handle teszi lehetővé a valós idejű fájlmonitorozást a frontenden.

A File System Access API Megértése: Az Alaptechnológia

Mielőtt könyvtárfigyelőt építhetnénk, meg kell értenünk az API kulcsfontosságú komponenseit, amelyek működtetik. Az egész API aszinkron, ami azt jelenti, hogy minden, a fájlrendszerrel interakcióba lépő művelet egy Promise-t ad vissza, biztosítva, hogy a felhasználói felület reszponzív maradjon.

Biztonság és Engedélyek: A Felhasználó Irányít

Ennek az API-nak a legfontosabb aspektusa a biztonsági modellje. Egy weboldal nem tud önkényesen átvizsgálni a merevlemezét. A hozzáférés szigorúan önkéntes (opt-in).

• Kezdeti hozzáférés: A felhasználónak kell elindítania egy műveletet, például egy gombra kattintást, amely meghív egy API metódust, mint például a window.showDirectoryPicker(). Ez megnyit egy ismerős, operációs rendszer szintű párbeszédablakot, ahol a felhasználó kiválaszt egy könyvtárat, és kifejezetten a „Hozzáférés megadása” vagy egy hasonló gombra kattint.
• Engedélyállapotok: Egy webhely engedélye egy adott handle-re három állapotban lehet: 'prompt' (az alapértelmezett, a felhasználótól kell kérni), 'granted' (a webhelynek van hozzáférése), vagy 'denied' (a webhely nem férhet hozzá, és ugyanabban a munkamenetben nem kérheti újra).
• Perzisztencia: A jobb felhasználói élmény érdekében a böngésző megőrizheti a 'granted' engedélyt a munkamenetek között telepített PWA-k vagy magas elköteleződésű webhelyek esetében. Ez azt jelenti, hogy a felhasználónak esetleg nem kell minden alkalommal újra kiválasztania a projektmappáját, amikor meglátogatja az alkalmazását. Az aktuális engedélyállapotot a directoryHandle.queryPermission() segítségével ellenőrizheti, és a directoryHandle.requestPermission() segítségével kérheti annak frissítését.

Kulcsfontosságú Módszerek a Hozzáférés Megszerzéséhez

Az API belépési pontjai három globális metódus a window objektumon:

• window.showOpenFilePicker(): Felszólítja a felhasználót egy vagy több fájl kiválasztására. Egy FileSystemFileHandle objektumokból álló tömböt ad vissza.
• window.showDirectoryPicker(): Ez a mi elsődleges eszközünk. Felszólítja a felhasználót egy könyvtár kiválasztására. Egyetlen FileSystemDirectoryHandle-t ad vissza.
• window.showSaveFilePicker(): Felszólítja a felhasználót egy hely kiválasztására egy fájl mentéséhez. Egy FileSystemFileHandle-t ad vissza írásra.

A „Handle”-ök Ereje: FileSystemDirectoryHandle

Amint rendelkezik egy FileSystemDirectoryHandle-lel, egy hatékony objektum van a birtokában, amely azt a könyvtárat képviseli. Nem tartalmazza a könyvtár tartalmát, de metódusokat ad az azzal való interakcióhoz:

• Iteráció: Egy könyvtár tartalmán egy aszinkron iterátor segítségével iterálhat: for await (const entry of directoryHandle.values()) { ... }. Minden entry vagy egy FileSystemFileHandle vagy egy másik FileSystemDirectoryHandle lesz.
• Konkrét bejegyzések feloldása: Egy adott ismert fájlhoz vagy alkönyvtárhoz tartozó handle-t a directoryHandle.getFileHandle('filename.txt') vagy a directoryHandle.getDirectoryHandle('subfolder') segítségével kaphat meg.
• Módosítás: Új fájlokat és alkönyvtárakat hozhat létre a { create: true } opció hozzáadásával a fenti metódusokhoz, vagy eltávolíthatja őket a directoryHandle.removeEntry('item-to-delete') segítségével.

A Lényeg: A Könyvtármonitorozás Megvalósítása

Itt a kulcsfontosságú részlet: a File System Access API nem biztosít natív, eseményalapú figyelő mechanizmust, mint például a Node.js fs.watch() funkciója. Nincs directoryHandle.on('change', ...) metódus. Ez egy gyakran kért funkció, de egyelőre nekünk kell megvalósítanunk a figyelési logikát.

A leggyakoribb és legpraktikusabb megközelítés a periodikus lekérdezés (polling). Ez magában foglalja egy „pillanatkép” készítését a könyvtár állapotáról rendszeres időközönként, és annak összehasonlítását az előző pillanatképpel a változások észleléséhez.

A Naiv Megközelítés: Egy Egyszerű Lekérdezési Ciklus

Egy alapvető megvalósítás valahogy így nézhet ki:

// Egy egyszerűsített példa a koncepció illusztrálására

let initialFiles = new Set();

async function watchDirectory(directoryHandle) {

  const currentFiles = new Set();

  for await (const entry of directoryHandle.values()) {

    currentFiles.add(entry.name);

  }

  // Összehasonlítás az előző állapottal (ez a logika túlságosan egyszerű)

  console.log("Directory checked. Current files:", Array.from(currentFiles));

  // Az állapot frissítése a következő ellenőrzéshez

  initialFiles = currentFiles;

}

// A figyelés indítása

async function start() {

  const directoryHandle = await window.showDirectoryPicker();

  setInterval(() => watchDirectory(directoryHandle), 2000); // Ellenőrzés 2 másodpercenként

}

Ez működik, de nagyon korlátozott. Csak a legfelső szintű könyvtárat ellenőrzi, csak a hozzáadásokat/törléseket képes észlelni (a módosításokat nem), és nincs tokozva. Ez egy kiindulópont, de ennél sokkal jobbat is tehetünk.

Egy Kifinomultabb Megközelítés: Rekurzív Figyelő Osztály Építése

Ahhoz, hogy egy igazán hasznos könyvtárfigyelőt hozzunk létre, egy robusztusabb megoldásra van szükségünk. Tervezzünk egy osztályt, amely rekurzívan átvizsgálja a könyvtárat, követi a fájl metaadatokat a módosítások észleléséhez, és egyértelmű eseményeket bocsát ki a különböző típusú változásokról.

1. Lépés: Részletes Pillanatkép Készítése

Először is szükségünk van egy függvényre, amely rekurzívan bejár egy könyvtárat, és részletes térképet készít a tartalmáról. Ennek a térképnek nemcsak a fájlneveket, hanem a metaadatokat is tartalmaznia kell, mint például a lastModified időbélyeget, ami kulcsfontosságú a változások észleléséhez.

// Függvény egy könyvtár pillanatképének rekurzív létrehozásához

async function createSnapshot(dirHandle, path = '') {

  const snapshot = new Map();

  for await (const entry of dirHandle.values()) {

    const currentPath = path ? `${path}/${entry.name}` : entry.name;

    if (entry.kind === 'file') {

      const file = await entry.getFile();

      snapshot.set(currentPath, {

        lastModified: file.lastModified,

        size: file.size,

        handle: entry

      });

    } else if (entry.kind === 'directory') {

      const subSnapshot = await createSnapshot(entry, currentPath);

      subSnapshot.forEach((value, key) => snapshot.set(key, value));

    }

  }

  return snapshot;

}

2. Lépés: A Pillanatképek Összehasonlítása a Változások Megtalálásához

Ezután szükségünk van egy függvényre, amely összehasonlít egy régi pillanatképet egy újjal, és pontosan azonosítja, hogy mi változott.

// Függvény két pillanatkép összehasonlítására és a változások visszaadására

function compareSnapshots(oldSnapshot, newSnapshot) {

  const changes = {

    added: [],

    modified: [],

    deleted: []

  };

  // Hozzáadott és módosított fájlok ellenőrzése

  newSnapshot.forEach((newFile, path) => {

    const oldFile = oldSnapshot.get(path);

    if (!oldFile) {

      changes.added.push({ path, handle: newFile.handle });

    } else if (oldFile.lastModified !== newFile.lastModified || oldFile.size !== newFile.size) {

      changes.modified.push({ path, handle: newFile.handle });

    }

  });

  // Törölt fájlok ellenőrzése

  oldSnapshot.forEach((oldFile, path) => {

    if (!newSnapshot.has(path)) {

      changes.deleted.push({ path });

    }

  });

  return changes;

}

3. Lépés: A Logika Tokozása egy DirectoryWatcher Osztályba

Végül mindent egy tiszta, újrafelhasználható osztályba csomagolunk, amely kezeli az állapotot és a lekérdezési intervallumot, és egy egyszerű, visszahívás-alapú API-t biztosít.

class DirectoryWatcher {

  constructor(directoryHandle, interval = 1000) {

    this.directoryHandle = directoryHandle;

    this.interval = interval;

    this.lastSnapshot = new Map();

    this.intervalId = null;

    this.onChange = () => {}; // Alapértelmezett üres visszahívás

  }

  async check() {

    try {

      const newSnapshot = await createSnapshot(this.directoryHandle);

      const changes = compareSnapshots(this.lastSnapshot, newSnapshot);

      if (changes.added.length > 0 || changes.modified.length > 0 || changes.deleted.length > 0) {

        this.onChange(changes);

      }

      this.lastSnapshot = newSnapshot;

    } catch (error) {

      console.error("Error while checking for file changes:", error);

      // Lehetséges a figyelés leállítása, ha a könyvtár már nem elérhető

      this.stop();

    }

  }

  async start(callback) {

    if (this.intervalId) {

      console.log("Watcher is already running.");

      return;

    }

    this.onChange = callback;

    // Azonnali kezdeti ellenőrzés végrehajtása

    this.lastSnapshot = await createSnapshot(this.directoryHandle);

    this.intervalId = setInterval(() => this.check(), this.interval);

    console.log(`Started watching "${this.directoryHandle.name}" for changes.`);

  }

  stop() {

    if (this.intervalId) {

      clearInterval(this.intervalId);

      this.intervalId = null;

      console.log(`Stopped watching "${this.directoryHandle.name}".`);

    }

  }

}

// A DirectoryWatcher osztály használata

const startButton = document.getElementById('startButton');

const stopButton = document.getElementById('stopButton');

let watcher;

startButton.addEventListener('click', async () => {

  try {

    const directoryHandle = await window.showDirectoryPicker();

    watcher = new DirectoryWatcher(directoryHandle, 2000); // Ellenőrzés 2 másodpercenként

    watcher.start((changes) => {

      console.log("Changes detected:", changes);

      // Most már frissítheti a felhasználói felületet ezen változások alapján

    });

  } catch (error) {

    console.error("User cancelled the dialog or an error occurred.", error);

  }

});

stopButton.addEventListener('click', () => {

  if (watcher) {

    watcher.stop();

  }

});

Gyakorlati Felhasználási Esetek és Globális Példák

Ez a technológia nem csupán elméleti gyakorlat; hatékony, valós alkalmazásokat tesz lehetővé, amelyek globális közönség számára elérhetők.

1. Webalapú IDE-k és Kódszerkesztők

Ez a legjellegzetesebb felhasználási eset. Az olyan eszközök, mint a VS Code for the Web vagy a GitHub Codespaces, lehetővé tehetik a fejlesztők számára, hogy megnyissanak egy helyi projektmappát. A könyvtárfigyelő ezután figyelheti a változásokat:

• Fájlfa Szinkronizáció: Amikor egy fájlt létrehoznak, törölnek vagy átneveznek a lemezen (esetleg egy másik alkalmazás segítségével), a szerkesztő fájlfája azonnal frissül.
• Élő Újratöltés/Előnézet: Webfejlesztés esetén a HTML, CSS vagy JavaScript fájlokba mentett változások automatikusan frissíthetik a szerkesztőn belüli előnézeti panelt.
• Háttérfeladatok: Egy fájl módosítása háttérben futó lintinget, típusellenőrzést vagy fordítást indíthat el.

2. Digitális Vagyonkezelés (DAM) Kreatív Szakemberek Számára

Egy fotós a világ bármely pontján csatlakoztatja a fényképezőgépét a számítógépéhez, és a fotók egy adott „Bejövő” mappába mentődnek. Egy webalapú fotókezelő eszköz, miután hozzáférést kapott ehhez a mappához, figyelheti az új hozzáadásokat. Amint egy új JPEG vagy RAW fájl megjelenik, a webalkalmazás automatikusan importálhatja, létrehozhat egy miniatűr képet, és hozzáadhatja a felhasználó könyvtárához, mindezt manuális beavatkozás nélkül.

3. Tudományos és Adatelemző Eszközök

Egy kutatólaboratórium berendezése óránként több száz kis CSV vagy JSON adatfájlt generálhat egy kijelölt kimeneti könyvtárba. Egy webalapú műszerfal figyelheti ezt a könyvtárat. Ahogy új adatfájlok kerülnek hozzáadásra, képes azokat feldolgozni és valós időben frissíteni a grafikonokat, diagramokat és statisztikai összefoglalókat, azonnali visszajelzést adva a folyamatban lévő kísérletről. Ez globálisan alkalmazható a biológiától a pénzügyekig terjedő területeken.

4. „Local-First” Jegyzetelő és Dokumentációs Alkalmazások

Sok felhasználó inkább egyszerű szöveges vagy Markdown fájlokként tartja a jegyzeteit egy helyi mappában, ami lehetővé teszi számukra, hogy olyan hatékony asztali szerkesztőket használjanak, mint az Obsidian vagy a Typora. Egy Progresszív Webalkalmazás (PWA) társként működhet, figyelve ezt a mappát. Amikor a felhasználó szerkeszt egy fájlt és elmenti, a webalkalmazás észleli a módosítást és frissíti a saját nézetét. Ez egy zökkenőmentes, szinkronizált élményt teremt a natív és webes eszközök között, tiszteletben tartva a felhasználó adatainak tulajdonjogát.

Kihívások, Korlátok és Bevált Gyakorlatok

Bár hihetetlenül hatékony, a könyvtárfigyelés megvalósítása számos kihívással és felelősséggel jár.

Böngészőkompatibilitás

A File System Access API egy modern technológia. 2023 végétől elsősorban a Chromium-alapú böngészőkben támogatott, mint a Google Chrome, a Microsoft Edge és az Opera. Nem érhető el a Firefoxban vagy a Safariban. Ezért kulcsfontosságú:

• Funkcióérzékelés: Mindig ellenőrizze a 'showDirectoryPicker' in window létezését, mielőtt megpróbálná használni az API-t.
• Tartalék megoldások biztosítása: Ha az API nem támogatott, kecsesen rontsa le az élményt. Visszaeshet a hagyományos <input type="file" multiple> elemre, tájékoztatva a felhasználót a támogatott böngészőben elérhető továbbfejlesztett képességekről.

Teljesítményi Megfontolások

A lekérdezés (polling) eredendően kevésbé hatékony, mint egy rendszerszintű, eseményalapú megközelítés. A teljesítményköltség közvetlenül összefügg a figyelt könyvtár méretével és mélységével, valamint a lekérdezési intervallum gyakoriságával.

• Nagy könyvtárak: Egy több tízezer fájlt tartalmazó könyvtár másodpercenkénti átvizsgálása jelentős CPU erőforrásokat emészthet fel és lemerítheti egy laptop akkumulátorát.
• Lekérdezési gyakoriság: Válassza a leghosszabb intervallumot, amely még elfogadható a felhasználási esethez. Egy valós idejű kódszerkesztőnek szüksége lehet 1-2 másodperces intervallumra, de egy fotókönyvtár-importáló esetében 10-15 másodperces intervallum is megfelelő lehet.
• Optimalizálás: A pillanatkép-összehasonlításunk már optimalizált, mivel csak a lastModified és a size adatokat ellenőrzi, ami sokkal gyorsabb, mint a fájltartalmak hash-elése. Kerülje a fájltartalmak olvasását a lekérdezési ciklusban, hacsak nem feltétlenül szükséges.
• Fókuszváltások: Egy okos optimalizálás a figyelő szüneteltetése, amikor a böngészőfül nincs fókuszban, a Page Visibility API segítségével.

Biztonság és Felhasználói Bizalom

A bizalom a legfontosabb. A felhasználók jogosan óvatosak, amikor webhelyeknek adnak hozzáférést a helyi fájljaikhoz. Fejlesztőként felelősségteljesen kell gazdálkodnia ezzel a hatalommal.

• Legyen átlátható: Világosan magyarázza el a felhasználói felületen, miért van szüksége könyvtár-hozzáférésre. Egy „Válassza ki a projektmappáját az élő fájlszinkronizálás engedélyezéséhez” üzenet sokkal jobb, mint egy általános „Mappa megnyitása” gomb.
• Felhasználói műveletre kérjen hozzáférést: Soha ne indítsa el a showDirectoryPicker() párbeszédablakot közvetlen és nyilvánvaló felhasználói művelet, például egy gombra kattintás nélkül.
• Kecsesen kezelje az elutasításokat: Ha a felhasználó a „Mégse” gombra kattint, vagy elutasítja az engedélykérést, az alkalmazásának elegánsan, összeomlás nélkül kell kezelnie ezt az állapotot.

UI/UX Bevált Gyakorlatok

A jó felhasználói élmény kulcsfontosságú ahhoz, hogy ez a hatékony funkció intuitívnak és biztonságosnak érződjön.

• Adjon egyértelmű visszajelzést: Mindig jelenítse meg az éppen figyelt könyvtár nevét. Ez emlékezteti a felhasználót arra, hogy milyen hozzáférést adott meg.
• Kínáljon explicit vezérlőket: Tartalmazzon egyértelmű „Figyelés indítása” és „Figyelés leállítása” gombokat. A felhasználónak mindig éreznie kell, hogy ő irányítja a folyamatot.
• Kezelje a hibákat: Mi történik, ha a felhasználó átnevezi vagy törli a figyelt mappát, miközben az alkalmazás fut? A következő lekérdezés valószínűleg hibát fog dobni. Kapja el ezeket a hibákat, és tájékoztassa a felhasználót, esetleg a figyelő leállításával és egy új könyvtár kiválasztására való felszólítással.

A Jövő: Mi Várható a Fájlrendszer Hozzáférés Terén a Weben?

A jelenlegi lekérdezés-alapú megközelítés egy okos és hatékony kerülőút, de nem az ideális hosszú távú megoldás. A webes szabványokkal foglalkozó közösség tisztában van ezzel.

A leginkább várt jövőbeli fejlesztés egy natív, eseményvezérelt fájlrendszer-figyelő mechanizmus lehetséges hozzáadása az API-hoz. Ez valódi áttörést jelentene, lehetővé téve a böngészők számára, hogy az operációs rendszer saját hatékony értesítési rendszereihez kapcsolódjanak (mint például az inotify Linuxon, az FSEvents macOS-en, vagy a ReadDirectoryChangesW Windowson). Ez megszüntetné a lekérdezés szükségességét, drasztikusan javítva a teljesítményt és a hatékonyságot, különösen nagy könyvtárak és akkumulátorról működő eszközök esetében.

Bár nincs konkrét időterv egy ilyen funkcióra, annak lehetősége egyértelműen jelzi, hogy a webplatform milyen irányba halad: egy olyan jövő felé, ahol a webalkalmazások képességeit nem a böngésző homokozója korlátozza, hanem csak a képzeletünk.

Összegzés

A frontend fájlrendszer-könyvtármonitorozás, amelyet a File System Access API hajt, egy átalakító technológia. Lebont egy régóta fennálló akadályt a web és a helyi asztali környezet között, lehetővé téve a kifinomult, interaktív és produktív böngészőalapú alkalmazások új generációját. Az alap API megértésével, egy robusztus lekérdezési stratégia megvalósításával, valamint a teljesítményre és a felhasználói bizalomra vonatkozó bevált gyakorlatok betartásával a fejlesztők olyan élményeket hozhatnak létre, amelyek integráltabbnak és erőteljesebbnek érződnek, mint valaha.

Bár jelenleg saját figyelők építésére támaszkodunk, az általunk tárgyalt elvek alapvetőek. Ahogy a webplatform tovább fejlődik, a felhasználó helyi adataival való zökkenőmentes és hatékony interakció képessége a modern alkalmazásfejlesztés sarokköve marad, felhatalmazva a fejlesztőket, hogy valóban globális eszközöket építsenek, amelyek bárki számára elérhetők egy böngészővel.