What you will learn in Vanilla Web
Building apps without frameworks
Chapter by chapter
Chapter 1: Hello Vanilla Web
The introduction argues for choosing web tools based on project needs, explains the appeal of working directly with the browser, and distinguishes libraries from frameworks.
What you learn in chapter 1 →Chapter 2: Understanding the web platform
The chapter introduction argues that the web platform is powerful by default, even though a focus on libraries and frameworks can obscure its advantages.
What you learn in chapter 2 →Chapter 3: The user interface
The chapter introduces a platform-first approach to UI and explains why Vanilla Web favors declarative HTML, CSS, and native controls.
What you learn in chapter 3 →Chapter 4: Vanilla CSS
The chapter introduces direct use of modern CSS for Vanilla Web apps and gives principles for keeping styles maintainable.
What you learn in chapter 4 →Chapter 5: Vanilla JavaScript
Introduces Vanilla JavaScript’s role in web apps and explains why ECMAScript versioning matters when code is shipped without a framework build process.
What you learn in chapter 5 →Chapter 6: The document object model API
Introduces the DOM as the browser’s in-memory document tree and explains why native APIs and careful updates are enough to build interfaces without a library.
What you learn in chapter 6 →Chapter 7: Web components
Introduces web components as the chapter’s approach to building maintainable, reusable user interfaces and previews the topics ahead.
What you learn in chapter 7 →Chapter 8: Working with templates and slots
The introduction explains why inline web-component markup may become less suitable as components and applications grow, then previews the chapter’s alternatives.
What you learn in chapter 8 →Chapter 9: Advanced web components
This introduction previews advanced web component topics aimed at making components more like native controls, easier to integrate, and simpler to ship.
What you learn in chapter 9 →Chapter 10: Navigation
Introduces navigation as movement between views and routing as matching a URL to content, while explaining why SPA routing still depends on the browser and server.
What you learn in chapter 10 →Chapter 11: Building a router
The chapter previews building a client-side router from matched routes, including rendering, browser-cue updates, and view transitions.
What you learn in chapter 11 →Chapter 12: Working with data
The chapter introduces working with data in Vanilla Web by contrasting framework-packaged data features with solutions assembled from browser primitives.
What you learn in chapter 12 →Chapter 13: Data binding and reactivity
The introduction frames data binding as keeping a Vanilla app’s interface synchronized with changing data in both directions, without a framework runtime.
What you learn in chapter 13 →Chapter 14: Beyond basics
This chapter introduction previews small libraries, performance techniques, offline support, and installability for Vanilla Web apps.
What you learn in chapter 14 →Chapter 15: Building an app
Introduces Luma Books and outlines the static Vanilla Web app that the chapter builds.
What you learn in chapter 15 →Concepts explained in this book
- vanilla webAn approach to building websites and web applications with core web technologies and browser APIs without a framework defining the application architecture.
- progressive enhancementProgressive enhancement is an approach that starts with broadly compatible baseline functionality and adds capabilities when supported by the user's device and browser.
- Custom ElementsA developer-defined HTML element registered through the browser's custom element APIs with custom behavior and lifecycle callbacks.
- feature detectionFeature detection is a technique for determining at runtime whether a browser or environment supports a particular capability.
- Web ComponentsA reusable custom HTML element built using browser standards such as custom elements, shadow DOM, and HTML templates.
- routingComparing a navigation destination with route definitions to select a view or handler.
- semantic markupThe practice of using HTML elements according to their meaning to represent a document's content and structure.
- HTML template elementThe HTML <template> element holds inert markup that can later be cloned and inserted into a document or shadow DOM.
- Navigation APIA browser API for observing and controlling navigation, including intercepting navigations.
- Document Object ModelThe browser programming interface for querying and manipulating a document's DOM representation.
- Fetch APIA function of the Fetch API that initiates a network request and returns a promise for its response.
- server-side renderingGenerating HTML on a server for delivery to a browser.
- fallbackAn alternative implementation or behavior used when a preferred feature or supplied content is unavailable.
- progressive web appA progressive web app is a web application that can be installed on an operating system and provide a standalone app-like experience with optional offline operation and operating-system integration.
- connectedcallbackconnectedCallback is a custom element lifecycle callback that the browser invokes when the element is attached to a document DOM.
- prerenderingStatic site generation is the process of producing deployable HTML files from templates and content before those files are served to users.
- rendering engineA rendering engine is browser software that parses web content and produces the rendered document and interactive page experience.
- slot elementThe HTML <slot> element defines an insertion point for content projected into a web component's shadow tree.
- CSS variableA CSS custom property is an author-defined property whose value can be inherited and reused in CSS declarations through the var() function.
- ECMAScript moduleAn ECMAScript module is a separately scoped JavaScript module with explicit import and export bindings.
- Web APIsA programming interface exposed by a web browser for accessing web-platform or device capabilities.
- CustomEventA script-created DOM event that can carry application-specific data and participate in event propagation.
- manifest fileA manifest file is a structured web-application configuration file that declares metadata and installation-related properties.
- attributeA JavaScript property is a named value associated with an object.
- CSSVanilla CSS is an approach to styling web interfaces with modern CSS directly, without CSS pre-compilers or core styling libraries.
- Shadow DOMShadow DOM is a web platform feature for attaching an encapsulated DOM tree to an element.
- History APIThe History API is a browser API for manipulating session history entries and navigating between document URLs without necessarily loading new documents.
- Cache Storage APIThe Cache Storage API is a browser API for storing and retrieving request–response pairs, commonly to support offline use and control of network responses.
- JavaScriptA programming language standardized as ECMAScript and widely used to implement behavior in web browsers.
- single-page applicationA single-page application is a web application that updates its interface within one loaded document rather than performing full document loads for each view.
- renderingRendering is the process of producing visible interface content from application data, state, or route information.
- micro-libraryA small software library providing narrowly scoped functionality.
- apiAn API surface is the set of interfaces and operations that software exposes for external use.
- componentA self-contained software unit designed for use in multiple parts of an application or across applications.
- web platformThe collection of browser-provided standards and technologies, including HTML, CSS, and JavaScript, that support web application development.
- addEventListeneraddEventListener is a DOM API method that registers a callback for events of a specified type on an event target.
- application shellAn application shell is the persistent structure and shared interface of an application around content that changes or loads separately.
- originA web security identity defined by a scheme, host, and port that determines the boundary for same-origin access.
- ElementInternalsElementInternals is a browser interface that provides a custom element with access to internal capabilities such as form participation and accessibility semantics.
- URLA URL is a standardized textual address that identifies a web resource or navigation destination and can include protocol, host, port, path, query, and fragment components.
- event delegationAn event-handling technique that registers a listener on an ancestor and identifies relevant descendant interactions from the event.
- URLPatternURLPattern is a web-platform API for matching URLs against structured patterns and extracting their components or parameters.
- shadow rootA shadow root is the encapsulated DOM subtree attached to a shadow host for implementing a web component's internal structure and presentation.
- navigation modelA navigation model is an architectural scheme that determines how URLs and user navigation map to web application content or views.
- data attributeA custom HTML attribute whose name begins with data- and whose value stores application-specific information on an element.
- stateData representing an application's current condition and behavior.
- accessibilityThe degree to which a product or service can be used by people with varied abilities and disabilities.
- customElements.defineA browser method that registers a custom element name with its constructor and optional built-in-element extension options.
- web standardsA public technical specification defining interoperable web languages, APIs, protocols, or platform behavior.
- route handlerA route handler is a function or component associated with a route that produces the content or response for that destination.
- client-side renderingClient-side rendering is the generation or updating of a web interface in the user's browser using client-side code.
- static siteA website whose pages are served as prebuilt files rather than assembled by application code for each visitor request.
- incremental static regenerationIncremental static regeneration is a static-generation technique that regenerates deployed pages in the background on a schedule or when requested.
- multi-page appA multi-page application is a web application whose navigation commonly loads separate HTML documents for different routes or views.
- partial hydrationIslands architecture is a rendering pattern in which mostly static server-rendered HTML contains independently hydrated interactive regions.
- rendering modelA rendering model is an architectural scheme that determines where and when web-page content is generated.
- universal renderingUniversal rendering is an architecture that renders initial HTML on the server and then enables client-side interactivity through hydration.
- DOM fragmentA lightweight DOM container that holds a subtree of nodes without being part of the document tree itself.
- history.pushState()history.pushState() adds a session-history entry with optional state and URL without loading a new document.
- navigate eventA Navigation API event dispatched when a navigation is initiated.
- bubble phaseThe event-propagation stage in which an event travels from its target back through ancestor elements.
- event capturingThe event-propagation stage in which an event travels down the DOM tree toward its target.
- handlerAn event listener is a callback registration that causes code to run when a specified event occurs.
- event phaseA stage in an event's traversal through the DOM, consisting of capture, target, or bubble processing.
- rewrite ruleA rewrite rule is server configuration that maps an incoming request path to a different resource or response without changing the requested URL.
- url fragmentA hash fragment is the fragment identifier following a URL's hash mark that identifies a target within a document.
- BaselineA WebDX initiative that reports when web platform features reach specified levels of availability across major browsers.
- datasetA DOM property that exposes an element’s data-* attributes through a camelCase-keyed object of string values.
- dependencyA dependency is an external software component required by an application or another software component to build or operate.
- CORSCross-origin resource sharing is a web mechanism through which servers use HTTP headers to specify which other origins may access their resources.
- history.replaceState()A History API method that replaces the current session-history entry and can change the displayed URL without loading a new document.
- web app manifestA Web App Manifest is a JSON document that supplies metadata describing a web application, such as its name, icons, colors, and launch URL.
- navigationMovement among locations or views in a web application.
- custom element lifecycleA method invoked by the browser when a custom element is connected, disconnected, adopted, or has an observed attribute changed.
- HTTPThe application-layer protocol used to transfer resources and messages between web clients and servers.
- @containerA container query is a CSS conditional rule that applies styles based on the size of an element's containing ancestor rather than the viewport.
- AbortSignalA web-platform interface that communicates cancellation of an asynchronous operation.
- frameworkA reusable software structure that imposes conventions and supplies components for organizing application architecture and development.
- storage bucketAn experimental browser API proposal for grouping an origin's data under separate lifetime and eviction policies.
- CustomElementRegistryThe browser registry interface for defining and retrieving custom element constructors.
- storage apiThe Storage API is a browser API for inspecting web-storage usage, estimating quotas, and requesting persistence.
- attachShadowAn Element method that creates and attaches a shadow root with the requested mode.
- declarative shadow rootAn HTML feature for declaring a shadow root and its contents in markup rather than creating them with JavaScript.
- interoperabilityInteroperability is the ability of software systems or components to exchange and use information correctly across their boundaries.
- popstate eventA browser event dispatched when the active session-history entry changes through history traversal.
- HTMLThe standard markup language for structuring content in web documents.
- signalA reactive value container that notifies dependent computations and effects when its value changes.
- light DOMThe DOM content supplied by a web component's host document rather than contained in the component's shadow tree.
- form-associated custom elementA form-associated custom element is a custom HTML element that participates in a form's association, disabled-state, reset, and state-restoration behavior.
- constructor methodA JavaScript function intended to create and initialize object instances when invoked as a constructor.
- responsive designResponsive web design is an approach to creating websites that adapt their layout and presentation to different screen sizes, devices, and contexts.
- cascadeThe CSS cascade is the rule system that resolves competing style declarations according to origin, importance, specificity, and source order.
- performancePerformance is the speed, responsiveness, and resource efficiency of a software system during operation.
- CSS GridCSS Grid is a layout model for arranging elements in two-dimensional rows and columns.
- subgridSubgrid is a CSS Grid feature that lets a nested grid participate in the track sizing and alignment of its parent grid.
- data bindingDynamic data binding synchronizes changing application data with user-interface elements, potentially in both directions.
- textContenttextContent is a DOM node property that gets or sets the plain text content of a node and its descendants without parsing markup.
- promiseA JavaScript promise is an object representing the eventual completion or failure of an asynchronous operation and its resulting value.
- history entry stateHistory entry state is serializable transient data associated with an individual browser session-history entry.
- service workerA service worker is a browser-managed background script that can intercept network requests and support offline behavior, caching, and other progressive web application features.
- reactive programmingReactivity is a programming model in which changes to data automatically propagate to dependent computations or interface output.
- named slotA named slot is a slot with a name attribute that receives only child nodes whose slot attribute has the matching value.
- browser developer toolsBrowser developer tools are utilities for inspecting, debugging, testing, and profiling web pages and applications.
- event.intercept()event.intercept() is a navigation-event method that prevents a supported navigation from proceeding natively and assigns application handling to it.
- web storage apiWeb Storage is a browser storage facility for small amounts of string key/value data associated with a web origin.
- dispatchEventdispatchEvent is a DOM API method that synchronously dispatches an event to an object and its event listeners.
- AbortControllerAbortController is a browser interface for signaling cancellation of asynchronous operations such as fetch requests and event listeners.
- performance APIThe Performance API is a browser API for collecting high-resolution timing and performance information.
- API stabilityA stable API is a web API whose behavior and availability are sufficiently established for dependable use across supported browsers.
- canonical URLA canonical URL is the preferred URL designated as the authoritative address for a page or resource among equivalent URL variants.
- container-relative unitA container unit is a CSS length unit whose value is calculated from the size of a query container.
- lazy initializationA technique that defers loading or initialization until content or functionality is needed.
- HTMLElement APIHTMLElement is the base browser interface implemented by most concrete HTML element objects and their shared properties and methods.
- constructable stylesheetA constructible stylesheet is a programmatically created CSSStyleSheet that can be adopted and shared by document or shadow roots.
- IndexedDBIndexedDB is a browser database API for storing and querying structured data, including data larger than typical web-storage values.
- ECMAScript language specificationECMAScript is the standardized language specification from which JavaScript implementations derive their core syntax and semantics.
- shadow hostThe element to which a shadow root is attached and which represents the component externally.
- query stringA query string is the URL component containing name-value parameters that modify a resource request or represent view state.
- developer experienceThe overall quality and effectiveness of a software developer's interaction with development tools, systems, and workflows.
- serverA networked system that responds to client requests by returning resources or providing services.
- canvas elementCanvas is an HTML element and browser graphics interface that provides a drawable surface for script-generated visual content.
- metadataMetadata is information that defines settings and descriptive properties for a website or web application without changing the document contents displayed in the viewport.
- customElementsThe browser global property that provides access to a CustomElementRegistry instance.
- moduleA module is a self-contained unit of code that encapsulates declarations and can expose selected bindings to other code.
- contractA specification of an API's operations, inputs, outputs, and behavioral requirements.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
