Angular 2. Tworzenie interaktywnych aplikacji internetowych - ebook

Wykorzystywanie komponentów do budowy aplikacji internetowych jest uważane za wyjątkowo ważny krok naprzód w tej dziedzinie. Szczególnie ciekawym pomysłem jest tworzenie interfejsów użytkownika bazujących na komponentach. Framework Angular 2 zmienia technologię tworzenia aplikacji: ułatwia pisanie współdzielonych bloków kodu HTML, które można bez problemu wielokrotnie wykorzystywać dzięki zastosowaniu mechanizmu shadow DOM. Jest to bardzo obiecująca perspektywa, jednakże pod warunkiem, że programista potrafi efektywnie wykorzystać architekturę komponentową.

Niniejsza książka ma na celu nauczenie programistów tego nowego podejścia do programowania interaktywnych stron internetowych i równocześnie pokazanie najlepszych możliwości Angulara. Poza praktycznymi aspektami korzystania z tego frameworka największy nacisk położono na tworzenie interfejsów użytkownika bazujących na komponentach — wyjaśniono podstawowe koncepcje tego sposobu programowania i opisano, jak wykorzystać framework do tworzenia nowoczesnych, wydajnych i łatwych w utrzymaniu interfejsów użytkownika.

Niektóre zagadnienia omówione w książce:

• podstawy tworzenia interfejsów z wykorzystaniem komponentów
• tworzenie komponentów wielokrotnego użytku w Angularze
• wykorzystanie komponentów do routingu, logowania i śledzenia czasu
• korzystanie z zewnętrznych bibliotek w Angularze
• zapewnienie rozszerzalności komponentów
• techniki testowania komponentów Angular 2

Architektura oparta na komponentach — najlepsza recepta na świetny interfejs!

---

Gion Kunz od wielu lat pisze interaktywne interfejsy użytkownika w języku JavaScript. Bardzo chętnie korzysta z frameworka Angular 2. Często zabiera głos na konferencjach. Kunz jest również głównym instruktorem w SAE Institute w Zurichu. Jest osobą, która angażuje się na rzecz open source — napisał responsywną bibliotekę do rysowania wykresów Chartist. W wolnych chwilach zajmuje się muzyką, wędkowaniem lub po prostu spędza czas ze swoją ukochaną i milutkim, małym pieskiem.

O autorze (9)

O redaktorze merytorycznym (10)

Przedmowa (11)

Rozdział 1. Interfejsy użytkownika bazujące na komponentach (17)

• Myślenie w kategoriach organizmów (18)
• Komponenty, czyli organy interfejsu użytkownika (19)
  
  • Enkapsulacja (19)
  • Łatwość kompozycji (22)
  • Komponenty, czyli rozwiązanie wymyślone przez naturę (23)
  • Czas na nowe standardy (27)
• Architektura komponentowa w Angularze (29)
  
  • Wszystko jest komponentem (30)
• Pierwszy komponent (31)
  
  • JavaScript przyszłości (33)
• Narzędzia (40)
  
  • Node.js i NPM (40)
  • SystemJS i JSPM (41)
• Podsumowanie (43)

Rozdział 2. Trzy, dwa, jeden, start! (45)

• Zarządzanie zadaniami (45)
  
  • Wizja (46)
• Zaczynamy od zera (47)
  
  • Moduł aplikacji (51)
  • Kod startowy aplikacji (52)
  • Uruchomienie aplikacji (52)
  • Powtórka (53)
• Tworzenie listy zadań (53)
  
  • Powtórka (56)
• Właściwy poziom enkapsulacji (56)
  
  • Powtórka (58)
• Wejście generuje wyjście (59)
  
  • Powtórka (62)
• Własne elementy interfejsu użytkownika (62)
  
  • Powtórka (70)
• Filtrowanie zadań (70)
• Podsumowanie (74)

Rozdział 3. Tworzenie kompozycji przy użyciu komponentów (75)

• Dane - od tymczasowej listy do prawdziwej bazy danych (76)
• Programowanie reaktywne z użyciem obserwowalnych struktur danych (76)
• Niezmienność (84)
• Czyste komponenty (86)
  
  • Oczyszczanie listy zadań (89)
  • Powtórka (95)
• Kompozycja z użyciem rzutowania treści (95)
• Tworzenie komponentu zakładek (97)
  
  • Powtórka (100)
• Mieszanie rzutowanej i generowanej zawartości (101)
• Podsumowanie (107)

Rozdział 4. Tylko bez komentarzy, proszę! (109)

• Jeden edytor, by wszystkimi rządzić (110)
  
  • Tworzenie komponentu edytora (110)
  • Powtórka (118)
• Budowanie systemu komentarzy (118)
  
  • Budowanie systemu komentarzy (119)
  • Budowanie komponentu komentarzy (122)
  • Powtórka (129)
• Podsumowanie (130)

Rozdział 5. Routing a komponenty (133)

• Wprowadzenie do routera Angulara (134)
• Kompozycja poprzez routing (134)
  
  • Kompozycja za pomocą szablonu czy routera (136)
  • Jak działa drzewo routingu? (137)
