Wstęp (11)

Rozdział 1. Ale o co w ogóle chodzi? (13)

• Nasz cel: BEMQuery (13)
  • BEM zamiast DOM (13)
  • Moduły i jeszcze raz moduły (14)
  • Najnowsza wersja JS-a (14)
  • Eksperymentowanie (14)
• Ale zaraz, zaraz... Biblioteka, nie framework? (14)
• Dlaczego ES6? (16)
  • Wsparcie przeglądarek (16)
  • Wsparcie ekosystemu i środowiska (17)
  • ECMAScript - żywy standard? (17)
• BEM - ale właściwie co to takiego? (18)
  • Blok (18)
  • Element (19)
  • Modyfikator (19)
  • Konwencja nazewnicza (20)
• Podsumowanie (22)

Rozdział 2. Tworzymy nasze środowisko pracy! (25)

• Git + GitHub, czyli mamy wszystko pod kontrolą (25)
• Node.js + npm (27)
  • Pierwszy skrypt w Node.js (28)
• npm - a na co mi to? (29)
• ESLint - czyli poznajemy trochę ECMAScript 6, wyrabiając sobie... styl (30)
  • ESLint? (31)
  • Nasz styl (31)
• npm - "ogarniamy" prosty projekt! (39)
  • Tworzymy nowy projekt! (39)
  • Instalujemy ESLinta i chalk (41)
  • Tworzymy logger (42)
  • Skrypty npm (43)
  • Konfiguracja ESLinta (45)
• Zadanie domowe (49)
• Podsumowanie (49)

Rozdział 3. Wielki głaz czy małe kamyczki? Monolityczność vs modularność (51)

• Stara, dobra era jQuery (51)
  • Duży głaz = większy rozmiar (52)
• Wielki monolit = jeden moduł (53)
  • Jednowersjonowość, czyli kiepski neologizm w natarciu (53)
  • Łysiejący developerzy i znerwicowani maintainerzy (54)
  • Bo co jest do wszystkiego... (54)
• Dzielimy BEMQuery! (55)
  • Silnik selektorów (55)
  • Trzon biblioteki (55)
  • Moduł DOM (56)
  • Moduł eventów (56)
  • Moduł animacji (56)
  • Bycze monstrum, czyli jak użytkownik spotkał developera (56)
  • Moduły a npm i GitHub (57)
• Standardy modułów w JS-ie (58)
  • Moduł, czyli co? (59)
  • Wzorzec modułu (60)
  • Standard CJS (60)
  • Standard AMD (62)
  • Standard UMD (64)
  • Moduły ES6 (65)
• Jak wczytać moduły ES6? (66)
  • jsnext:main (68)
  • Szybki test (69)
• Zadanie domowe (69)
• Podsumowanie (70)

Rozdział 4. TDD - najpierw testy, potem kod! (71)

• Testy? (71)
• Rodzaje testów (72)
• TDD, czyli wywracamy wszystko do góry nogami (73)
• Testowanie w JS-ie (74)
• Karma (75)
• Mocha (77)
• Chai (80)
• Sinon (81)
• Test coverage (83)
• Continuous Integration (84)
• Zadanie domowe (85)
• Podsumowanie (85)

Rozdział 5. Tworzymy idealny projekt modułu w JS-ie! (87)

• Ściągamy boilerplate'a! (87)
• Struktura katalogów projektu (89)
  • Katalog src (90)
  • Katalog tests (90)
  • Katalog config (90)
  • Katalog dist (91)
• Zależności (92)
  • Narzędzia do testowania (93)
  • Narzędzia do budowania (93)
  • Narzędzia do publikacji (94)
  • Narzędzia do dokumentacji (94)
• Skrypty npm (94)
• Testowanie (95)
  • Konfiguracja (96)
• Jak użyć boilerplate'a? (98)
  • Droga niegitowa (98)
  • Droga gitowa (98)
  • Aktualizacja boilerplate'a (101)
• Zadanie domowe (102)
• Podsumowanie (102)

Rozdział 6. Silnik selektorów (103)

• Silnik selektorów - WTF? (103)
• Rozwiązanie natywne (104)
• Sizzle (106)
• Selektory BEM (107)
• Drzewko BEM (108)
• Projektujemy silnik selektorów! (109)
  • SOLID (109)
  • Dzielimy silnik selektorów na części! (112)
• Klasy?! (113)
• Tworzymy klasę Selector! (117)
• Konwerter selektorów (120)
  • Konfiguracja (121)
  • Konwertowanie selektorów (123)
  • Łączymy to do kupy! (127)
  • Piszemy sensowne regułki (130)
