Index
A
- advantages, multiple instances of sandbox module
- about / Advantages of multiple instances of the sandbox
- isolation / Isolating the sandbox instances from each other
- code execution context, creating / Creating a code execution context
- performance improvements / Performance improvements
- Agile development environment
- about / Designing in a modular way
- AJAX / Acting as the controller
- alert box
- almond.js
- reference link / Introducing RequireJS
- AMD
- about / Introducing Asynchronous Module Definition
- used, for defining modules / Defining modules using AMD format
- AMD format
- using, by re-factoring Images Inc. application / Refactoring Images Inc. application to use AMD format
- AMD modules
- importing / Importing AMD modules
- loading, with test project / A test project for creating and loading AMD modules
- simple person AMD module, creating / Creating a simple AMD module
- AMD person module, consuming / Consuming our person AMD module
- dependencies of dependencies, loading / Loading dependencies of dependencies
- paths, setting in config object / Setting paths in the config object
- core submodules, modifying into / Modifying Core submodules into AMD modules
- AngularJS / Application architecture overview
- application
- designing, in modular way / Designing in a modular way
- defining / The big picture
- requirements / Our application requirements
- user's view / The user's view of our application
- functionality / Application functionality
- implementation / Application implementation
- components / Application components
- application architecture
- overview / Application architecture overview
- base module / Base module
- sandbox module / Sandbox module
- core module / Core module
- components / Components
- considerations / Application architectural considerations
- application components
- about / Application components
- registering, with MainCore module / Registering components with MainCore module
- header component / Header component
- footer component / Footer component
- content component / Content component
- notificationWidget component / NotificationWidget component
- notificationWidget, rendering / Rendering notificationWidget
- application content area
- generating / Generating our application's content area
- application controller
- about / Application controller
- modules / Application controller modules
- application functionality
- about / Application functionality
- index page / Index page
- image page / Image page
- favorites page / Favorites page
- support widget / Support widget
- application implementation
- about / Application implementation
- module files, loading in module files / Loading our module files in index.html
- base module implementation / Base module implementation
- core module implementation / Core module implementation
- SandBox module implementation / SandBox module implementation
- application model
- about / Application model
- module, creating as / Creating a module for our application's model
- application modules
- auto initialization / Auto-initialization of application modules
- application non-core modules
- about / Application non-core modules
- testModule1 implementation / testModule1 implementation
- testModule2 implementation / testModule2 implementation
- application view
- about / Application view
- index.html page skeleton, creating / Creating the index.html page skeleton
- object definition, creating for header / Creating an object definition for the header
- Header fragment, generating / Generating the Header fragment dynamically
- generating dynamically / Generating client application's view dynamically
- Asynchronous Module Definition (AMD) / Loading our module files in index.html
- asynchronous script loading
- simulating / Tight augmentation of ImagesInc_GlobalData
- automated tests
- writing, advantages / Advantages of writing automated tests
- types / Different types of automated tests
- automated tests, types
- unit testing / Unit testing
- integration testing / Integration testing
- End to end (E2E) testing / End to end testing
B
- base module
- about / Base module
- general purpose libraries, adding / Adding general-purpose libraries to the base module
- Behavioral Driven Development (BDD) unit tests
- about / BDD unit tests
C
- Chai
- about / Introduction to Mocha, Chai
- reference link / Chai
- Client-side Modular Design (CMD) / Application architecture overview
- Closure
- defining / Closures
- CommonJS(CJS) module
- about / CommonJS
- curl.js / CommonJS
- SproutCore / CommonJS
- implementing / Implementing a CommonJS module
- reference link / Implementing a CommonJS module
- CommonJS(CJS) modules
- reference link / ECMAScript 6 modules
- components
- about / Application view, Application architecture overview, Components
- required methods / Components required methods
- events, binding to elements / Binding events to the components elements
- design considerations / Component design considerations
- considerations, application architecture / Application architectural considerations
- constructor property
- about / Constructor property
- constructor stealing
- content area click events
- handling / Handling content area click events
- Add To Favorite link click event, handling / Handling the Add To Favorite link click event
- image click event, handling / Handling an image click event
- content area generator methods
- buildFavouritesPage / Content area generator methods
- buildIndexContentHTML / Content area generator methods
- buildImagePageHTML / Content area generator methods
- getAnchorHTMLStr / Content area generator methods
- content component
- about / Content component
- content area click events, handling / Handling content area click events
- area generator methods / Content area generator methods
- content delivery network (CDN) / Setting up Mocha
- cookie / Acting as the controller
- core module
- about / Application controller modules, Core module
- tasks, performing / Core module
- core construction approach / Core module construction approach
- communication bridges, providing / Providing communication bridges
- components, initializing / Initializing and destroying components
- components, destroying / Initializing and destroying components
- plug-and-play capability, providing / Providing plug-and-play capability
- centralized approach, providing for error handling / Providing a centralized approach to handling errors
- application level extensibility, providing / Providing application-level extensibility
- third party libraries, leveraging / Leveraging third party libraries
- core module implementation
- about / Core module implementation
- MainCore module implementation / MainCore module implementation
- component registration, with MainCore / Component registration with MainCore
- components, dynamic loading by MainCore / Dynamic loading of components by MainCore
- functionality, routing in MainCore module / Routing functionality in MainCore module
- publish-subscribe implementation, in MainCore module / Publish-subscribe implementation in MainCore
- curl.js
- reference link / CommonJS
D
- deep cloning / Shallow cloning and deep cloning
- Dot Matrix / Introduction to Mocha
- Dynamic Page Generation (DPG)
- dynamic views
- defining / Dynamic views
E
- ECMAScript 6
- about / JavaScript objects
- ECMAScript 6 (ES 6) modules
- about / ECMAScript 6 modules
- considerations / ECMAScript 6 modules
- defining / Defining an ES6 module
- consuming / Consuming an ES6 module
- loading sequence, in browsers / Module loading sequence in the browsers for ES6 modules
- reference links / Module loading sequence in the browsers for ES6 modules
- encapsulation
- defining / Encapsulation and scoping
- End to end (E2E) testing / End to end testing
- Expect / Chai
- extensible
- about / The big picture
F
- first module
- defining / Structure of our first module
- functionality, using / Using our first module's functionality
- interface, defining / Mapping our module's methods to its interface
- framework / Application architecture overview
- functionality, routing in MainCore module
- URL, adding to history object of browser / Adding a URL to the history object of the browser
- URL, obtaining from history object of browser / Getting a URL from the history object of the browser
- function object
- about / Function objects
- versus object literal notation / Object literal notation versus function objects
- functions
- as object constructors (classes) / Functions as object constructors (classes)
- as static objects / Functions as static objects
G
- GitHub / Exploring Mocha further
- GlobalData module
- about / GlobalData module
- graceful degradation / Base module
- Grunt
- reference link / Running CookieHandler unit tests
- Gulp
- reference link / Running CookieHandler unit tests
H
- history API
- reference link / Adding a URL to the history object of the browser
I
- IIFE
- about / Encapsulation and scoping
- Images Inc. application
- core submodules, modifying into AMD modules / Modifying Core submodules into AMD modules
- non-AMD modules, loading with RequireJS / Loading our non-AMD modules using RequireJS
- config.js file, setting up / Setting up our application's config.js file
- booting up, with RequireJS / Booting up our application using RequireJS
- about / Module loading sequence in the browsers for ES6 modules
- ImagesInc_GlobalData module
- augmentation / Simple augmentation of ImagesInc_GlobalData
- loose augmentation, performing / Loose augmentation of ImagesInc_GlobalData
- data encapsulation, testing / Testing ImagesInc_GlobalData data encapsulation
- tight augmentation, performing / Tight augmentation of ImagesInc_GlobalData
- augmenting code, loading / Loading ImagesInc_GlobalData augmenting code
- ImagesInc_Utilites module
- about / Creating ImagesInc_Utilites module
- creating / Creating ImagesInc_Utilites module
- custom cloning method, testing / Testing our custom cloning method in ImagesInc_Utilites module
- features / An important aspect of our cloning method
- Immediately Invoked Function Expression (IIFE)
- about / Module pattern
- implementation inheritance
- about / Inheritance
- index.html
- used, for loading modules / Revisiting index.html file
- about / Revisiting index.html file
- inheritance
- defining / Inheritance
- prototype chaining / Prototype chaining
- constructor stealing / Constructor stealing
- parasitic combination inheritance / Parasitic combination inheritance
- integration testing / Integration testing
- interface inheritance
- about / Inheritance
J
- Jasmine
- about / Introduction to Jasmine
- reference link / Introduction to Jasmine, Setting up Jasmine, Exploring Jasmine further
- Spec file, creating / Creating our Jasmine spec file
- unit tests, running / Running our Jasmine unit tests
- exploring / Exploring Jasmine further
- Jasmine 2.4
- setting up / Setting up Jasmine
- JavaScript (ES 6)
- URL / JavaScript objects
- JavaScript modules
- reference link / Importing AMD modules
- JavaScript objects
- defining / JavaScript objects
- object type constructor / Object type constructors
- object literal notation / Object literal notation
- function object / Function objects
- object literal notation, versus function object / Object literal notation versus function objects
- this keyword / The "this" keyword
- Closure / Closures
- encapsulation / Encapsulation and scoping
- scoping / Encapsulation and scoping
- inheritance / Inheritance
- constructor property / Constructor property
- native support, for inheritance / Native support for inheritance
- jQuery
- about / Using external libraries for cloning
- reference link / Using external libraries for cloning
- and AMD format / Creating a simple AMD module
- JSON exploit
- reference link / Using JSON exploit for cloning
L
- List / Introduction to Mocha
- local storage / Acting as the controller
- lodash
- about / Using external libraries for cloning
- documentation link / Using external libraries for cloning
- loose augmentation
- about / The order of things in module augmentation
- of modules / Loose augmentation of modules
- of ImagesInc_GlobalData module / Loose augmentation of ImagesInc_GlobalData
- loose coupling
- creating, among modules / Creating loose coupling among modules
M
- MainCore
- dynamic loading of components / Dynamic loading of components by MainCore
- object definitions, storing in local storage / Storing object definitions in local storage
- component's object definitions, obtaining from local storage / Getting a component's object definition from local storage
- component's component resources, dynamically loading from server / Dynamically loading component's resources from the server
- MainCore.js
- about / Setting up Jasmine
- MainCore module
- implementation / MainCore module implementation
- augmenting / Augmenting MainCore module
- augmenting, with tight augmentation / Augmenting MainCore using tight augmentation
- augmenting, with sub-modules / Augmenting MainCore using sub-modules
- functionality, routing / Routing functionality in MainCore module
- Minimum Viable Product (MVP)
- Mocha
- about / Introduction to Mocha
- setting up / Setting up Mocha
- reference link / Setting up Mocha, Exploring Mocha further
- Chai / Chai
- spec file, creating / Creating our Mocha spec file
- -Chai unit tests, running / Running our Mocha-Chai unit tests
- exploring / Exploring Mocha further
- mocks / Creating our Jasmine spec file, Exploring Jasmine further
- Model-View-Controller (MVC)
- about / Designing our SPA main pieces
- Model-View-Wildcard (MV*)
- about / Designing our SPA main pieces
- modular design, advantages
- plug-and-play / Augmenting MainCore using sub-modules
- progressive enhancement / Augmenting MainCore using sub-modules
- graceful degradation / Augmenting MainCore using sub-modules
- modular programming
- about / Prelude to modular programming
- Module-View-Controller (MVC) / Core module
- module augmentation
- about / Principles of module augmentation, The order of things in module augmentation
- implementing / Implementing module augmentation
- of ImagesInc_GlobalData module / Simple augmentation of ImagesInc_GlobalData
- Module Design Pattern
- module inheritance
- about / Inheritance in modules
- __proto__ object inheritance, using / Module inheritance using __proto__ object
- parasitic combination inheritance, using / Module inheritance using parasitic combination
- selecting / Deciding on the module inheritance approach
- module pattern
- defining / Module pattern
- internal private scope / Internal private scope in module pattern
- properties adding, to interface / Adding properties to an interface in module pattern
- object factory module / Object factory module
- problems / Structure of our first module
- modules
- creating / The simple rule for creating modules
- example / A real-life example of modules
- non-modular example / A look at a non-modular example
- re-factoring / Re-factoring to a more modularized approach
- application core module / Application core module
- application Mediator module / Application Mediator module
- application non-core modules / Application non-core modules
- module initialization / Module initialization and design considerations
- design considerations / Module initialization and design considerations
- naming conventions / Implementing module augmentation
- loose augmentation / Loose augmentation of modules
- tight augmentation / Tight augmentation of modules
- cloning / Cloning modules
- inheritance / Inheritance in modules
- loading, with index.html / Revisiting index.html file
- defining, with AMD format / Defining modules using AMD format
- modules, application controller
- page updater module / Page updater module
- storage handler module / Storage handler module
- communication handler module / Communication handler module
- utilities module / Utilities module
- message handler module / Message handler module
- logging handler module / Logging handler module
- modules, cloning
- constructor function instances, creating / Creating instances of a constructor function
- assignment operator, used for copying objects / Using the assignment operator for copying objects
- object clone, creating / Creating a clone of an object
- modules I / Application architecture overview
- multiple instances, sandbox module
- implementing / Implementing multiple instances of the sandbox module
- advantages / Advantages of multiple instances of the sandbox
N
- namespace
- Node.js / Exploring Mocha further
- non-AMD modules
- consuming / Loading and consuming non-AMD modules
- loading / Loading and consuming non-AMD modules
- shims, creating / Creating shims for non-AMD modules
- loading, with RequireJS / Loading our non-AMD modules using RequireJS
- notificationWidget component
- model / NotificationWidget's model
- required methods / Required methods of the notificationWidget component
O
- Object.create method
- object clone, creating
- about / Creating a clone of an object
- shallow cloning / Shallow cloning and deep cloning
- deep cloning / Shallow cloning and deep cloning
- cloning approaches / Shallow cloning and deep cloning
- external libraries, using / Using external libraries for cloning
- JSON exploit, using / Using JSON exploit for cloning
- custom clone method, creating / Creating a custom clone method
- Object Factory design pattern
- object factory module / Object factory module
- object literal notation
- about / Object literal notation
- versus function object / Object literal notation versus function objects
P
- package
- creating / A look at a non-modular example
- parasitic combination inheritance
- about / Parasitic combination inheritance
- used, for module inheritance / Module inheritance using parasitic combination
- selecting / Deciding on the module inheritance approach
- private variable
- about / Encapsulation and scoping
- privileged method
- about / Encapsulation and scoping
- privileged methods
- about / Structure of our first module
- progressive enhancement / Base module
- project code
- proof of concept type application / Application components
- prototypal inheritance
- about / Native support for inheritance
- prototype chaining
- about / Prototype chaining, Parasitic combination inheritance
- property look up, in prototype chaining / Property look up in prototype chaining
- constructor property, resetting / Resetting the constructor property
- publish-subscribe implementation
- in MainCore / Publish-subscribe implementation in MainCore
- components, registering for custom events / Registering components for custom events
- custom events, broadcasting by components / Broadcasting custom events by components
R
- React / Application architecture overview
- RequireJS
- about / Introducing RequireJS
- downloading / Downloading RequireJS
- download link / Downloading RequireJS
- reference link / Creating shims for non-AMD modules
- used, for loading non-AMD modules / Loading our non-AMD modules using RequireJS
- used, for booting up Images Inc. application / Booting up our application using RequireJS
- revealing module pattern
- about / testModule2 implementation
S
- sandbox functionality
- about / Sandbox module functionality
- as consistent interface / Sandbox as a consistent interface
- as security layer / Sandbox as a security layer
- as communication layer / Sandbox as a communication layer
- as filter / Sandbox as a filter
- sandbox module
- about / Sandbox module
- functionality / Sandbox module functionality
- components / Sandbox module functionality
- multiple instances, implementing / Implementing multiple instances of the sandbox module
- SandBox module implementation
- about / SandBox module implementation
- constructor / SandBox module's constructor
- component's container context, setting in SandBox instance / Setting a component's container context in the SandBox instance
- instance, identifying / Identifying the SandBox module's instance
- considerations / SandBox module considerations
- scope chain
- about / Object type constructors
- URL / Object type constructors
- scoping
- defining / Encapsulation and scoping
- shadowing
- shallow cloning / Shallow cloning and deep cloning
- Single Page Application (SPA)
- about / Dynamic views
- singleton objects
- about / Module pattern
- Sinon
- about / Creating our Mocha spec file
- reference link / Creating our Mocha spec file
- SPA application
- references / Designing our SPA main pieces
- application controller / Application controller
- first core module / Creating our first core module
- application view / Application view
- application model / Application model
- logging module, creating / Creating a logging module
- specialized modular approach
- about / A look at a non-modular example
- spies / Creating our Jasmine spec file
- SproutCore
- reference link / CommonJS
- stubs / Creating our Jasmine spec file, Exploring Jasmine further
- sub-modules
- AjaxEngine / Augmenting MainCore using sub-modules
- CookieHandler / Augmenting MainCore using sub-modules
- NotificationHandle / Augmenting MainCore using sub-modules
- StorageHanlder / Augmenting MainCore using sub-modules
- utilities / Augmenting MainCore using sub-modules
- submodules
- about / Submodules
- adding, dynamic properties used / Adding submodules using dynamic properties
- adding, asynchronous properties used / Adding submodules using asynchronous properties
T
- Test-Driven Development (TDD)
- Test Driven Development (TDD) unit tests
- about / TDD unit tests
- versus Behavioral Driven Development (BDD) unit tests / TDD versus BDD
- this keyword
- defining / The "this" keyword
- tight augmentation
- about / Tight augmentation of modules
- of ImagesInc_GlobalData module / Tight augmentation of ImagesInc_GlobalData
- considerations / Considerations in tight augmentation
U
- unit testing
- about / Unit testing
- Test Driven Development (TDD) / TDD unit tests
- Behavioral Driven Development (BDD) / BDD unit tests
- TDD, versus BDD / TDD versus BDD
- test coverage / Test coverage
- unit tests
- writing / A simple start to writing our unit tests
- writing, without unit testing frameworks / Writing unit tests without any unit testing frameworks
- writing, third party frameworks used / Writing unit tests using third party frameworks
- unit tests, writing without unit testing frameworks
- about / Writing unit tests without any unit testing frameworks
- AppTester module, adding to application / Adding an AppTester module to our application
- unit test suites, adding to test-runner / Adding unit test suites to our test-runner
- CookieHandler module unit tests / CookieHandler module unit tests
- CookieHandler module unit tests, running / Running CookieHandler unit tests
- cleaning up, after running tests / Cleaning up after running our unit tests
- unit tests, writing with third party frameworks
- about / Writing unit tests using third party frameworks
- Jasmine / Introduction to Jasmine
- Mocha / Introduction to Mocha