• Powrót do korzeni (139)
  
  • Zakładki wykorzystujące router (147)
• Refaktoryzacja nawigacji (149)
• Podsumowanie (151)

Rozdział 6. Strumień aktywności, czyli co się działo (153)

• Wykonanie usługi do tworzenia dziennika aktywności (154)
  
  • Tworzenie dziennika aktywności (156)
• Wykorzystanie elastyczności SVG (158)
  
  • Nadawanie SVG stylów (160)
  • Budowanie komponentów SVG (162)
• Tworzenie komponentu interaktywnego suwaka aktywności (164)
  
  • Rzutowanie czasu (167)
  • Renderowanie znaczników aktywności (169)
  • Tchnięcie życia w suwak (172)
  • Powtórka (175)
• Tworzenie strumienia aktywności (175)
• Dodanie aktywności do modułu projektu (179)
• Podsumowanie (180)

Rozdział 7. Komponenty poprawiające działanie aplikacji (183)

• Zarządzanie etykietami (184)
  
  • Encja danych etykiety (184)
  • Generowanie etykiet (185)
  • Tworzenie usługi etykiet (186)
  • Renderowanie etykiet (188)
  • Integracja usługi etykiet (190)
  • Włączenie renderowania etykiet (192)
• Obsługa wpisywania etykiety (193)
  
  • Tworzenie menedżera wpisywania etykiet (194)
  • Tworzenie komponentu wyboru etykiet (196)
  • Integracja listy etykiet z komponentem edytora (199)
  • Koniec prac nad systemem etykiet (201)
• Przeciągnij i upuść (201)
  
  • Implementacja dyrektywy przeciągania (202)
  • Implementacja dyrektywy dla strefy upuszczania (205)
  • Integracja funkcjonalności "przeciągnij i upuść" w komponencie listy zadań (208)
  • Powtórka (210)
• Do nieskończoności, a nawet dalej! (211)
  
  • Składnia z gwiazdką i szablony (211)
  • Tworzenie dyrektywy przewijania w nieskończoność (213)
  • Wykrywanie zmian w dyrektywie szablonu (216)
  • Dodawanie i usuwanie osadzonych widoków (218)
  • Zakończenie tworzenia dyrektywy (223)
• Podsumowanie (223)

Rozdział 8. Czas pokaże (225)

• Szczegóły zadania (226)
• Włączenie etykiet dla zadań (230)
• Zarządzanie czasochłonnością (232)
  
  • Pole wprowadzania czasu (233)
  • Komponenty związane z obsługą czasu (235)
  • Wizualne przedstawienie postępów prac (240)
  • Powtórka z obsługi czasu (243)
• Konfiguracja kamieni milowych (244)
  
  • Tworzenie komponentu automatycznego uzupełniania (244)
• Podsumowanie (251)

Rozdział 9. Konsoleta statku kosmicznego (253)

• Wprowadzenie do Chartist (254)
• Panel projektów (257)
  
  • Tworzenie komponentu panelu projektów (258)
  • Komponent podsumowania projektu (259)
• Tworzymy pierwszy komponent wykresu (264)
• Wizualizacja otwartych zadań (269)
  
  • Tworzenie wykresu otwartych zadań (272)
  • Tworzenie legendy wykresu (275)
  • Nadawanie interaktywności wykresowi (277)
• Podsumowanie (280)

Rozdział 10. Zapewnienie rozszerzalności systemu (281)

• Architektura modułowa (282)
• Komponenty interfejsu użytkownika jako moduły dodatkowe (284)
• Implementacja API modułów dodatkowych (285)
  
  • Wstawianie komponentów z pluginu (290)
  • Ukończenie architektury pluginów (295)
• Budowanie pluginu dla projektów w stylu zwinnym (296)
  
  • Komponent informacji o zwinnym zadaniu (299)
  • Komponent szczegółów zadania (301)
  • Powtórka z tworzenia pluginu (305)
• Zarządzanie pluginami (305)
  
  • Wczytywanie pluginów w trakcie działania aplikacji (308)
• Podsumowanie (311)

Rozdział 11. Testowanie komponentów (313)

• Wprowadzenie do Jasmine (314)
• Tworzenie pierwszego testu (317)
• Szpiegowanie wyników działania komponentu (319)
• Narzędzia do testowania komponentów (322)
  
  • Wstrzykiwanie w testach (323)
  • Narzędzie do testowania komponentów (325)
• Zaawansowane testowanie komponentów (330)
• Testowanie interakcji komponentu (333)
• Testowanie systemu pluginów (335)
• Podsumowanie (340)

Dodatek A. Kod źródłowy aplikacji do zarządzania zadaniami (341)

• Wymagania wstępne (341)
• Użycie (342)
• Rozwiązywanie problemów (342)
  
  • Czyszczenie danych w bazie IndexedDB (342)
  • Włączenie komponentów webowych w przeglądarce Firefox (343)

Skorowidz (345)