• Zatem tworzymy silnik! (134)
  • Testy, testy (134)
  • Kod, kod (136)
• Fabryka (139)
• Eksporter (141)
• Zadanie domowe (141)
• Podsumowanie (142)

Rozdział 7. Worek na elementy (145)

• "Podstawowa funkcjonalność" (145)
  • Zawsze zwracaj obiekt BEMQuery (146)
  • Bardziej intuicyjna metoda each (146)
• Klasa BEMQuery (146)
  • Konstruktor (147)
  • Metoda get (147)
  • Metoda each (148)
• Testy - znowu (148)
  • Mocki (148)
  • Fixtures (149)
  • Testy dla konstruktora (150)
• Piszemy konstruktor! (152)
• Iteratory (156)
  • Obiekty "iterowalne" (158)
  • Symbol - WTF?! (158)
  • Implementujemy iterator w BEMQuery! (158)
• Metoda get (161)
• Metoda each (162)
• Fluent API (163)
• Pseudotablica (163)
  • Niepotrzebnie udziwniony i utrudniony, ale dający respekt na dzielni (164)
  • Cholernie prostacki i prymitywny, z którego na dzielni się śmieją (164)
  • Udziwniony, utrudniony, bez respektu i bez śmiechu, ale całkiem, całkiem (164)
• Fabryka (167)
• Główny plik modułu (169)
• Zadanie domowe (170)
• Podsumowanie (171)

Rozdział 8. "Ma być szybko!", czyli operacje na DOM (173)

• Co będziemy robić? (173)
• Rozgrzewka (174)
• Dlaczego DOM jest wolny? (175)
  • Obserwowanie zjawiska (177)
• Wirtualny DOM (179)
  • BEM Tree jako wirtualny DOM? (180)
• Incremental DOM (180)
• Asynchroniczny DOM (180)
• Obiecanki (182)
• Piszemy nasz moduł! (186)
  • Batch (186)
  • Włączamy Batch do biblioteki (188)
  • Mocki (190)
  • Dobieramy się do stanów! (191)
  • Pokaż kotku, co masz w środku! (194)
  • Główny plik modułu (196)
  • Testujemy! (197)
• Wild refactoring appears! (197)
• Zadanie domowe (199)
• Podsumowanie (200)

Rozdział 9. "PRZESTAŃ MNIE KLIKAĆ!", czyli o zdarzeniach słów kilka (201)

• Co to właściwie są "zdarzenia DOM"? (201)
  • Listenery (201)
  • Obiekt Event (203)
  • Fazy propagacji zdarzenia (203)
  • Uruchamianie zdarzeń (209)
• Piszemy moduł (210)
  • Metoda on (210)
  • Metoda off (215)
  • Plik modułu (221)
• Zadanie domowe (221)
• Podsumowanie (221)

Rozdział 10. "Coś mi się tu rusza" - o animacji słów kilka (223)

• Po co nam animacje? (223)
• Dlaczego animacje są wolne? (225)
  • Model RAIL (225)
• Jak animować? (226)
  • Przykład (226)
  • Liczniki (227)
  • Optymalizacja CSS (228)
  • Porzucamy liczniki! (229)
  • Transitions (231)
  • Animacje (232)
  • Web Animations API (232)
  • SMIL (233)
  • Użycie "gotowca" (233)
• Zadanie domowe (233)
• Podsumowanie (234)

Rozdział 11. Piszemy dokumentację... (235)

• Plik README.md (235)
• Plik CHANGELOG.md (236)
• Plik CONTRIBUTING.md (237)
• Pliki w katalogu .github (237)
• Plik LICENSE (238)
• Plik tonic-example.js (238)
• Metadane w pliku package.json (239)
• Dokumentacja kodu JS (239)
  • Generowanie dokumentacji (241)
  • Publikowanie dokumentacji (241)
• Zadanie domowe (242)
• Podsumowanie (242)

Rozdział 12. Rozprowadzamy ten towar... (243)

• Publikacja modułu na npm (243)
  • Podbicie numeru wersji wraz z publikacją jej na GitHubie (244)
  • Publikacja pakietu na npm (245)
  • Budowanie? (246)
• Piszemy moduł bemquery (248)
• Szybki test (249)
• Jak używać? (249)
• Zadanie domowe (250)
• Podsumowanie (250)

Podziękowania (253)

Skorowidz (254)

• Tytuł: JavaScript. Programowanie zaawansowane
• Autor: Tomasz "Comandeer" Jakut
• ISBN: 978-83-283-3116-7, 9788328331167
• Data wydania: 2016-09-11
• Format: Ebook
• Identyfikator pozycji: jascpz
• Wydawca: Helion