From d6f5f613fbaf5aa0afdab6acc00056451310f9d7 Mon Sep 17 00:00:00 2001 From: serkanozer Date: Fri, 7 Jul 2017 02:03:00 +0300 Subject: [PATCH 1/2] Trim search text from beginning and the end. (fixes #1861) --- examples/dist/app.js | 13537 +++++++------- examples/dist/bundle.js | 3618 ++-- examples/dist/common.js | 27246 ++++++++++++++-------------- examples/dist/standalone.js | 3253 ++-- src/Select.js | 3 + src/utils/defaultFilterOptions.js | 7 + src/utils/trim.js | 10 + test/Select-test.js | 36 + 8 files changed, 24238 insertions(+), 23472 deletions(-) create mode 100644 src/utils/trim.js diff --git a/examples/dist/app.js b/examples/dist/app.js index 276ddb6683..673e9674e9 100644 --- a/examples/dist/app.js +++ b/examples/dist/app.js @@ -522,7 +522,7 @@ function arrowRenderer() { module.exports = UsersField; -},{"../data/users":15,"create-react-class":undefined,"prop-types":undefined,"react":undefined,"react-gravatar":31,"react-select":undefined}],6:[function(require,module,exports){ +},{"../data/users":15,"create-react-class":undefined,"prop-types":undefined,"react":undefined,"react-gravatar":21,"react-select":undefined}],6:[function(require,module,exports){ 'use strict'; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } @@ -613,7 +613,7 @@ var DisabledUpsellOptions = (0, _createReactClass2['default'])({ }); module.exports = DisabledUpsellOptions; -},{"create-react-class":undefined,"prop-types":undefined,"react":undefined,"react-highlight-words":32,"react-select":undefined}],7:[function(require,module,exports){ +},{"create-react-class":undefined,"prop-types":undefined,"react":undefined,"react-highlight-words":30,"react-select":undefined}],7:[function(require,module,exports){ 'use strict'; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } @@ -761,7 +761,7 @@ var GithubUsers = (0, _createReactClass2['default'])({ module.exports = GithubUsers; -},{"create-react-class":undefined,"isomorphic-fetch":23,"prop-types":undefined,"react":undefined,"react-select":undefined}],8:[function(require,module,exports){ +},{"create-react-class":undefined,"isomorphic-fetch":16,"prop-types":undefined,"react":undefined,"react-select":undefined}],8:[function(require,module,exports){ 'use strict'; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } @@ -1212,7 +1212,7 @@ var CitiesField = (0, _createReactClass2['default'])({ module.exports = CitiesField; -},{"../data/cities":12,"create-react-class":undefined,"react":undefined,"react-virtualized-select":35}],12:[function(require,module,exports){ +},{"../data/cities":12,"create-react-class":undefined,"react":undefined,"react-virtualized-select":33}],12:[function(require,module,exports){ 'use strict'; exports.CITIES = [{ name: 'Abilene' }, { name: 'Addison' }, { name: 'Akron' }, { name: 'Alameda' }, { name: 'Albany' }, { name: 'Albany' }, { name: 'Albany' }, { name: 'Albuquerque' }, { name: 'Alexandria' }, { name: 'Alexandria' }, { name: 'Alhambra' }, { name: 'Aliso Viejo' }, { name: 'Allen' }, { name: 'Allentown' }, { name: 'Alpharetta' }, { name: 'Altamonte Springs' }, { name: 'Altoona' }, { name: 'Amarillo' }, { name: 'Ames' }, { name: 'Anaheim' }, { name: 'Anchorage' }, { name: 'Anderson' }, { name: 'Ankeny' }, { name: 'Ann Arbor' }, { name: 'Annapolis' }, { name: 'Antioch' }, { name: 'Apache Junction' }, { name: 'Apex' }, { name: 'Apopka' }, { name: 'Apple Valley' }, { name: 'Apple Valley' }, { name: 'Appleton' }, { name: 'Arcadia' }, { name: 'Arlington' }, { name: 'Arlington Heights' }, { name: 'Arvada' }, { name: 'Asheville' }, { name: 'Athens-Clarke County' }, { name: 'Atlanta' }, { name: 'Atlantic City' }, { name: 'Attleboro' }, { name: 'Auburn' }, { name: 'Auburn' }, { name: 'Augusta-Richmond County' }, { name: 'Aurora' }, { name: 'Aurora' }, { name: 'Austin' }, { name: 'Aventura' }, { name: 'Avondale' }, { name: 'Azusa' }, { name: 'Bakersfield' }, { name: 'Baldwin Park' }, { name: 'Baltimore' }, { name: 'Barnstable Town' }, { name: 'Bartlett' }, { name: 'Bartlett' }, { name: 'Baton Rouge' }, { name: 'Battle Creek' }, { name: 'Bayonne' }, { name: 'Baytown' }, { name: 'Beaumont' }, { name: 'Beaumont' }, { name: 'Beavercreek' }, { name: 'Beaverton' }, { name: 'Bedford' }, { name: 'Bell Gardens' }, { name: 'Belleville' }, { name: 'Bellevue' }, { name: 'Bellevue' }, { name: 'Bellflower' }, { name: 'Bellingham' }, { name: 'Beloit' }, { name: 'Bend' }, { name: 'Bentonville' }, { name: 'Berkeley' }, { name: 'Berwyn' }, { name: 'Bethlehem' }, { name: 'Beverly' }, { name: 'Billings' }, { name: 'Biloxi' }, { name: 'Binghamton' }, { name: 'Birmingham' }, { name: 'Bismarck' }, { name: 'Blacksburg' }, { name: 'Blaine' }, { name: 'Bloomington' }, { name: 'Bloomington' }, { name: 'Bloomington' }, { name: 'Blue Springs' }, { name: 'Boca Raton' }, { name: 'Boise City' }, { name: 'Bolingbrook' }, { name: 'Bonita Springs' }, { name: 'Bossier City' }, { name: 'Boston' }, { name: 'Boulder' }, { name: 'Bountiful' }, { name: 'Bowie' }, { name: 'Bowling Green' }, { name: 'Boynton Beach' }, { name: 'Bozeman' }, { name: 'Bradenton' }, { name: 'Brea' }, { name: 'Bremerton' }, { name: 'Brentwood' }, { name: 'Brentwood' }, { name: 'Bridgeport' }, { name: 'Bristol' }, { name: 'Brockton' }, { name: 'Broken Arrow' }, { name: 'Brookfield' }, { name: 'Brookhaven' }, { name: 'Brooklyn Park' }, { name: 'Broomfield' }, { name: 'Brownsville' }, { name: 'Bryan' }, { name: 'Buckeye' }, { name: 'Buena Park' }, { name: 'Buffalo' }, { name: 'Buffalo Grove' }, { name: 'Bullhead City' }, { name: 'Burbank' }, { name: 'Burien' }, { name: 'Burleson' }, { name: 'Burlington' }, { name: 'Burlington' }, { name: 'Burnsville' }, { name: 'Caldwell' }, { name: 'Calexico' }, { name: 'Calumet City' }, { name: 'Camarillo' }, { name: 'Cambridge' }, { name: 'Camden' }, { name: 'Campbell' }, { name: 'Canton' }, { name: 'Cape Coral' }, { name: 'Cape Girardeau' }, { name: 'Carlsbad' }, { name: 'Carmel' }, { name: 'Carol Stream' }, { name: 'Carpentersville' }, { name: 'Carrollton' }, { name: 'Carson' }, { name: 'Carson City' }, { name: 'Cary' }, { name: 'Casa Grande' }, { name: 'Casper' }, { name: 'Castle Rock' }, { name: 'Cathedral City' }, { name: 'Cedar Falls' }, { name: 'Cedar Hill' }, { name: 'Cedar Park' }, { name: 'Cedar Rapids' }, { name: 'Centennial' }, { name: 'Ceres' }, { name: 'Cerritos' }, { name: 'Champaign' }, { name: 'Chandler' }, { name: 'Chapel Hill' }, { name: 'Charleston' }, { name: 'Charleston' }, { name: 'Charlotte' }, { name: 'Charlottesville' }, { name: 'Chattanooga' }, { name: 'Chelsea' }, { name: 'Chesapeake' }, { name: 'Chesterfield' }, { name: 'Cheyenne' }, { name: 'Chicago' }, { name: 'Chico' }, { name: 'Chicopee' }, { name: 'Chino' }, { name: 'Chino Hills' }, { name: 'Chula Vista' }, { name: 'Cicero' }, { name: 'Cincinnati' }, { name: 'Citrus Heights' }, { name: 'Clarksville' }, { name: 'Clearwater' }, { name: 'Cleveland' }, { name: 'Cleveland' }, { name: 'Cleveland Heights' }, { name: 'Clifton' }, { name: 'Clovis' }, { name: 'Clovis' }, { name: 'Coachella' }, { name: 'Coconut Creek' }, { name: 'Coeur d\'Alene' }, { name: 'College Station' }, { name: 'Collierville' }, { name: 'Colorado Springs' }, { name: 'Colton' }, { name: 'Columbia' }, { name: 'Columbia' }, { name: 'Columbus' }, { name: 'Columbus' }, { name: 'Columbus' }, { name: 'Commerce City' }, { name: 'Compton' }, { name: 'Concord' }, { name: 'Concord' }, { name: 'Concord' }, { name: 'Conroe' }, { name: 'Conway' }, { name: 'Coon Rapids' }, { name: 'Coppell' }, { name: 'Coral Gables' }, { name: 'Coral Springs' }, { name: 'Corona' }, { name: 'Corpus Christi' }, { name: 'Corvallis' }, { name: 'Costa Mesa' }, { name: 'Council Bluffs' }, { name: 'Covina' }, { name: 'Covington' }, { name: 'Cranston' }, { name: 'Crystal Lake' }, { name: 'Culver City' }, { name: 'Cupertino' }, { name: 'Cutler Bay' }, { name: 'Cuyahoga Falls' }, { name: 'Cypress' }, { name: 'Dallas' }, { name: 'Daly City' }, { name: 'Danbury' }, { name: 'Danville' }, { name: 'Danville' }, { name: 'Davenport' }, { name: 'Davie' }, { name: 'Davis' }, { name: 'Dayton' }, { name: 'Daytona Beach' }, { name: 'DeKalb' }, { name: 'DeSoto' }, { name: 'Dearborn' }, { name: 'Dearborn Heights' }, { name: 'Decatur' }, { name: 'Decatur' }, { name: 'Deerfield Beach' }, { name: 'Delano' }, { name: 'Delray Beach' }, { name: 'Deltona' }, { name: 'Denton' }, { name: 'Denver' }, { name: 'Des Moines' }, { name: 'Des Plaines' }, { name: 'Detroit' }, { name: 'Diamond Bar' }, { name: 'Doral' }, { name: 'Dothan' }, { name: 'Dover' }, { name: 'Downers Grove' }, { name: 'Downey' }, { name: 'Draper' }, { name: 'Dublin' }, { name: 'Dublin' }, { name: 'Dubuque' }, { name: 'Duluth' }, { name: 'Duncanville' }, { name: 'Dunwoody' }, { name: 'Durham' }, { name: 'Eagan' }, { name: 'East Lansing' }, { name: 'East Orange' }, { name: 'East Providence' }, { name: 'Eastvale' }, { name: 'Eau Claire' }, { name: 'Eden Prairie' }, { name: 'Edina' }, { name: 'Edinburg' }, { name: 'Edmond' }, { name: 'Edmonds' }, { name: 'El Cajon' }, { name: 'El Centro' }, { name: 'El Monte' }, { name: 'El Paso' }, { name: 'Elgin' }, { name: 'Elizabeth' }, { name: 'Elk Grove' }, { name: 'Elkhart' }, { name: 'Elmhurst' }, { name: 'Elyria' }, { name: 'Encinitas' }, { name: 'Enid' }, { name: 'Erie' }, { name: 'Escondido' }, { name: 'Euclid' }, { name: 'Eugene' }, { name: 'Euless' }, { name: 'Evanston' }, { name: 'Evansville' }, { name: 'Everett' }, { name: 'Everett' }, { name: 'Fairfield' }, { name: 'Fairfield' }, { name: 'Fall River' }, { name: 'Fargo' }, { name: 'Farmington' }, { name: 'Farmington Hills' }, { name: 'Fayetteville' }, { name: 'Fayetteville' }, { name: 'Federal Way' }, { name: 'Findlay' }, { name: 'Fishers' }, { name: 'Fitchburg' }, { name: 'Flagstaff' }, { name: 'Flint' }, { name: 'Florence' }, { name: 'Florence' }, { name: 'Florissant' }, { name: 'Flower Mound' }, { name: 'Folsom' }, { name: 'Fond du Lac' }, { name: 'Fontana' }, { name: 'Fort Collins' }, { name: 'Fort Lauderdale' }, { name: 'Fort Myers' }, { name: 'Fort Pierce' }, { name: 'Fort Smith' }, { name: 'Fort Wayne' }, { name: 'Fort Worth' }, { name: 'Fountain Valley' }, { name: 'Franklin' }, { name: 'Frederick' }, { name: 'Freeport' }, { name: 'Fremont' }, { name: 'Fresno' }, { name: 'Friendswood' }, { name: 'Frisco' }, { name: 'Fullerton' }, { name: 'Gainesville' }, { name: 'Gaithersburg' }, { name: 'Galveston' }, { name: 'Garden Grove' }, { name: 'Gardena' }, { name: 'Garland' }, { name: 'Gary' }, { name: 'Gastonia' }, { name: 'Georgetown' }, { name: 'Germantown' }, { name: 'Gilbert' }, { name: 'Gilroy' }, { name: 'Glendale' }, { name: 'Glendale' }, { name: 'Glendora' }, { name: 'Glenview' }, { name: 'Goodyear' }, { name: 'Goose Creek' }, { name: 'Grand Forks' }, { name: 'Grand Island' }, { name: 'Grand Junction' }, { name: 'Grand Prairie' }, { name: 'Grand Rapids' }, { name: 'Grapevine' }, { name: 'Great Falls' }, { name: 'Greeley' }, { name: 'Green Bay' }, { name: 'Greenacres' }, { name: 'Greenfield' }, { name: 'Greensboro' }, { name: 'Greenville' }, { name: 'Greenville' }, { name: 'Greenwood' }, { name: 'Gresham' }, { name: 'Grove City' }, { name: 'Gulfport' }, { name: 'Hackensack' }, { name: 'Hagerstown' }, { name: 'Hallandale Beach' }, { name: 'Haltom City' }, { name: 'Hamilton' }, { name: 'Hammond' }, { name: 'Hampton' }, { name: 'Hanford' }, { name: 'Hanover Park' }, { name: 'Harlingen' }, { name: 'Harrisburg' }, { name: 'Harrisonburg' }, { name: 'Hartford' }, { name: 'Hattiesburg' }, { name: 'Haverhill' }, { name: 'Hawthorne' }, { name: 'Hayward' }, { name: 'Hemet' }, { name: 'Hempstead' }, { name: 'Henderson' }, { name: 'Hendersonville' }, { name: 'Hesperia' }, { name: 'Hialeah' }, { name: 'Hickory' }, { name: 'High Point' }, { name: 'Highland' }, { name: 'Hillsboro' }, { name: 'Hilton Head Island' }, { name: 'Hoboken' }, { name: 'Hoffman Estates' }, { name: 'Hollywood' }, { name: 'Holyoke' }, { name: 'Homestead' }, { name: 'Honolulu' }, { name: 'Hoover' }, { name: 'Houston' }, { name: 'Huber Heights' }, { name: 'Huntersville' }, { name: 'Huntington' }, { name: 'Huntington Beach' }, { name: 'Huntington Park' }, { name: 'Huntsville' }, { name: 'Huntsville' }, { name: 'Hurst' }, { name: 'Hutchinson' }, { name: 'Idaho Falls' }, { name: 'Independence' }, { name: 'Indianapolis' }, { name: 'Indio' }, { name: 'Inglewood' }, { name: 'Iowa City' }, { name: 'Irvine' }, { name: 'Irving' }, { name: 'Jackson' }, { name: 'Jackson' }, { name: 'Jacksonville' }, { name: 'Jacksonville' }, { name: 'Janesville' }, { name: 'Jefferson City' }, { name: 'Jeffersonville' }, { name: 'Jersey City' }, { name: 'Johns Creek' }, { name: 'Johnson City' }, { name: 'Joliet' }, { name: 'Jonesboro' }, { name: 'Joplin' }, { name: 'Jupiter' }, { name: 'Jurupa Valley' }, { name: 'Kalamazoo' }, { name: 'Kannapolis' }, { name: 'Kansas City' }, { name: 'Kansas City' }, { name: 'Kearny' }, { name: 'Keizer' }, { name: 'Keller' }, { name: 'Kenner' }, { name: 'Kennewick' }, { name: 'Kenosha' }, { name: 'Kent' }, { name: 'Kentwood' }, { name: 'Kettering' }, { name: 'Killeen' }, { name: 'Kingsport' }, { name: 'Kirkland' }, { name: 'Kissimmee' }, { name: 'Knoxville' }, { name: 'Kokomo' }, { name: 'La Crosse' }, { name: 'La Habra' }, { name: 'La Mesa' }, { name: 'La Mirada' }, { name: 'La Puente' }, { name: 'La Quinta' }, { name: 'Lacey' }, { name: 'Lafayette' }, { name: 'Lafayette' }, { name: 'Laguna Niguel' }, { name: 'Lake Charles' }, { name: 'Lake Elsinore' }, { name: 'Lake Forest' }, { name: 'Lake Havasu City' }, { name: 'Lake Oswego' }, { name: 'Lakeland' }, { name: 'Lakeville' }, { name: 'Lakewood' }, { name: 'Lakewood' }, { name: 'Lakewood' }, { name: 'Lakewood' }, { name: 'Lancaster' }, { name: 'Lancaster' }, { name: 'Lancaster' }, { name: 'Lancaster' }, { name: 'Lansing' }, { name: 'Laredo' }, { name: 'Largo' }, { name: 'Las Cruces' }, { name: 'Las Vegas' }, { name: 'Lauderhill' }, { name: 'Lawrence' }, { name: 'Lawrence' }, { name: 'Lawrence' }, { name: 'Lawton' }, { name: 'Layton' }, { name: 'League City' }, { name: 'Lee\'s Summit' }, { name: 'Leesburg' }, { name: 'Lehi' }, { name: 'Lenexa' }, { name: 'Leominster' }, { name: 'Lewisville' }, { name: 'Lexington-Fayette' }, { name: 'Lima' }, { name: 'Lincoln' }, { name: 'Lincoln' }, { name: 'Lincoln Park' }, { name: 'Linden' }, { name: 'Little Rock' }, { name: 'Littleton' }, { name: 'Livermore' }, { name: 'Livonia' }, { name: 'Lodi' }, { name: 'Logan' }, { name: 'Lombard' }, { name: 'Lompoc' }, { name: 'Long Beach' }, { name: 'Longmont' }, { name: 'Longview' }, { name: 'Lorain' }, { name: 'Los Angeles' }, { name: 'Louisville/Jefferson County' }, { name: 'Loveland' }, { name: 'Lowell' }, { name: 'Lubbock' }, { name: 'Lynchburg' }, { name: 'Lynn' }, { name: 'Lynwood' }, { name: 'Macon' }, { name: 'Madera' }, { name: 'Madison' }, { name: 'Madison' }, { name: 'Malden' }, { name: 'Manassas' }, { name: 'Manchester' }, { name: 'Manhattan' }, { name: 'Mankato' }, { name: 'Mansfield' }, { name: 'Mansfield' }, { name: 'Manteca' }, { name: 'Maple Grove' }, { name: 'Maplewood' }, { name: 'Marana' }, { name: 'Margate' }, { name: 'Maricopa' }, { name: 'Marietta' }, { name: 'Marlborough' }, { name: 'Martinez' }, { name: 'Marysville' }, { name: 'McAllen' }, { name: 'McKinney' }, { name: 'Medford' }, { name: 'Medford' }, { name: 'Melbourne' }, { name: 'Memphis' }, { name: 'Menifee' }, { name: 'Mentor' }, { name: 'Merced' }, { name: 'Meriden' }, { name: 'Meridian' }, { name: 'Meridian' }, { name: 'Mesa' }, { name: 'Mesquite' }, { name: 'Methuen' }, { name: 'Miami' }, { name: 'Miami Beach' }, { name: 'Miami Gardens' }, { name: 'Middletown' }, { name: 'Middletown' }, { name: 'Midland' }, { name: 'Midland' }, { name: 'Midwest City' }, { name: 'Milford' }, { name: 'Milpitas' }, { name: 'Milwaukee' }, { name: 'Minneapolis' }, { name: 'Minnetonka' }, { name: 'Minot' }, { name: 'Miramar' }, { name: 'Mishawaka' }, { name: 'Mission' }, { name: 'Mission Viejo' }, { name: 'Missoula' }, { name: 'Missouri City' }, { name: 'Mobile' }, { name: 'Modesto' }, { name: 'Moline' }, { name: 'Monroe' }, { name: 'Monrovia' }, { name: 'Montclair' }, { name: 'Montebello' }, { name: 'Monterey Park' }, { name: 'Montgomery' }, { name: 'Moore' }, { name: 'Moorhead' }, { name: 'Moreno Valley' }, { name: 'Morgan Hill' }, { name: 'Mount Pleasant' }, { name: 'Mount Prospect' }, { name: 'Mount Vernon' }, { name: 'Mountain View' }, { name: 'Muncie' }, { name: 'Murfreesboro' }, { name: 'Murray' }, { name: 'Murrieta' }, { name: 'Muskegon' }, { name: 'Muskogee' }, { name: 'Nampa' }, { name: 'Napa' }, { name: 'Naperville' }, { name: 'Nashua' }, { name: 'Nashville-Davidson' }, { name: 'National City' }, { name: 'New Bedford' }, { name: 'New Berlin' }, { name: 'New Braunfels' }, { name: 'New Britain' }, { name: 'New Brunswick' }, { name: 'New Haven' }, { name: 'New Orleans' }, { name: 'New Rochelle' }, { name: 'New York' }, { name: 'Newark' }, { name: 'Newark' }, { name: 'Newark' }, { name: 'Newport Beach' }, { name: 'Newport News' }, { name: 'Newton' }, { name: 'Niagara Falls' }, { name: 'Noblesville' }, { name: 'Norfolk' }, { name: 'Normal' }, { name: 'Norman' }, { name: 'North Charleston' }, { name: 'North Las Vegas' }, { name: 'North Lauderdale' }, { name: 'North Little Rock' }, { name: 'North Miami' }, { name: 'North Miami Beach' }, { name: 'North Port' }, { name: 'North Richland Hills' }, { name: 'Northglenn' }, { name: 'Norwalk' }, { name: 'Norwalk' }, { name: 'Norwich' }, { name: 'Novato' }, { name: 'Novi' }, { name: 'O\'Fallon' }, { name: 'Oak Lawn' }, { name: 'Oak Park' }, { name: 'Oakland' }, { name: 'Oakland Park' }, { name: 'Oakley' }, { name: 'Ocala' }, { name: 'Oceanside' }, { name: 'Ocoee' }, { name: 'Odessa' }, { name: 'Ogden' }, { name: 'Oklahoma City' }, { name: 'Olathe' }, { name: 'Olympia' }, { name: 'Omaha' }, { name: 'Ontario' }, { name: 'Orange' }, { name: 'Orem' }, { name: 'Orland Park' }, { name: 'Orlando' }, { name: 'Ormond Beach' }, { name: 'Oro Valley' }, { name: 'Oshkosh' }, { name: 'Overland Park' }, { name: 'Owensboro' }, { name: 'Oxnard' }, { name: 'Pacifica' }, { name: 'Palatine' }, { name: 'Palm Bay' }, { name: 'Palm Beach Gardens' }, { name: 'Palm Coast' }, { name: 'Palm Desert' }, { name: 'Palm Springs' }, { name: 'Palmdale' }, { name: 'Palo Alto' }, { name: 'Panama City' }, { name: 'Paramount' }, { name: 'Park Ridge' }, { name: 'Parker' }, { name: 'Parma' }, { name: 'Pasadena' }, { name: 'Pasadena' }, { name: 'Pasco' }, { name: 'Passaic' }, { name: 'Paterson' }, { name: 'Pawtucket' }, { name: 'Peabody' }, { name: 'Peachtree Corners' }, { name: 'Pearland' }, { name: 'Pembroke Pines' }, { name: 'Pensacola' }, { name: 'Peoria' }, { name: 'Peoria' }, { name: 'Perris' }, { name: 'Perth Amboy' }, { name: 'Petaluma' }, { name: 'Pflugerville' }, { name: 'Pharr' }, { name: 'Phenix City' }, { name: 'Philadelphia' }, { name: 'Phoenix' }, { name: 'Pico Rivera' }, { name: 'Pine Bluff' }, { name: 'Pinellas Park' }, { name: 'Pittsburg' }, { name: 'Pittsburgh' }, { name: 'Pittsfield' }, { name: 'Placentia' }, { name: 'Plainfield' }, { name: 'Plainfield' }, { name: 'Plano' }, { name: 'Plantation' }, { name: 'Pleasanton' }, { name: 'Plymouth' }, { name: 'Pocatello' }, { name: 'Pomona' }, { name: 'Pompano Beach' }, { name: 'Pontiac' }, { name: 'Port Arthur' }, { name: 'Port Orange' }, { name: 'Port St. Lucie' }, { name: 'Portage' }, { name: 'Porterville' }, { name: 'Portland' }, { name: 'Portland' }, { name: 'Portsmouth' }, { name: 'Poway' }, { name: 'Prescott' }, { name: 'Prescott Valley' }, { name: 'Providence' }, { name: 'Provo' }, { name: 'Pueblo' }, { name: 'Puyallup' }, { name: 'Quincy' }, { name: 'Quincy' }, { name: 'Racine' }, { name: 'Raleigh' }, { name: 'Rancho Cordova' }, { name: 'Rancho Cucamonga' }, { name: 'Rancho Palos Verdes' }, { name: 'Rancho Santa Margarita' }, { name: 'Rapid City' }, { name: 'Reading' }, { name: 'Redding' }, { name: 'Redlands' }, { name: 'Redmond' }, { name: 'Redondo Beach' }, { name: 'Redwood City' }, { name: 'Reno' }, { name: 'Renton' }, { name: 'Revere' }, { name: 'Rialto' }, { name: 'Richardson' }, { name: 'Richland' }, { name: 'Richmond' }, { name: 'Richmond' }, { name: 'Rio Rancho' }, { name: 'Riverside' }, { name: 'Riverton' }, { name: 'Roanoke' }, { name: 'Rochester' }, { name: 'Rochester' }, { name: 'Rochester Hills' }, { name: 'Rock Hill' }, { name: 'Rock Island' }, { name: 'Rockford' }, { name: 'Rocklin' }, { name: 'Rockville' }, { name: 'Rockwall' }, { name: 'Rocky Mount' }, { name: 'Rogers' }, { name: 'Rohnert Park' }, { name: 'Romeoville' }, { name: 'Rosemead' }, { name: 'Roseville' }, { name: 'Roseville' }, { name: 'Roswell' }, { name: 'Roswell' }, { name: 'Round Rock' }, { name: 'Rowlett' }, { name: 'Roy' }, { name: 'Royal Oak' }, { name: 'Sacramento' }, { name: 'Saginaw' }, { name: 'Salem' }, { name: 'Salem' }, { name: 'Salina' }, { name: 'Salinas' }, { name: 'Salt Lake City' }, { name: 'Sammamish' }, { name: 'San Angelo' }, { name: 'San Antonio' }, { name: 'San Bernardino' }, { name: 'San Bruno' }, { name: 'San Buenaventura (Ventura)' }, { name: 'San Clemente' }, { name: 'San Diego' }, { name: 'San Francisco' }, { name: 'San Gabriel' }, { name: 'San Jacinto' }, { name: 'San Jose' }, { name: 'San Leandro' }, { name: 'San Luis Obispo' }, { name: 'San Marcos' }, { name: 'San Marcos' }, { name: 'San Mateo' }, { name: 'San Rafael' }, { name: 'San Ramon' }, { name: 'Sandy' }, { name: 'Sandy Springs' }, { name: 'Sanford' }, { name: 'Santa Ana' }, { name: 'Santa Barbara' }, { name: 'Santa Clara' }, { name: 'Santa Clarita' }, { name: 'Santa Cruz' }, { name: 'Santa Fe' }, { name: 'Santa Maria' }, { name: 'Santa Monica' }, { name: 'Santa Rosa' }, { name: 'Santee' }, { name: 'Sarasota' }, { name: 'Savannah' }, { name: 'Sayreville' }, { name: 'Schaumburg' }, { name: 'Schenectady' }, { name: 'Scottsdale' }, { name: 'Scranton' }, { name: 'Seattle' }, { name: 'Shakopee' }, { name: 'Shawnee' }, { name: 'Sheboygan' }, { name: 'Shelton' }, { name: 'Sherman' }, { name: 'Shoreline' }, { name: 'Shreveport' }, { name: 'Sierra Vista' }, { name: 'Simi Valley' }, { name: 'Sioux City' }, { name: 'Sioux Falls' }, { name: 'Skokie' }, { name: 'Smyrna' }, { name: 'Smyrna' }, { name: 'Somerville' }, { name: 'South Bend' }, { name: 'South Gate' }, { name: 'South Jordan' }, { name: 'South San Francisco' }, { name: 'Southaven' }, { name: 'Southfield' }, { name: 'Spanish Fork' }, { name: 'Sparks' }, { name: 'Spartanburg' }, { name: 'Spokane' }, { name: 'Spokane Valley' }, { name: 'Springdale' }, { name: 'Springfield' }, { name: 'Springfield' }, { name: 'Springfield' }, { name: 'Springfield' }, { name: 'Springfield' }, { name: 'St. Charles' }, { name: 'St. Clair Shores' }, { name: 'St. Cloud' }, { name: 'St. Cloud' }, { name: 'St. George' }, { name: 'St. Joseph' }, { name: 'St. Louis' }, { name: 'St. Louis Park' }, { name: 'St. Paul' }, { name: 'St. Peters' }, { name: 'St. Petersburg' }, { name: 'Stamford' }, { name: 'Stanton' }, { name: 'State College' }, { name: 'Sterling Heights' }, { name: 'Stillwater' }, { name: 'Stockton' }, { name: 'Streamwood' }, { name: 'Strongsville' }, { name: 'Suffolk' }, { name: 'Sugar Land' }, { name: 'Summerville' }, { name: 'Sumter' }, { name: 'Sunnyvale' }, { name: 'Sunrise' }, { name: 'Surprise' }, { name: 'Syracuse' }, { name: 'Tacoma' }, { name: 'Tallahassee' }, { name: 'Tamarac' }, { name: 'Tampa' }, { name: 'Taunton' }, { name: 'Taylor' }, { name: 'Taylorsville' }, { name: 'Temecula' }, { name: 'Tempe' }, { name: 'Temple' }, { name: 'Terre Haute' }, { name: 'Texarkana' }, { name: 'Texas City' }, { name: 'The Colony' }, { name: 'Thornton' }, { name: 'Thousand Oaks' }, { name: 'Tigard' }, { name: 'Tinley Park' }, { name: 'Titusville' }, { name: 'Toledo' }, { name: 'Topeka' }, { name: 'Torrance' }, { name: 'Tracy' }, { name: 'Trenton' }, { name: 'Troy' }, { name: 'Troy' }, { name: 'Tucson' }, { name: 'Tulare' }, { name: 'Tulsa' }, { name: 'Turlock' }, { name: 'Tuscaloosa' }, { name: 'Tustin' }, { name: 'Twin Falls' }, { name: 'Tyler' }, { name: 'Union City' }, { name: 'Union City' }, { name: 'Upland' }, { name: 'Urbana' }, { name: 'Urbandale' }, { name: 'Utica' }, { name: 'Vacaville' }, { name: 'Valdosta' }, { name: 'Vallejo' }, { name: 'Valley Stream' }, { name: 'Vancouver' }, { name: 'Victoria' }, { name: 'Victorville' }, { name: 'Vineland' }, { name: 'Virginia Beach' }, { name: 'Visalia' }, { name: 'Vista' }, { name: 'Waco' }, { name: 'Walnut Creek' }, { name: 'Waltham' }, { name: 'Warner Robins' }, { name: 'Warren' }, { name: 'Warren' }, { name: 'Warwick' }, { name: 'Washington' }, { name: 'Waterbury' }, { name: 'Waterloo' }, { name: 'Watsonville' }, { name: 'Waukegan' }, { name: 'Waukesha' }, { name: 'Wausau' }, { name: 'Wauwatosa' }, { name: 'Wellington' }, { name: 'Weslaco' }, { name: 'West Allis' }, { name: 'West Covina' }, { name: 'West Des Moines' }, { name: 'West Haven' }, { name: 'West Jordan' }, { name: 'West New York' }, { name: 'West Palm Beach' }, { name: 'West Sacramento' }, { name: 'West Valley City' }, { name: 'Westerville' }, { name: 'Westfield' }, { name: 'Westland' }, { name: 'Westminster' }, { name: 'Westminster' }, { name: 'Weston' }, { name: 'Weymouth Town' }, { name: 'Wheaton' }, { name: 'Wheeling' }, { name: 'White Plains' }, { name: 'Whittier' }, { name: 'Wichita' }, { name: 'Wichita Falls' }, { name: 'Wilkes-Barre' }, { name: 'Wilmington' }, { name: 'Wilmington' }, { name: 'Wilson' }, { name: 'Winston-Salem' }, { name: 'Winter Garden' }, { name: 'Woburn' }, { name: 'Woodbury' }, { name: 'Woodland' }, { name: 'Woonsocket' }, { name: 'Worcester' }, { name: 'Wylie' }, { name: 'Wyoming' }, { name: 'Yakima' }, { name: 'Yonkers' }, { name: 'Yorba Linda' }, { name: 'York' }, { name: 'Youngstown' }, { name: 'Yuba City' }, { name: 'Yucaipa' }, { name: 'Yuma' }]; @@ -1235,572 +1235,575 @@ exports.US = [{ value: 'AL', label: 'Alabama', disabled: true }, { value: 'AK', module.exports = [{ value: 'John Smith', label: 'John Smith', email: 'john@smith.com' }, { value: 'Merry Jane', label: 'Merry Jane', email: 'merry@jane.com' }, { value: 'Stan Hoper', label: 'Stan Hoper', email: 'stan@hoper.com' }]; },{}],16:[function(require,module,exports){ -var charenc = { - // UTF-8 encoding - utf8: { - // Convert a string to a byte array - stringToBytes: function(str) { - return charenc.bin.stringToBytes(unescape(encodeURIComponent(str))); - }, +// the whatwg-fetch polyfill installs the fetch() function +// on the global object (window or self) +// +// Return that as the export for use in Webpack, Browserify etc. +require('whatwg-fetch'); +module.exports = self.fetch.bind(self); - // Convert a byte array to a string - bytesToString: function(bytes) { - return decodeURIComponent(escape(charenc.bin.bytesToString(bytes))); - } - }, +},{"whatwg-fetch":17}],17:[function(require,module,exports){ +(function(self) { + 'use strict'; - // Binary encoding - bin: { - // Convert a string to a byte array - stringToBytes: function(str) { - for (var bytes = [], i = 0; i < str.length; i++) - bytes.push(str.charCodeAt(i) & 0xFF); - return bytes; - }, + if (self.fetch) { + return + } - // Convert a byte array to a string - bytesToString: function(bytes) { - for (var str = [], i = 0; i < bytes.length; i++) - str.push(String.fromCharCode(bytes[i])); - return str.join(''); - } + var support = { + searchParams: 'URLSearchParams' in self, + iterable: 'Symbol' in self && 'iterator' in Symbol, + blob: 'FileReader' in self && 'Blob' in self && (function() { + try { + new Blob() + return true + } catch(e) { + return false + } + })(), + formData: 'FormData' in self, + arrayBuffer: 'ArrayBuffer' in self } -}; -module.exports = charenc; + if (support.arrayBuffer) { + var viewClasses = [ + '[object Int8Array]', + '[object Uint8Array]', + '[object Uint8ClampedArray]', + '[object Int16Array]', + '[object Uint16Array]', + '[object Int32Array]', + '[object Uint32Array]', + '[object Float32Array]', + '[object Float64Array]' + ] -},{}],17:[function(require,module,exports){ -(function() { - var base64map - = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/', + var isDataView = function(obj) { + return obj && DataView.prototype.isPrototypeOf(obj) + } - crypt = { - // Bit-wise rotation left - rotl: function(n, b) { - return (n << b) | (n >>> (32 - b)); - }, + var isArrayBufferView = ArrayBuffer.isView || function(obj) { + return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1 + } + } - // Bit-wise rotation right - rotr: function(n, b) { - return (n << (32 - b)) | (n >>> b); - }, + function normalizeName(name) { + if (typeof name !== 'string') { + name = String(name) + } + if (/[^a-z0-9\-#$%&'*+.\^_`|~]/i.test(name)) { + throw new TypeError('Invalid character in header field name') + } + return name.toLowerCase() + } - // Swap big-endian to little-endian and vice versa - endian: function(n) { - // If number given, swap endian - if (n.constructor == Number) { - return crypt.rotl(n, 8) & 0x00FF00FF | crypt.rotl(n, 24) & 0xFF00FF00; + function normalizeValue(value) { + if (typeof value !== 'string') { + value = String(value) + } + return value + } + + // Build a destructive iterator for the value list + function iteratorFor(items) { + var iterator = { + next: function() { + var value = items.shift() + return {done: value === undefined, value: value} } + } - // Else, assume array and swap all items - for (var i = 0; i < n.length; i++) - n[i] = crypt.endian(n[i]); - return n; - }, + if (support.iterable) { + iterator[Symbol.iterator] = function() { + return iterator + } + } - // Generate an array of any length of random bytes - randomBytes: function(n) { - for (var bytes = []; n > 0; n--) - bytes.push(Math.floor(Math.random() * 256)); - return bytes; - }, + return iterator + } - // Convert a byte array to big-endian 32-bit words - bytesToWords: function(bytes) { - for (var words = [], i = 0, b = 0; i < bytes.length; i++, b += 8) - words[b >>> 5] |= bytes[i] << (24 - b % 32); - return words; - }, + function Headers(headers) { + this.map = {} - // Convert big-endian 32-bit words to a byte array - wordsToBytes: function(words) { - for (var bytes = [], b = 0; b < words.length * 32; b += 8) - bytes.push((words[b >>> 5] >>> (24 - b % 32)) & 0xFF); - return bytes; - }, + if (headers instanceof Headers) { + headers.forEach(function(value, name) { + this.append(name, value) + }, this) + } else if (Array.isArray(headers)) { + headers.forEach(function(header) { + this.append(header[0], header[1]) + }, this) + } else if (headers) { + Object.getOwnPropertyNames(headers).forEach(function(name) { + this.append(name, headers[name]) + }, this) + } + } - // Convert a byte array to a hex string - bytesToHex: function(bytes) { - for (var hex = [], i = 0; i < bytes.length; i++) { - hex.push((bytes[i] >>> 4).toString(16)); - hex.push((bytes[i] & 0xF).toString(16)); - } - return hex.join(''); - }, + Headers.prototype.append = function(name, value) { + name = normalizeName(name) + value = normalizeValue(value) + var oldValue = this.map[name] + this.map[name] = oldValue ? oldValue+','+value : value + } - // Convert a hex string to a byte array - hexToBytes: function(hex) { - for (var bytes = [], c = 0; c < hex.length; c += 2) - bytes.push(parseInt(hex.substr(c, 2), 16)); - return bytes; - }, + Headers.prototype['delete'] = function(name) { + delete this.map[normalizeName(name)] + } - // Convert a byte array to a base-64 string - bytesToBase64: function(bytes) { - for (var base64 = [], i = 0; i < bytes.length; i += 3) { - var triplet = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2]; - for (var j = 0; j < 4; j++) - if (i * 8 + j * 6 <= bytes.length * 8) - base64.push(base64map.charAt((triplet >>> 6 * (3 - j)) & 0x3F)); - else - base64.push('='); - } - return base64.join(''); - }, + Headers.prototype.get = function(name) { + name = normalizeName(name) + return this.has(name) ? this.map[name] : null + } - // Convert a base-64 string to a byte array - base64ToBytes: function(base64) { - // Remove non-base-64 characters - base64 = base64.replace(/[^A-Z0-9+\/]/ig, ''); + Headers.prototype.has = function(name) { + return this.map.hasOwnProperty(normalizeName(name)) + } - for (var bytes = [], i = 0, imod4 = 0; i < base64.length; - imod4 = ++i % 4) { - if (imod4 == 0) continue; - bytes.push(((base64map.indexOf(base64.charAt(i - 1)) - & (Math.pow(2, -2 * imod4 + 8) - 1)) << (imod4 * 2)) - | (base64map.indexOf(base64.charAt(i)) >>> (6 - imod4 * 2))); + Headers.prototype.set = function(name, value) { + this.map[normalizeName(name)] = normalizeValue(value) + } + + Headers.prototype.forEach = function(callback, thisArg) { + for (var name in this.map) { + if (this.map.hasOwnProperty(name)) { + callback.call(thisArg, this.map[name], name, this) } - return bytes; } - }; + } - module.exports = crypt; -})(); + Headers.prototype.keys = function() { + var items = [] + this.forEach(function(value, name) { items.push(name) }) + return iteratorFor(items) + } -},{}],18:[function(require,module,exports){ -'use strict'; -module.exports = !!(typeof window !== 'undefined' && window.document && window.document.createElement); -},{}],19:[function(require,module,exports){ -'use strict'; + Headers.prototype.values = function() { + var items = [] + this.forEach(function(value) { items.push(value) }) + return iteratorFor(items) + } -var canUseDOM = require('./inDOM'); + Headers.prototype.entries = function() { + var items = [] + this.forEach(function(value, name) { items.push([name, value]) }) + return iteratorFor(items) + } -var size; + if (support.iterable) { + Headers.prototype[Symbol.iterator] = Headers.prototype.entries + } -module.exports = function (recalc) { - if (!size || recalc) { - if (canUseDOM) { - var scrollDiv = document.createElement('div'); + function consumed(body) { + if (body.bodyUsed) { + return Promise.reject(new TypeError('Already read')) + } + body.bodyUsed = true + } - scrollDiv.style.position = 'absolute'; - scrollDiv.style.top = '-9999px'; - scrollDiv.style.width = '50px'; - scrollDiv.style.height = '50px'; - scrollDiv.style.overflow = 'scroll'; + function fileReaderReady(reader) { + return new Promise(function(resolve, reject) { + reader.onload = function() { + resolve(reader.result) + } + reader.onerror = function() { + reject(reader.error) + } + }) + } - document.body.appendChild(scrollDiv); - size = scrollDiv.offsetWidth - scrollDiv.clientWidth; - document.body.removeChild(scrollDiv); + function readBlobAsArrayBuffer(blob) { + var reader = new FileReader() + var promise = fileReaderReady(reader) + reader.readAsArrayBuffer(blob) + return promise + } + + function readBlobAsText(blob) { + var reader = new FileReader() + var promise = fileReaderReady(reader) + reader.readAsText(blob) + return promise + } + + function readArrayBufferAsText(buf) { + var view = new Uint8Array(buf) + var chars = new Array(view.length) + + for (var i = 0; i < view.length; i++) { + chars[i] = String.fromCharCode(view[i]) } + return chars.join('') } - return size; -}; -},{"./inDOM":18}],20:[function(require,module,exports){ -/** - * Copyright (c) 2013-present, Facebook, Inc. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. An additional grant - * of patent rights can be found in the PATENTS file in the same directory. - * - * @typechecks - * - */ + function bufferClone(buf) { + if (buf.slice) { + return buf.slice(0) + } else { + var view = new Uint8Array(buf.byteLength) + view.set(new Uint8Array(buf)) + return view.buffer + } + } -/*eslint-disable no-self-compare */ + function Body() { + this.bodyUsed = false -'use strict'; + this._initBody = function(body) { + this._bodyInit = body + if (!body) { + this._bodyText = '' + } else if (typeof body === 'string') { + this._bodyText = body + } else if (support.blob && Blob.prototype.isPrototypeOf(body)) { + this._bodyBlob = body + } else if (support.formData && FormData.prototype.isPrototypeOf(body)) { + this._bodyFormData = body + } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) { + this._bodyText = body.toString() + } else if (support.arrayBuffer && support.blob && isDataView(body)) { + this._bodyArrayBuffer = bufferClone(body.buffer) + // IE 10-11 can't handle a DataView body. + this._bodyInit = new Blob([this._bodyArrayBuffer]) + } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) { + this._bodyArrayBuffer = bufferClone(body) + } else { + throw new Error('unsupported BodyInit type') + } -var hasOwnProperty = Object.prototype.hasOwnProperty; + if (!this.headers.get('content-type')) { + if (typeof body === 'string') { + this.headers.set('content-type', 'text/plain;charset=UTF-8') + } else if (this._bodyBlob && this._bodyBlob.type) { + this.headers.set('content-type', this._bodyBlob.type) + } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) { + this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8') + } + } + } -/** - * inlined Object.is polyfill to avoid requiring consumers ship their own - * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is - */ -function is(x, y) { - // SameValue algorithm - if (x === y) { - // Steps 1-5, 7-10 - // Steps 6.b-6.e: +0 != -0 - // Added the nonzero y check to make Flow happy, but it is redundant - return x !== 0 || y !== 0 || 1 / x === 1 / y; - } else { - // Step 6.a: NaN == NaN - return x !== x && y !== y; - } -} + if (support.blob) { + this.blob = function() { + var rejected = consumed(this) + if (rejected) { + return rejected + } -/** - * Performs equality by iterating through keys on an object and returning false - * when any key has values which are not strictly equal between the arguments. - * Returns true when the values of all keys are strictly equal. - */ -function shallowEqual(objA, objB) { - if (is(objA, objB)) { - return true; - } + if (this._bodyBlob) { + return Promise.resolve(this._bodyBlob) + } else if (this._bodyArrayBuffer) { + return Promise.resolve(new Blob([this._bodyArrayBuffer])) + } else if (this._bodyFormData) { + throw new Error('could not read FormData body as blob') + } else { + return Promise.resolve(new Blob([this._bodyText])) + } + } - if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) { - return false; - } + this.arrayBuffer = function() { + if (this._bodyArrayBuffer) { + return consumed(this) || Promise.resolve(this._bodyArrayBuffer) + } else { + return this.blob().then(readBlobAsArrayBuffer) + } + } + } - var keysA = Object.keys(objA); - var keysB = Object.keys(objB); + this.text = function() { + var rejected = consumed(this) + if (rejected) { + return rejected + } - if (keysA.length !== keysB.length) { - return false; - } + if (this._bodyBlob) { + return readBlobAsText(this._bodyBlob) + } else if (this._bodyArrayBuffer) { + return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer)) + } else if (this._bodyFormData) { + throw new Error('could not read FormData body as text') + } else { + return Promise.resolve(this._bodyText) + } + } - // Test for A's keys different from B. - for (var i = 0; i < keysA.length; i++) { - if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) { - return false; + if (support.formData) { + this.formData = function() { + return this.text().then(decode) + } } - } - return true; -} + this.json = function() { + return this.text().then(JSON.parse) + } -module.exports = shallowEqual; -},{}],21:[function(require,module,exports){ -/*! - * Determine if an object is a Buffer - * - * @author Feross Aboukhadijeh - * @license MIT - */ + return this + } -// The _isBuffer check is for Safari 5-7 support, because it's missing -// Object.prototype.constructor. Remove this eventually -module.exports = function (obj) { - return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer) -} + // HTTP methods whose capitalization should be normalized + var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'] -function isBuffer (obj) { - return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) -} + function normalizeMethod(method) { + var upcased = method.toUpperCase() + return (methods.indexOf(upcased) > -1) ? upcased : method + } -// For Node v0.10 support. Remove this eventually. -function isSlowBuffer (obj) { - return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0)) -} + function Request(input, options) { + options = options || {} + var body = options.body -},{}],22:[function(require,module,exports){ -module.exports = function() { - var mediaQuery; - if (typeof window !== "undefined" && window !== null) { - mediaQuery = "(-webkit-min-device-pixel-ratio: 1.25), (min--moz-device-pixel-ratio: 1.25), (-o-min-device-pixel-ratio: 5/4), (min-resolution: 1.25dppx)"; - if (window.devicePixelRatio > 1.25) { - return true; + if (input instanceof Request) { + if (input.bodyUsed) { + throw new TypeError('Already read') + } + this.url = input.url + this.credentials = input.credentials + if (!options.headers) { + this.headers = new Headers(input.headers) + } + this.method = input.method + this.mode = input.mode + if (!body && input._bodyInit != null) { + body = input._bodyInit + input.bodyUsed = true + } + } else { + this.url = String(input) } - if (window.matchMedia && window.matchMedia(mediaQuery).matches) { - return true; + + this.credentials = options.credentials || this.credentials || 'omit' + if (options.headers || !this.headers) { + this.headers = new Headers(options.headers) } + this.method = normalizeMethod(options.method || this.method || 'GET') + this.mode = options.mode || this.mode || null + this.referrer = null + + if ((this.method === 'GET' || this.method === 'HEAD') && body) { + throw new TypeError('Body not allowed for GET or HEAD requests') + } + this._initBody(body) } - return false; -}; -},{}],23:[function(require,module,exports){ -// the whatwg-fetch polyfill installs the fetch() function -// on the global object (window or self) -// -// Return that as the export for use in Webpack, Browserify etc. -require('whatwg-fetch'); -module.exports = self.fetch.bind(self); + Request.prototype.clone = function() { + return new Request(this, { body: this._bodyInit }) + } -},{"whatwg-fetch":83}],24:[function(require,module,exports){ -(function(){ - var crypt = require('crypt'), - utf8 = require('charenc').utf8, - isBuffer = require('is-buffer'), - bin = require('charenc').bin, - - // The core - md5 = function (message, options) { - // Convert to byte array - if (message.constructor == String) - if (options && options.encoding === 'binary') - message = bin.stringToBytes(message); - else - message = utf8.stringToBytes(message); - else if (isBuffer(message)) - message = Array.prototype.slice.call(message, 0); - else if (!Array.isArray(message)) - message = message.toString(); - // else, assume byte array already - - var m = crypt.bytesToWords(message), - l = message.length * 8, - a = 1732584193, - b = -271733879, - c = -1732584194, - d = 271733878; - - // Swap endian - for (var i = 0; i < m.length; i++) { - m[i] = ((m[i] << 8) | (m[i] >>> 24)) & 0x00FF00FF | - ((m[i] << 24) | (m[i] >>> 8)) & 0xFF00FF00; - } - - // Padding - m[l >>> 5] |= 0x80 << (l % 32); - m[(((l + 64) >>> 9) << 4) + 14] = l; - - // Method shortcuts - var FF = md5._ff, - GG = md5._gg, - HH = md5._hh, - II = md5._ii; - - for (var i = 0; i < m.length; i += 16) { - - var aa = a, - bb = b, - cc = c, - dd = d; - - a = FF(a, b, c, d, m[i+ 0], 7, -680876936); - d = FF(d, a, b, c, m[i+ 1], 12, -389564586); - c = FF(c, d, a, b, m[i+ 2], 17, 606105819); - b = FF(b, c, d, a, m[i+ 3], 22, -1044525330); - a = FF(a, b, c, d, m[i+ 4], 7, -176418897); - d = FF(d, a, b, c, m[i+ 5], 12, 1200080426); - c = FF(c, d, a, b, m[i+ 6], 17, -1473231341); - b = FF(b, c, d, a, m[i+ 7], 22, -45705983); - a = FF(a, b, c, d, m[i+ 8], 7, 1770035416); - d = FF(d, a, b, c, m[i+ 9], 12, -1958414417); - c = FF(c, d, a, b, m[i+10], 17, -42063); - b = FF(b, c, d, a, m[i+11], 22, -1990404162); - a = FF(a, b, c, d, m[i+12], 7, 1804603682); - d = FF(d, a, b, c, m[i+13], 12, -40341101); - c = FF(c, d, a, b, m[i+14], 17, -1502002290); - b = FF(b, c, d, a, m[i+15], 22, 1236535329); - - a = GG(a, b, c, d, m[i+ 1], 5, -165796510); - d = GG(d, a, b, c, m[i+ 6], 9, -1069501632); - c = GG(c, d, a, b, m[i+11], 14, 643717713); - b = GG(b, c, d, a, m[i+ 0], 20, -373897302); - a = GG(a, b, c, d, m[i+ 5], 5, -701558691); - d = GG(d, a, b, c, m[i+10], 9, 38016083); - c = GG(c, d, a, b, m[i+15], 14, -660478335); - b = GG(b, c, d, a, m[i+ 4], 20, -405537848); - a = GG(a, b, c, d, m[i+ 9], 5, 568446438); - d = GG(d, a, b, c, m[i+14], 9, -1019803690); - c = GG(c, d, a, b, m[i+ 3], 14, -187363961); - b = GG(b, c, d, a, m[i+ 8], 20, 1163531501); - a = GG(a, b, c, d, m[i+13], 5, -1444681467); - d = GG(d, a, b, c, m[i+ 2], 9, -51403784); - c = GG(c, d, a, b, m[i+ 7], 14, 1735328473); - b = GG(b, c, d, a, m[i+12], 20, -1926607734); - - a = HH(a, b, c, d, m[i+ 5], 4, -378558); - d = HH(d, a, b, c, m[i+ 8], 11, -2022574463); - c = HH(c, d, a, b, m[i+11], 16, 1839030562); - b = HH(b, c, d, a, m[i+14], 23, -35309556); - a = HH(a, b, c, d, m[i+ 1], 4, -1530992060); - d = HH(d, a, b, c, m[i+ 4], 11, 1272893353); - c = HH(c, d, a, b, m[i+ 7], 16, -155497632); - b = HH(b, c, d, a, m[i+10], 23, -1094730640); - a = HH(a, b, c, d, m[i+13], 4, 681279174); - d = HH(d, a, b, c, m[i+ 0], 11, -358537222); - c = HH(c, d, a, b, m[i+ 3], 16, -722521979); - b = HH(b, c, d, a, m[i+ 6], 23, 76029189); - a = HH(a, b, c, d, m[i+ 9], 4, -640364487); - d = HH(d, a, b, c, m[i+12], 11, -421815835); - c = HH(c, d, a, b, m[i+15], 16, 530742520); - b = HH(b, c, d, a, m[i+ 2], 23, -995338651); - - a = II(a, b, c, d, m[i+ 0], 6, -198630844); - d = II(d, a, b, c, m[i+ 7], 10, 1126891415); - c = II(c, d, a, b, m[i+14], 15, -1416354905); - b = II(b, c, d, a, m[i+ 5], 21, -57434055); - a = II(a, b, c, d, m[i+12], 6, 1700485571); - d = II(d, a, b, c, m[i+ 3], 10, -1894986606); - c = II(c, d, a, b, m[i+10], 15, -1051523); - b = II(b, c, d, a, m[i+ 1], 21, -2054922799); - a = II(a, b, c, d, m[i+ 8], 6, 1873313359); - d = II(d, a, b, c, m[i+15], 10, -30611744); - c = II(c, d, a, b, m[i+ 6], 15, -1560198380); - b = II(b, c, d, a, m[i+13], 21, 1309151649); - a = II(a, b, c, d, m[i+ 4], 6, -145523070); - d = II(d, a, b, c, m[i+11], 10, -1120210379); - c = II(c, d, a, b, m[i+ 2], 15, 718787259); - b = II(b, c, d, a, m[i+ 9], 21, -343485551); - - a = (a + aa) >>> 0; - b = (b + bb) >>> 0; - c = (c + cc) >>> 0; - d = (d + dd) >>> 0; - } - - return crypt.endian([a, b, c, d]); - }; - - // Auxiliary functions - md5._ff = function (a, b, c, d, x, s, t) { - var n = a + (b & c | ~b & d) + (x >>> 0) + t; - return ((n << s) | (n >>> (32 - s))) + b; - }; - md5._gg = function (a, b, c, d, x, s, t) { - var n = a + (b & d | c & ~d) + (x >>> 0) + t; - return ((n << s) | (n >>> (32 - s))) + b; - }; - md5._hh = function (a, b, c, d, x, s, t) { - var n = a + (b ^ c ^ d) + (x >>> 0) + t; - return ((n << s) | (n >>> (32 - s))) + b; - }; - md5._ii = function (a, b, c, d, x, s, t) { - var n = a + (c ^ (b | ~d)) + (x >>> 0) + t; - return ((n << s) | (n >>> (32 - s))) + b; - }; - - // Package private blocksize - md5._blocksize = 16; - md5._digestsize = 16; - - module.exports = function (message, options) { - if (message === undefined || message === null) - throw new Error('Illegal argument ' + message); - - var digestbytes = crypt.wordsToBytes(md5(message, options)); - return options && options.asBytes ? digestbytes : - options && options.asString ? bin.bytesToString(digestbytes) : - crypt.bytesToHex(digestbytes); - }; - -})(); + function decode(body) { + var form = new FormData() + body.trim().split('&').forEach(function(bytes) { + if (bytes) { + var split = bytes.split('=') + var name = split.shift().replace(/\+/g, ' ') + var value = split.join('=').replace(/\+/g, ' ') + form.append(decodeURIComponent(name), decodeURIComponent(value)) + } + }) + return form + } -},{"charenc":16,"crypt":17,"is-buffer":21}],25:[function(require,module,exports){ -/* -object-assign -(c) Sindre Sorhus -@license MIT -*/ + function parseHeaders(rawHeaders) { + var headers = new Headers() + rawHeaders.split(/\r?\n/).forEach(function(line) { + var parts = line.split(':') + var key = parts.shift().trim() + if (key) { + var value = parts.join(':').trim() + headers.append(key, value) + } + }) + return headers + } -'use strict'; -/* eslint-disable no-unused-vars */ -var getOwnPropertySymbols = Object.getOwnPropertySymbols; -var hasOwnProperty = Object.prototype.hasOwnProperty; -var propIsEnumerable = Object.prototype.propertyIsEnumerable; + Body.call(Request.prototype) -function toObject(val) { - if (val === null || val === undefined) { - throw new TypeError('Object.assign cannot be called with null or undefined'); - } + function Response(bodyInit, options) { + if (!options) { + options = {} + } - return Object(val); -} + this.type = 'default' + this.status = 'status' in options ? options.status : 200 + this.ok = this.status >= 200 && this.status < 300 + this.statusText = 'statusText' in options ? options.statusText : 'OK' + this.headers = new Headers(options.headers) + this.url = options.url || '' + this._initBody(bodyInit) + } -function shouldUseNative() { - try { - if (!Object.assign) { - return false; - } + Body.call(Response.prototype) - // Detect buggy property enumeration order in older V8 versions. + Response.prototype.clone = function() { + return new Response(this._bodyInit, { + status: this.status, + statusText: this.statusText, + headers: new Headers(this.headers), + url: this.url + }) + } - // https://bugs.chromium.org/p/v8/issues/detail?id=4118 - var test1 = new String('abc'); // eslint-disable-line no-new-wrappers - test1[5] = 'de'; - if (Object.getOwnPropertyNames(test1)[0] === '5') { - return false; - } + Response.error = function() { + var response = new Response(null, {status: 0, statusText: ''}) + response.type = 'error' + return response + } - // https://bugs.chromium.org/p/v8/issues/detail?id=3056 - var test2 = {}; - for (var i = 0; i < 10; i++) { - test2['_' + String.fromCharCode(i)] = i; - } - var order2 = Object.getOwnPropertyNames(test2).map(function (n) { - return test2[n]; - }); - if (order2.join('') !== '0123456789') { - return false; - } + var redirectStatuses = [301, 302, 303, 307, 308] - // https://bugs.chromium.org/p/v8/issues/detail?id=3056 - var test3 = {}; - 'abcdefghijklmnopqrst'.split('').forEach(function (letter) { - test3[letter] = letter; - }); - if (Object.keys(Object.assign({}, test3)).join('') !== - 'abcdefghijklmnopqrst') { - return false; - } + Response.redirect = function(url, status) { + if (redirectStatuses.indexOf(status) === -1) { + throw new RangeError('Invalid status code') + } - return true; - } catch (err) { - // We don't expect any of the above to throw, but better to be safe. - return false; - } -} + return new Response(null, {status: status, headers: {location: url}}) + } -module.exports = shouldUseNative() ? Object.assign : function (target, source) { - var from; - var to = toObject(target); - var symbols; + self.Headers = Headers + self.Request = Request + self.Response = Response - for (var s = 1; s < arguments.length; s++) { - from = Object(arguments[s]); + self.fetch = function(input, init) { + return new Promise(function(resolve, reject) { + var request = new Request(input, init) + var xhr = new XMLHttpRequest() - for (var key in from) { - if (hasOwnProperty.call(from, key)) { - to[key] = from[key]; - } - } + xhr.onload = function() { + var options = { + status: xhr.status, + statusText: xhr.statusText, + headers: parseHeaders(xhr.getAllResponseHeaders() || '') + } + options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL') + var body = 'response' in xhr ? xhr.response : xhr.responseText + resolve(new Response(body, options)) + } - if (getOwnPropertySymbols) { - symbols = getOwnPropertySymbols(from); - for (var i = 0; i < symbols.length; i++) { - if (propIsEnumerable.call(from, symbols[i])) { - to[symbols[i]] = from[symbols[i]]; - } - } - } - } + xhr.onerror = function() { + reject(new TypeError('Network request failed')) + } - return to; -}; + xhr.ontimeout = function() { + reject(new TypeError('Network request failed')) + } -},{}],26:[function(require,module,exports){ -(function (process){ -// Generated by CoffeeScript 1.7.1 -(function() { - var getNanoSeconds, hrtime, loadTime; + xhr.open(request.method, request.url, true) - if ((typeof performance !== "undefined" && performance !== null) && performance.now) { - module.exports = function() { - return performance.now(); - }; - } else if ((typeof process !== "undefined" && process !== null) && process.hrtime) { - module.exports = function() { - return (getNanoSeconds() - loadTime) / 1e6; - }; - hrtime = process.hrtime; - getNanoSeconds = function() { - var hr; - hr = hrtime(); - return hr[0] * 1e9 + hr[1]; - }; - loadTime = getNanoSeconds(); - } else if (Date.now) { - module.exports = function() { - return Date.now() - loadTime; - }; - loadTime = Date.now(); + if (request.credentials === 'include') { + xhr.withCredentials = true + } + + if ('responseType' in xhr && support.blob) { + xhr.responseType = 'blob' + } + + request.headers.forEach(function(value, name) { + xhr.setRequestHeader(name, value) + }) + + xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit) + }) + } + self.fetch.polyfill = true +})(typeof self !== 'undefined' ? self : this); + +},{}],18:[function(require,module,exports){ +/** + * Copyright 2013-present, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * LICENSE file in the root directory of this source tree. An additional grant + * of patent rights can be found in the PATENTS file in the same directory. + * + * @providesModule shallowCompare + */ + +'use strict'; + +var shallowEqual = require('fbjs/lib/shallowEqual'); + +/** + * Does a shallow comparison for props and state. + * See ReactComponentWithPureRenderMixin + * See also https://facebook.github.io/react/docs/shallow-compare.html + */ +function shallowCompare(instance, nextProps, nextState) { + return ( + !shallowEqual(instance.props, nextProps) || + !shallowEqual(instance.state, nextState) + ); +} + +module.exports = shallowCompare; + +},{"fbjs/lib/shallowEqual":19}],19:[function(require,module,exports){ +/** + * Copyright (c) 2013-present, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * LICENSE file in the root directory of this source tree. An additional grant + * of patent rights can be found in the PATENTS file in the same directory. + * + * @typechecks + * + */ + +/*eslint-disable no-self-compare */ + +'use strict'; + +var hasOwnProperty = Object.prototype.hasOwnProperty; + +/** + * inlined Object.is polyfill to avoid requiring consumers ship their own + * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is + */ +function is(x, y) { + // SameValue algorithm + if (x === y) { + // Steps 1-5, 7-10 + // Steps 6.b-6.e: +0 != -0 + // Added the nonzero y check to make Flow happy, but it is redundant + return x !== 0 || y !== 0 || 1 / x === 1 / y; } else { - module.exports = function() { - return new Date().getTime() - loadTime; - }; - loadTime = new Date().getTime(); + // Step 6.a: NaN == NaN + return x !== x && y !== y; } +} -}).call(this); +/** + * Performs equality by iterating through keys on an object and returning false + * when any key has values which are not strictly equal between the arguments. + * Returns true when the values of all keys are strictly equal. + */ +function shallowEqual(objA, objB) { + if (is(objA, objB)) { + return true; + } -}).call(this,require('_process')) -},{"_process":27}],27:[function(require,module,exports){ + if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) { + return false; + } + + var keysA = Object.keys(objA); + var keysB = Object.keys(objB); + + if (keysA.length !== keysB.length) { + return false; + } + + // Test for A's keys different from B. + for (var i = 0; i < keysA.length; i++) { + if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) { + return false; + } + } + + return true; +} + +module.exports = shallowEqual; +},{}],20:[function(require,module,exports){ // shim for using process in browser var process = module.exports = {}; @@ -1971,6 +1974,10 @@ process.off = noop; process.removeListener = noop; process.removeAllListeners = noop; process.emit = noop; +process.prependListener = noop; +process.prependOnceListener = noop; + +process.listeners = function (name) { return [] } process.binding = function (name) { throw new Error('process.binding is not supported'); @@ -1982,305 +1989,22 @@ process.chdir = function (dir) { }; process.umask = function() { return 0; }; -},{}],28:[function(require,module,exports){ +},{}],21:[function(require,module,exports){ 'use strict'; -var strictUriEncode = require('strict-uri-encode'); -var objectAssign = require('object-assign'); -function encoderForArrayFormat(opts) { - switch (opts.arrayFormat) { - case 'index': - return function (key, value, index) { - return value === null ? [ - encode(key, opts), - '[', - index, - ']' - ].join('') : [ - encode(key, opts), - '[', - encode(index, opts), - ']=', - encode(value, opts) - ].join(''); - }; +var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; - case 'bracket': - return function (key, value) { - return value === null ? encode(key, opts) : [ - encode(key, opts), - '[]=', - encode(value, opts) - ].join(''); - }; +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); - default: - return function (key, value) { - return value === null ? encode(key, opts) : [ - encode(key, opts), - '=', - encode(value, opts) - ].join(''); - }; - } -} +var _react = require('react'); -function parserForArrayFormat(opts) { - var result; +var _react2 = _interopRequireDefault(_react); - switch (opts.arrayFormat) { - case 'index': - return function (key, value, accumulator) { - result = /\[(\d*)]$/.exec(key); +var _md = require('md5'); - key = key.replace(/\[\d*]$/, ''); +var _md2 = _interopRequireDefault(_md); - if (!result) { - accumulator[key] = value; - return; - } - - if (accumulator[key] === undefined) { - accumulator[key] = {}; - } - - accumulator[key][result[1]] = value; - }; - - case 'bracket': - return function (key, value, accumulator) { - result = /(\[])$/.exec(key); - - key = key.replace(/\[]$/, ''); - - if (!result || accumulator[key] === undefined) { - accumulator[key] = value; - return; - } - - accumulator[key] = [].concat(accumulator[key], value); - }; - - default: - return function (key, value, accumulator) { - if (accumulator[key] === undefined) { - accumulator[key] = value; - return; - } - - accumulator[key] = [].concat(accumulator[key], value); - }; - } -} - -function encode(value, opts) { - if (opts.encode) { - return opts.strict ? strictUriEncode(value) : encodeURIComponent(value); - } - - return value; -} - -function keysSorter(input) { - if (Array.isArray(input)) { - return input.sort(); - } else if (typeof input === 'object') { - return keysSorter(Object.keys(input)).sort(function (a, b) { - return Number(a) - Number(b); - }).map(function (key) { - return input[key]; - }); - } - - return input; -} - -exports.extract = function (str) { - return str.split('?')[1] || ''; -}; - -exports.parse = function (str, opts) { - opts = objectAssign({arrayFormat: 'none'}, opts); - - var formatter = parserForArrayFormat(opts); - - // Create an object with no prototype - // https://github.com/sindresorhus/query-string/issues/47 - var ret = Object.create(null); - - if (typeof str !== 'string') { - return ret; - } - - str = str.trim().replace(/^(\?|#|&)/, ''); - - if (!str) { - return ret; - } - - str.split('&').forEach(function (param) { - var parts = param.replace(/\+/g, ' ').split('='); - // Firefox (pre 40) decodes `%3D` to `=` - // https://github.com/sindresorhus/query-string/pull/37 - var key = parts.shift(); - var val = parts.length > 0 ? parts.join('=') : undefined; - - // missing `=` should be `null`: - // http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters - val = val === undefined ? null : decodeURIComponent(val); - - formatter(decodeURIComponent(key), val, ret); - }); - - return Object.keys(ret).sort().reduce(function (result, key) { - var val = ret[key]; - if (Boolean(val) && typeof val === 'object' && !Array.isArray(val)) { - // Sort object keys, not values - result[key] = keysSorter(val); - } else { - result[key] = val; - } - - return result; - }, Object.create(null)); -}; - -exports.stringify = function (obj, opts) { - var defaults = { - encode: true, - strict: true, - arrayFormat: 'none' - }; - - opts = objectAssign(defaults, opts); - - var formatter = encoderForArrayFormat(opts); - - return obj ? Object.keys(obj).sort().map(function (key) { - var val = obj[key]; - - if (val === undefined) { - return ''; - } - - if (val === null) { - return encode(key, opts); - } - - if (Array.isArray(val)) { - var result = []; - - val.slice().forEach(function (val2) { - if (val2 === undefined) { - return; - } - - result.push(formatter(key, val2, result.length)); - }); - - return result.join('&'); - } - - return encode(key, opts) + '=' + encode(val, opts); - }).filter(function (x) { - return x.length > 0; - }).join('&') : ''; -}; - -},{"object-assign":25,"strict-uri-encode":82}],29:[function(require,module,exports){ -(function (global){ -var now = require('performance-now') - , root = typeof window === 'undefined' ? global : window - , vendors = ['moz', 'webkit'] - , suffix = 'AnimationFrame' - , raf = root['request' + suffix] - , caf = root['cancel' + suffix] || root['cancelRequest' + suffix] - -for(var i = 0; !raf && i < vendors.length; i++) { - raf = root[vendors[i] + 'Request' + suffix] - caf = root[vendors[i] + 'Cancel' + suffix] - || root[vendors[i] + 'CancelRequest' + suffix] -} - -// Some versions of FF have rAF but not cAF -if(!raf || !caf) { - var last = 0 - , id = 0 - , queue = [] - , frameDuration = 1000 / 60 - - raf = function(callback) { - if(queue.length === 0) { - var _now = now() - , next = Math.max(0, frameDuration - (_now - last)) - last = next + _now - setTimeout(function() { - var cp = queue.slice(0) - // Clear queue here to prevent - // callbacks from appending listeners - // to the current frame's queue - queue.length = 0 - for(var i = 0; i < cp.length; i++) { - if(!cp[i].cancelled) { - try{ - cp[i].callback(last) - } catch(e) { - setTimeout(function() { throw e }, 0) - } - } - } - }, Math.round(next)) - } - queue.push({ - handle: ++id, - callback: callback, - cancelled: false - }) - return id - } - - caf = function(handle) { - for(var i = 0; i < queue.length; i++) { - if(queue[i].handle === handle) { - queue[i].cancelled = true - } - } - } -} - -module.exports = function(fn) { - // Wrap in a new function to prevent - // `cancel` potentially being assigned - // to the native rAF function - return raf.call(root, fn) -} -module.exports.cancel = function() { - caf.apply(root, arguments) -} -module.exports.polyfill = function() { - root.requestAnimationFrame = raf - root.cancelAnimationFrame = caf -} - -}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) -},{"performance-now":26}],30:[function(require,module,exports){ -module.exports = require('react/lib/shallowCompare'); -},{"react/lib/shallowCompare":81}],31:[function(require,module,exports){ -'use strict'; - -var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; - -var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); - -var _react = require('react'); - -var _react2 = _interopRequireDefault(_react); - -var _md = require('md5'); - -var _md2 = _interopRequireDefault(_md); - -var _queryString = require('query-string'); +var _queryString = require('query-string'); var _queryString2 = _interopRequireDefault(_queryString); @@ -2288,6 +2012,10 @@ var _isRetina = require('is-retina'); var _isRetina2 = _interopRequireDefault(_isRetina); +var _propTypes = require('prop-types'); + +var _propTypes2 = _interopRequireDefault(_propTypes); + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } @@ -2304,7 +2032,7 @@ var Gravatar = function (_React$Component) { function Gravatar() { _classCallCheck(this, Gravatar); - return _possibleConstructorReturn(this, Object.getPrototypeOf(Gravatar).apply(this, arguments)); + return _possibleConstructorReturn(this, (Gravatar.__proto__ || Object.getPrototypeOf(Gravatar)).apply(this, arguments)); } _createClass(Gravatar, [{ @@ -2331,7 +2059,7 @@ var Gravatar = function (_React$Component) { if (this.props.md5) { hash = this.props.md5; } else if (typeof this.props.email === 'string') { - hash = (0, _md2.default)(formattedEmail); + hash = (0, _md2.default)(formattedEmail, { encoding: "binary" }); } else { console.warn('Gravatar image can not be fetched. Either the "email" or "md5" prop must be specified.'); return _react2.default.createElement('script', null); @@ -2394,14 +2122,14 @@ var Gravatar = function (_React$Component) { Gravatar.displayName = 'Gravatar'; Gravatar.propTypes = { - email: _react2.default.PropTypes.string, - md5: _react2.default.PropTypes.string, - size: _react2.default.PropTypes.number, - rating: _react2.default.PropTypes.string, - default: _react2.default.PropTypes.string, - className: _react2.default.PropTypes.string, - protocol: _react2.default.PropTypes.string, - style: _react2.default.PropTypes.object + email: _propTypes2.default.string, + md5: _propTypes2.default.string, + size: _propTypes2.default.number, + rating: _propTypes2.default.string, + default: _propTypes2.default.string, + className: _propTypes2.default.string, + protocol: _propTypes2.default.string, + style: _propTypes2.default.object }; Gravatar.defaultProps = { size: 50, @@ -2412,690 +2140,927 @@ Gravatar.defaultProps = { module.exports = Gravatar; -},{"is-retina":22,"md5":24,"query-string":28,"react":undefined}],32:[function(require,module,exports){ -module.exports = -/******/ (function(modules) { // webpackBootstrap -/******/ // The module cache -/******/ var installedModules = {}; -/******/ -/******/ // The require function -/******/ function __webpack_require__(moduleId) { -/******/ -/******/ // Check if module is in cache -/******/ if(installedModules[moduleId]) -/******/ return installedModules[moduleId].exports; -/******/ -/******/ // Create a new module (and put it into the cache) -/******/ var module = installedModules[moduleId] = { -/******/ exports: {}, -/******/ id: moduleId, -/******/ loaded: false -/******/ }; -/******/ -/******/ // Execute the module function -/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); -/******/ -/******/ // Flag the module as loaded -/******/ module.loaded = true; -/******/ -/******/ // Return the exports of the module -/******/ return module.exports; -/******/ } -/******/ -/******/ -/******/ // expose the modules object (__webpack_modules__) -/******/ __webpack_require__.m = modules; -/******/ -/******/ // expose the module cache -/******/ __webpack_require__.c = installedModules; -/******/ -/******/ // __webpack_public_path__ -/******/ __webpack_require__.p = ""; -/******/ -/******/ // Load entry module and return exports -/******/ return __webpack_require__(0); -/******/ }) -/************************************************************************/ -/******/ ([ -/* 0 */ -/***/ function(module, exports, __webpack_require__) { - - module.exports = __webpack_require__(1); - - -/***/ }, -/* 1 */ -/***/ function(module, exports, __webpack_require__) { - - 'use strict'; - - Object.defineProperty(exports, '__esModule', { - value: true - }); - - function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } - - var _Highlighter = __webpack_require__(2); - - var _Highlighter2 = _interopRequireDefault(_Highlighter); - - var _utils = __webpack_require__(4); - - exports['default'] = _Highlighter2['default']; - exports.combineChunks = _utils.combineChunks; - exports.fillInChunks = _utils.fillInChunks; - exports.findAll = _utils.findAll; - exports.findChunks = _utils.findChunks; - -/***/ }, -/* 2 */ -/***/ function(module, exports, __webpack_require__) { +},{"is-retina":22,"md5":23,"prop-types":undefined,"query-string":27,"react":undefined}],22:[function(require,module,exports){ +module.exports = function() { + var mediaQuery; + if (typeof window !== "undefined" && window !== null) { + mediaQuery = "(-webkit-min-device-pixel-ratio: 1.25), (min--moz-device-pixel-ratio: 1.25), (-o-min-device-pixel-ratio: 5/4), (min-resolution: 1.25dppx)"; + if (window.devicePixelRatio > 1.25) { + return true; + } + if (window.matchMedia && window.matchMedia(mediaQuery).matches) { + return true; + } + } + return false; +}; - 'use strict'; - - Object.defineProperty(exports, '__esModule', { - value: true - }); - exports['default'] = Highlighter; - - function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } } - - function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } - - var _react = __webpack_require__(3); - - var _react2 = _interopRequireDefault(_react); - - var _utilsJs = __webpack_require__(4); - - var Chunks = _interopRequireWildcard(_utilsJs); - - Highlighter.propTypes = { - highlightClassName: _react.PropTypes.string, - highlightStyle: _react.PropTypes.object, - searchWords: _react.PropTypes.arrayOf(_react.PropTypes.string).isRequired, - textToHighlight: _react.PropTypes.string.isRequired, - sanitize: _react.PropTypes.func - }; - - /** - * Highlights all occurrences of search terms (searchText) within a string (textToHighlight). - * This function returns an array of strings and s (wrapping highlighted words). - */ - - function Highlighter(_ref) { - var _ref$highlightClassName = _ref.highlightClassName; - var highlightClassName = _ref$highlightClassName === undefined ? '' : _ref$highlightClassName; - var _ref$highlightStyle = _ref.highlightStyle; - var highlightStyle = _ref$highlightStyle === undefined ? {} : _ref$highlightStyle; - var searchWords = _ref.searchWords; - var textToHighlight = _ref.textToHighlight; - var sanitize = _ref.sanitize; - - var chunks = Chunks.findAll(textToHighlight, searchWords, sanitize); - - return _react2['default'].createElement( - 'span', - null, - chunks.map(function (chunk, index) { - var text = textToHighlight.substr(chunk.start, chunk.end - chunk.start); - - if (chunk.highlight) { - return _react2['default'].createElement( - 'mark', - { - className: highlightClassName, - key: index, - style: highlightStyle - }, - text - ); - } else { - return _react2['default'].createElement( - 'span', - { key: index }, - text - ); - } - }) - ); - } - - module.exports = exports['default']; +},{}],23:[function(require,module,exports){ +(function(){ + var crypt = require('crypt'), + utf8 = require('charenc').utf8, + isBuffer = require('is-buffer'), + bin = require('charenc').bin, + + // The core + md5 = function (message, options) { + // Convert to byte array + if (message.constructor == String) + if (options && options.encoding === 'binary') + message = bin.stringToBytes(message); + else + message = utf8.stringToBytes(message); + else if (isBuffer(message)) + message = Array.prototype.slice.call(message, 0); + else if (!Array.isArray(message)) + message = message.toString(); + // else, assume byte array already + + var m = crypt.bytesToWords(message), + l = message.length * 8, + a = 1732584193, + b = -271733879, + c = -1732584194, + d = 271733878; + + // Swap endian + for (var i = 0; i < m.length; i++) { + m[i] = ((m[i] << 8) | (m[i] >>> 24)) & 0x00FF00FF | + ((m[i] << 24) | (m[i] >>> 8)) & 0xFF00FF00; + } + + // Padding + m[l >>> 5] |= 0x80 << (l % 32); + m[(((l + 64) >>> 9) << 4) + 14] = l; + + // Method shortcuts + var FF = md5._ff, + GG = md5._gg, + HH = md5._hh, + II = md5._ii; + + for (var i = 0; i < m.length; i += 16) { + + var aa = a, + bb = b, + cc = c, + dd = d; + + a = FF(a, b, c, d, m[i+ 0], 7, -680876936); + d = FF(d, a, b, c, m[i+ 1], 12, -389564586); + c = FF(c, d, a, b, m[i+ 2], 17, 606105819); + b = FF(b, c, d, a, m[i+ 3], 22, -1044525330); + a = FF(a, b, c, d, m[i+ 4], 7, -176418897); + d = FF(d, a, b, c, m[i+ 5], 12, 1200080426); + c = FF(c, d, a, b, m[i+ 6], 17, -1473231341); + b = FF(b, c, d, a, m[i+ 7], 22, -45705983); + a = FF(a, b, c, d, m[i+ 8], 7, 1770035416); + d = FF(d, a, b, c, m[i+ 9], 12, -1958414417); + c = FF(c, d, a, b, m[i+10], 17, -42063); + b = FF(b, c, d, a, m[i+11], 22, -1990404162); + a = FF(a, b, c, d, m[i+12], 7, 1804603682); + d = FF(d, a, b, c, m[i+13], 12, -40341101); + c = FF(c, d, a, b, m[i+14], 17, -1502002290); + b = FF(b, c, d, a, m[i+15], 22, 1236535329); + + a = GG(a, b, c, d, m[i+ 1], 5, -165796510); + d = GG(d, a, b, c, m[i+ 6], 9, -1069501632); + c = GG(c, d, a, b, m[i+11], 14, 643717713); + b = GG(b, c, d, a, m[i+ 0], 20, -373897302); + a = GG(a, b, c, d, m[i+ 5], 5, -701558691); + d = GG(d, a, b, c, m[i+10], 9, 38016083); + c = GG(c, d, a, b, m[i+15], 14, -660478335); + b = GG(b, c, d, a, m[i+ 4], 20, -405537848); + a = GG(a, b, c, d, m[i+ 9], 5, 568446438); + d = GG(d, a, b, c, m[i+14], 9, -1019803690); + c = GG(c, d, a, b, m[i+ 3], 14, -187363961); + b = GG(b, c, d, a, m[i+ 8], 20, 1163531501); + a = GG(a, b, c, d, m[i+13], 5, -1444681467); + d = GG(d, a, b, c, m[i+ 2], 9, -51403784); + c = GG(c, d, a, b, m[i+ 7], 14, 1735328473); + b = GG(b, c, d, a, m[i+12], 20, -1926607734); + + a = HH(a, b, c, d, m[i+ 5], 4, -378558); + d = HH(d, a, b, c, m[i+ 8], 11, -2022574463); + c = HH(c, d, a, b, m[i+11], 16, 1839030562); + b = HH(b, c, d, a, m[i+14], 23, -35309556); + a = HH(a, b, c, d, m[i+ 1], 4, -1530992060); + d = HH(d, a, b, c, m[i+ 4], 11, 1272893353); + c = HH(c, d, a, b, m[i+ 7], 16, -155497632); + b = HH(b, c, d, a, m[i+10], 23, -1094730640); + a = HH(a, b, c, d, m[i+13], 4, 681279174); + d = HH(d, a, b, c, m[i+ 0], 11, -358537222); + c = HH(c, d, a, b, m[i+ 3], 16, -722521979); + b = HH(b, c, d, a, m[i+ 6], 23, 76029189); + a = HH(a, b, c, d, m[i+ 9], 4, -640364487); + d = HH(d, a, b, c, m[i+12], 11, -421815835); + c = HH(c, d, a, b, m[i+15], 16, 530742520); + b = HH(b, c, d, a, m[i+ 2], 23, -995338651); + + a = II(a, b, c, d, m[i+ 0], 6, -198630844); + d = II(d, a, b, c, m[i+ 7], 10, 1126891415); + c = II(c, d, a, b, m[i+14], 15, -1416354905); + b = II(b, c, d, a, m[i+ 5], 21, -57434055); + a = II(a, b, c, d, m[i+12], 6, 1700485571); + d = II(d, a, b, c, m[i+ 3], 10, -1894986606); + c = II(c, d, a, b, m[i+10], 15, -1051523); + b = II(b, c, d, a, m[i+ 1], 21, -2054922799); + a = II(a, b, c, d, m[i+ 8], 6, 1873313359); + d = II(d, a, b, c, m[i+15], 10, -30611744); + c = II(c, d, a, b, m[i+ 6], 15, -1560198380); + b = II(b, c, d, a, m[i+13], 21, 1309151649); + a = II(a, b, c, d, m[i+ 4], 6, -145523070); + d = II(d, a, b, c, m[i+11], 10, -1120210379); + c = II(c, d, a, b, m[i+ 2], 15, 718787259); + b = II(b, c, d, a, m[i+ 9], 21, -343485551); + + a = (a + aa) >>> 0; + b = (b + bb) >>> 0; + c = (c + cc) >>> 0; + d = (d + dd) >>> 0; + } + + return crypt.endian([a, b, c, d]); + }; + + // Auxiliary functions + md5._ff = function (a, b, c, d, x, s, t) { + var n = a + (b & c | ~b & d) + (x >>> 0) + t; + return ((n << s) | (n >>> (32 - s))) + b; + }; + md5._gg = function (a, b, c, d, x, s, t) { + var n = a + (b & d | c & ~d) + (x >>> 0) + t; + return ((n << s) | (n >>> (32 - s))) + b; + }; + md5._hh = function (a, b, c, d, x, s, t) { + var n = a + (b ^ c ^ d) + (x >>> 0) + t; + return ((n << s) | (n >>> (32 - s))) + b; + }; + md5._ii = function (a, b, c, d, x, s, t) { + var n = a + (c ^ (b | ~d)) + (x >>> 0) + t; + return ((n << s) | (n >>> (32 - s))) + b; + }; + + // Package private blocksize + md5._blocksize = 16; + md5._digestsize = 16; + + module.exports = function (message, options) { + if (message === undefined || message === null) + throw new Error('Illegal argument ' + message); + + var digestbytes = crypt.wordsToBytes(md5(message, options)); + return options && options.asBytes ? digestbytes : + options && options.asString ? bin.bytesToString(digestbytes) : + crypt.bytesToHex(digestbytes); + }; + +})(); -/***/ }, -/* 3 */ -/***/ function(module, exports) { +},{"charenc":24,"crypt":25,"is-buffer":26}],24:[function(require,module,exports){ +var charenc = { + // UTF-8 encoding + utf8: { + // Convert a string to a byte array + stringToBytes: function(str) { + return charenc.bin.stringToBytes(unescape(encodeURIComponent(str))); + }, - module.exports = require("react"); + // Convert a byte array to a string + bytesToString: function(bytes) { + return decodeURIComponent(escape(charenc.bin.bytesToString(bytes))); + } + }, -/***/ }, -/* 4 */ -/***/ function(module, exports) { + // Binary encoding + bin: { + // Convert a string to a byte array + stringToBytes: function(str) { + for (var bytes = [], i = 0; i < str.length; i++) + bytes.push(str.charCodeAt(i) & 0xFF); + return bytes; + }, - /** - * Creates an array of chunk objects representing both higlightable and non highlightable pieces of text that match each search word. - * @param searchWords string[] - * @param textToSearch string - * @return {start:number, end:number, highlight:boolean}[] - */ - 'use strict'; - - Object.defineProperty(exports, '__esModule', { - value: true - }); - var findAll = function findAll(textToSearch, wordsToFind, sanitize) { - return fillInChunks(combineChunks(findChunks(textToSearch, wordsToFind, sanitize)), textToSearch.length); - }; - - exports.findAll = findAll; - /** - * Takes an array of {start:number, end:number} objects and combines chunks that overlap into single chunks. - * @param chunks {start:number, end:number}[] - * @return {start:number, end:number}[] - */ - var combineChunks = function combineChunks(chunks) { - chunks = chunks.sort(function (first, second) { - return first.start - second.start; - }).reduce(function (processedChunks, nextChunk) { - // First chunk just goes straight in the array... - if (processedChunks.length === 0) { - return [nextChunk]; - } else { - // ... subsequent chunks get checked to see if they overlap... - var prevChunk = processedChunks.pop(); - if (nextChunk.start <= prevChunk.end) { - // It may be the case that prevChunk completely surrounds nextChunk, so take the - // largest of the end indeces. - var endIndex = Math.max(prevChunk.end, nextChunk.end); - processedChunks.push({ start: prevChunk.start, end: endIndex }); - } else { - processedChunks.push(prevChunk, nextChunk); - } - return processedChunks; - } - }, []); - - return chunks; - }; - - exports.combineChunks = combineChunks; - /** - * Examine textToSearch for any matches. - * If we find matches, add them to the returned array as a "chunk" object ({start:number, end:number}). - * @param textToSearch string - * @param wordsToFind string[] - * @param sanitize Process and optionally modify textToSearch and wordsToFind before comparison; this can be used to eg. remove accents - * @return {start:number, end:number}[] - */ - var findChunks = function findChunks(textToSearch, wordsToFind) { - var sanitize = arguments.length <= 2 || arguments[2] === undefined ? identity : arguments[2]; - return wordsToFind.filter(function (searchWord) { - return searchWord; - }) // Remove empty words - .reduce(function (chunks, searchWord) { - var normalizedWord = sanitize(searchWord); - var normalizedText = sanitize(textToSearch); - var regex = new RegExp(normalizedWord, 'gi'); - var match = undefined; - while ((match = regex.exec(normalizedText)) != null) { - chunks.push({ start: match.index, end: regex.lastIndex }); - } - return chunks; - }, []); - }; - - exports.findChunks = findChunks; - /** - * Given a set of chunks to highlight, create an additional set of chunks - * to represent the bits of text between the highlighted text. - * @param chunksToHighlight {start:number, end:number}[] - * @param totalLength number - * @return {start:number, end:number, highlight:boolean}[] - */ - var fillInChunks = function fillInChunks(chunksToHighlight, totalLength) { - var allChunks = []; - var append = function append(start, end, highlight) { - if (end - start > 0) { - allChunks.push({ start: start, end: end, highlight: highlight }); - } - }; - - if (chunksToHighlight.length === 0) { - append(0, totalLength, false); - } else { - (function () { - var lastIndex = 0; - chunksToHighlight.forEach(function (chunk) { - append(lastIndex, chunk.start, false); - append(chunk.start, chunk.end, true); - lastIndex = chunk.end; - }); - append(lastIndex, totalLength, false); - })(); - } - return allChunks; - }; - - exports.fillInChunks = fillInChunks; - function identity(value) { - return value; - } + // Convert a byte array to a string + bytesToString: function(bytes) { + for (var str = [], i = 0; i < bytes.length; i++) + str.push(String.fromCharCode(bytes[i])); + return str.join(''); + } + } +}; -/***/ } -/******/ ]); +module.exports = charenc; -},{"react":undefined}],33:[function(require,module,exports){ -'use strict'; +},{}],25:[function(require,module,exports){ +(function() { + var base64map + = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/', -Object.defineProperty(exports, "__esModule", { - value: true -}); + crypt = { + // Bit-wise rotation left + rotl: function(n, b) { + return (n << b) | (n >>> (32 - b)); + }, -var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; + // Bit-wise rotation right + rotr: function(n, b) { + return (n << (32 - b)) | (n >>> b); + }, -var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + // Swap big-endian to little-endian and vice versa + endian: function(n) { + // If number given, swap endian + if (n.constructor == Number) { + return crypt.rotl(n, 8) & 0x00FF00FF | crypt.rotl(n, 24) & 0xFF00FF00; + } -var _react = require('react'); + // Else, assume array and swap all items + for (var i = 0; i < n.length; i++) + n[i] = crypt.endian(n[i]); + return n; + }, + + // Generate an array of any length of random bytes + randomBytes: function(n) { + for (var bytes = []; n > 0; n--) + bytes.push(Math.floor(Math.random() * 256)); + return bytes; + }, + + // Convert a byte array to big-endian 32-bit words + bytesToWords: function(bytes) { + for (var words = [], i = 0, b = 0; i < bytes.length; i++, b += 8) + words[b >>> 5] |= bytes[i] << (24 - b % 32); + return words; + }, + + // Convert big-endian 32-bit words to a byte array + wordsToBytes: function(words) { + for (var bytes = [], b = 0; b < words.length * 32; b += 8) + bytes.push((words[b >>> 5] >>> (24 - b % 32)) & 0xFF); + return bytes; + }, + + // Convert a byte array to a hex string + bytesToHex: function(bytes) { + for (var hex = [], i = 0; i < bytes.length; i++) { + hex.push((bytes[i] >>> 4).toString(16)); + hex.push((bytes[i] & 0xF).toString(16)); + } + return hex.join(''); + }, + + // Convert a hex string to a byte array + hexToBytes: function(hex) { + for (var bytes = [], c = 0; c < hex.length; c += 2) + bytes.push(parseInt(hex.substr(c, 2), 16)); + return bytes; + }, + + // Convert a byte array to a base-64 string + bytesToBase64: function(bytes) { + for (var base64 = [], i = 0; i < bytes.length; i += 3) { + var triplet = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2]; + for (var j = 0; j < 4; j++) + if (i * 8 + j * 6 <= bytes.length * 8) + base64.push(base64map.charAt((triplet >>> 6 * (3 - j)) & 0x3F)); + else + base64.push('='); + } + return base64.join(''); + }, + + // Convert a base-64 string to a byte array + base64ToBytes: function(base64) { + // Remove non-base-64 characters + base64 = base64.replace(/[^A-Z0-9+\/]/ig, ''); + + for (var bytes = [], i = 0, imod4 = 0; i < base64.length; + imod4 = ++i % 4) { + if (imod4 == 0) continue; + bytes.push(((base64map.indexOf(base64.charAt(i - 1)) + & (Math.pow(2, -2 * imod4 + 8) - 1)) << (imod4 * 2)) + | (base64map.indexOf(base64.charAt(i)) >>> (6 - imod4 * 2))); + } + return bytes; + } + }; + + module.exports = crypt; +})(); + +},{}],26:[function(require,module,exports){ +/*! + * Determine if an object is a Buffer + * + * @author Feross Aboukhadijeh + * @license MIT + */ + +// The _isBuffer check is for Safari 5-7 support, because it's missing +// Object.prototype.constructor. Remove this eventually +module.exports = function (obj) { + return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer) +} -var _react2 = _interopRequireDefault(_react); +function isBuffer (obj) { + return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) +} -var _reactSelect = require('react-select'); +// For Node v0.10 support. Remove this eventually. +function isSlowBuffer (obj) { + return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0)) +} -var _reactSelect2 = _interopRequireDefault(_reactSelect); +},{}],27:[function(require,module,exports){ +'use strict'; +var strictUriEncode = require('strict-uri-encode'); +var objectAssign = require('object-assign'); -var _reactVirtualized = require('react-virtualized'); +function encoderForArrayFormat(opts) { + switch (opts.arrayFormat) { + case 'index': + return function (key, value, index) { + return value === null ? [ + encode(key, opts), + '[', + index, + ']' + ].join('') : [ + encode(key, opts), + '[', + encode(index, opts), + ']=', + encode(value, opts) + ].join(''); + }; -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + case 'bracket': + return function (key, value) { + return value === null ? encode(key, opts) : [ + encode(key, opts), + '[]=', + encode(value, opts) + ].join(''); + }; -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + default: + return function (key, value) { + return value === null ? encode(key, opts) : [ + encode(key, opts), + '=', + encode(value, opts) + ].join(''); + }; + } +} -function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } +function parserForArrayFormat(opts) { + var result; -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + switch (opts.arrayFormat) { + case 'index': + return function (key, value, accumulator) { + result = /\[(\d*)\]$/.exec(key); -var VirtualizedSelect = function (_Component) { - _inherits(VirtualizedSelect, _Component); + key = key.replace(/\[\d*\]$/, ''); - function VirtualizedSelect(props, context) { - _classCallCheck(this, VirtualizedSelect); + if (!result) { + accumulator[key] = value; + return; + } - var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(VirtualizedSelect).call(this, props, context)); + if (accumulator[key] === undefined) { + accumulator[key] = {}; + } - _this._renderMenu = _this._renderMenu.bind(_this); - _this._optionRenderer = _this._optionRenderer.bind(_this); - return _this; - } + accumulator[key][result[1]] = value; + }; - /** See VirtualScroll#recomputeRowHeights */ + case 'bracket': + return function (key, value, accumulator) { + result = /(\[\])$/.exec(key); + key = key.replace(/\[\]$/, ''); + if (!result) { + accumulator[key] = value; + return; + } else if (accumulator[key] === undefined) { + accumulator[key] = [value]; + return; + } - _createClass(VirtualizedSelect, [{ - key: 'recomputeOptionHeights', - value: function recomputeOptionHeights() { - var index = arguments.length <= 0 || arguments[0] === undefined ? 0 : arguments[0]; + accumulator[key] = [].concat(accumulator[key], value); + }; - if (this._virtualScroll) { - this._virtualScroll.recomputeRowHeights(index); - } - } - }, { - key: 'render', - value: function render() { - var SelectComponent = this._getSelectComponent(); + default: + return function (key, value, accumulator) { + if (accumulator[key] === undefined) { + accumulator[key] = value; + return; + } - return _react2.default.createElement(SelectComponent, _extends({}, this.props, { - menuRenderer: this._renderMenu, - menuStyle: { overflow: 'hidden' } - })); - } + accumulator[key] = [].concat(accumulator[key], value); + }; + } +} - // See https://github.com/JedWatson/react-select/#effeciently-rendering-large-lists-with-windowing +function encode(value, opts) { + if (opts.encode) { + return opts.strict ? strictUriEncode(value) : encodeURIComponent(value); + } - }, { - key: '_renderMenu', - value: function _renderMenu(_ref) { - var _this2 = this; + return value; +} - var focusedOption = _ref.focusedOption; - var focusOption = _ref.focusOption; - var labelKey = _ref.labelKey; - var options = _ref.options; - var selectValue = _ref.selectValue; - var valueArray = _ref.valueArray; - var optionRenderer = this.props.optionRenderer; +function keysSorter(input) { + if (Array.isArray(input)) { + return input.sort(); + } else if (typeof input === 'object') { + return keysSorter(Object.keys(input)).sort(function (a, b) { + return Number(a) - Number(b); + }).map(function (key) { + return input[key]; + }); + } - var focusedOptionIndex = options.indexOf(focusedOption); - var height = this._calculateVirtualScrollHeight({ options: options }); - var innerRowRenderer = optionRenderer || this._optionRenderer; + return input; +} - function wrappedRowRenderer(_ref2) { - var index = _ref2.index; +exports.extract = function (str) { + return str.split('?')[1] || ''; +}; - var option = options[index]; +exports.parse = function (str, opts) { + opts = objectAssign({arrayFormat: 'none'}, opts); - return innerRowRenderer({ - focusedOption: focusedOption, - focusedOptionIndex: focusedOptionIndex, - focusOption: focusOption, - labelKey: labelKey, - option: option, - optionIndex: index, - options: options, - selectValue: selectValue, - valueArray: valueArray - }); - } + var formatter = parserForArrayFormat(opts); - return _react2.default.createElement( - _reactVirtualized.AutoSizer, - { disableHeight: true }, - function (_ref3) { - var width = _ref3.width; - return _react2.default.createElement(_reactVirtualized.VirtualScroll, { - className: 'VirtualSelectGrid', - height: height, - ref: function ref(_ref5) { - return _this2._virtualScroll = _ref5; - }, - rowCount: options.length, - rowHeight: function rowHeight(_ref4) { - var index = _ref4.index; - return _this2._getOptionHeight({ - option: options[index] - }); - }, - rowRenderer: wrappedRowRenderer, - scrollToIndex: focusedOptionIndex, - width: width - }); - } - ); - } - }, { - key: '_calculateVirtualScrollHeight', - value: function _calculateVirtualScrollHeight(_ref6) { - var options = _ref6.options; - var maxHeight = this.props.maxHeight; + // Create an object with no prototype + // https://github.com/sindresorhus/query-string/issues/47 + var ret = Object.create(null); + if (typeof str !== 'string') { + return ret; + } - var height = 0; + str = str.trim().replace(/^(\?|#|&)/, ''); - for (var optionIndex = 0; optionIndex < options.length; optionIndex++) { - var option = options[optionIndex]; + if (!str) { + return ret; + } - height += this._getOptionHeight({ option: option }); + str.split('&').forEach(function (param) { + var parts = param.replace(/\+/g, ' ').split('='); + // Firefox (pre 40) decodes `%3D` to `=` + // https://github.com/sindresorhus/query-string/pull/37 + var key = parts.shift(); + var val = parts.length > 0 ? parts.join('=') : undefined; - if (height > maxHeight) { - return maxHeight; - } - } + // missing `=` should be `null`: + // http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters + val = val === undefined ? null : decodeURIComponent(val); - return height; - } - }, { - key: '_getOptionHeight', - value: function _getOptionHeight(_ref7) { - var option = _ref7.option; - var optionHeight = this.props.optionHeight; + formatter(decodeURIComponent(key), val, ret); + }); + return Object.keys(ret).sort().reduce(function (result, key) { + var val = ret[key]; + if (Boolean(val) && typeof val === 'object' && !Array.isArray(val)) { + // Sort object keys, not values + result[key] = keysSorter(val); + } else { + result[key] = val; + } - return optionHeight instanceof Function ? optionHeight({ option: option }) : optionHeight; - } - }, { - key: '_getSelectComponent', - value: function _getSelectComponent() { - var _props = this.props; - var async = _props.async; - var selectComponent = _props.selectComponent; + return result; + }, Object.create(null)); +}; +exports.stringify = function (obj, opts) { + var defaults = { + encode: true, + strict: true, + arrayFormat: 'none' + }; - if (selectComponent) { - return selectComponent; - } else if (async) { - return _reactSelect2.default.Async; - } else { - return _reactSelect2.default; - } - } - }, { - key: '_optionRenderer', - value: function _optionRenderer(_ref8) { - var focusedOption = _ref8.focusedOption; - var focusOption = _ref8.focusOption; - var labelKey = _ref8.labelKey; - var option = _ref8.option; - var selectValue = _ref8.selectValue; + opts = objectAssign(defaults, opts); - var height = this._getOptionHeight({ option: option }); + var formatter = encoderForArrayFormat(opts); - var className = ['VirtualizedSelectOption']; + return obj ? Object.keys(obj).sort().map(function (key) { + var val = obj[key]; - if (option === focusedOption) { - className.push('VirtualizedSelectFocusedOption'); - } + if (val === undefined) { + return ''; + } - if (option.disabled) { - className.push('VirtualizedSelectDisabledOption'); - } + if (val === null) { + return encode(key, opts); + } - var events = option.disabled ? {} : { - onClick: function onClick() { - return selectValue(option); - }, - onMouseOver: function onMouseOver() { - return focusOption(option); - } - }; + if (Array.isArray(val)) { + var result = []; - return _react2.default.createElement( - 'div', - _extends({ - className: className.join(' '), - style: { height: height } - }, events), - option[labelKey] - ); - } - }]); + val.slice().forEach(function (val2) { + if (val2 === undefined) { + return; + } - return VirtualizedSelect; -}(_react.Component); + result.push(formatter(key, val2, result.length)); + }); -VirtualizedSelect.propTypes = { - async: _react.PropTypes.bool, - maxHeight: _react.PropTypes.number.isRequired, - optionHeight: _react.PropTypes.oneOfType([_react.PropTypes.number, _react.PropTypes.func]).isRequired, - optionRenderer: _react.PropTypes.func, - selectComponent: _react.PropTypes.func -}; -VirtualizedSelect.defaultProps = { - async: false, - maxHeight: 200, - optionHeight: 35 -}; -exports.default = VirtualizedSelect; -},{"react":undefined,"react-select":undefined,"react-virtualized":77}],34:[function(require,module,exports){ -'use strict'; + return result.join('&'); + } -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = undefined; + return encode(key, opts) + '=' + encode(val, opts); + }).filter(function (x) { + return x.length > 0; + }).join('&') : ''; +}; -var _VirtualizedSelect = require('./VirtualizedSelect'); +},{"object-assign":28,"strict-uri-encode":29}],28:[function(require,module,exports){ +/* +object-assign +(c) Sindre Sorhus +@license MIT +*/ -var _VirtualizedSelect2 = _interopRequireDefault(_VirtualizedSelect); +'use strict'; +/* eslint-disable no-unused-vars */ +var getOwnPropertySymbols = Object.getOwnPropertySymbols; +var hasOwnProperty = Object.prototype.hasOwnProperty; +var propIsEnumerable = Object.prototype.propertyIsEnumerable; -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } +function toObject(val) { + if (val === null || val === undefined) { + throw new TypeError('Object.assign cannot be called with null or undefined'); + } -exports.default = _VirtualizedSelect2.default; -},{"./VirtualizedSelect":33}],35:[function(require,module,exports){ -arguments[4][34][0].apply(exports,arguments) -},{"./VirtualizedSelect":34,"dup":34}],36:[function(require,module,exports){ -'use strict'; + return Object(val); +} -Object.defineProperty(exports, "__esModule", { - value: true -}); +function shouldUseNative() { + try { + if (!Object.assign) { + return false; + } -var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + // Detect buggy property enumeration order in older V8 versions. -var _react = require('react'); + // https://bugs.chromium.org/p/v8/issues/detail?id=4118 + var test1 = new String('abc'); // eslint-disable-line no-new-wrappers + test1[5] = 'de'; + if (Object.getOwnPropertyNames(test1)[0] === '5') { + return false; + } -var _react2 = _interopRequireDefault(_react); + // https://bugs.chromium.org/p/v8/issues/detail?id=3056 + var test2 = {}; + for (var i = 0; i < 10; i++) { + test2['_' + String.fromCharCode(i)] = i; + } + var order2 = Object.getOwnPropertyNames(test2).map(function (n) { + return test2[n]; + }); + if (order2.join('') !== '0123456789') { + return false; + } -var _reactAddonsShallowCompare = require('react-addons-shallow-compare'); + // https://bugs.chromium.org/p/v8/issues/detail?id=3056 + var test3 = {}; + 'abcdefghijklmnopqrst'.split('').forEach(function (letter) { + test3[letter] = letter; + }); + if (Object.keys(Object.assign({}, test3)).join('') !== + 'abcdefghijklmnopqrst') { + return false; + } -var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); + return true; + } catch (err) { + // We don't expect any of the above to throw, but better to be safe. + return false; + } +} -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } +module.exports = shouldUseNative() ? Object.assign : function (target, source) { + var from; + var to = toObject(target); + var symbols; -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + for (var s = 1; s < arguments.length; s++) { + from = Object(arguments[s]); -function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + for (var key in from) { + if (hasOwnProperty.call(from, key)) { + to[key] = from[key]; + } + } -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + if (getOwnPropertySymbols) { + symbols = getOwnPropertySymbols(from); + for (var i = 0; i < symbols.length; i++) { + if (propIsEnumerable.call(from, symbols[i])) { + to[symbols[i]] = from[symbols[i]]; + } + } + } + } -/** - * This HOC decorates a virtualized component and responds to arrow-key events by scrolling one row or column at a time. - */ -var ArrowKeyStepper = function (_Component) { - _inherits(ArrowKeyStepper, _Component); + return to; +}; - function ArrowKeyStepper(props, context) { - _classCallCheck(this, ArrowKeyStepper); +},{}],29:[function(require,module,exports){ +'use strict'; +module.exports = function (str) { + return encodeURIComponent(str).replace(/[!'()*]/g, function (c) { + return '%' + c.charCodeAt(0).toString(16).toUpperCase(); + }); +}; - var _this = _possibleConstructorReturn(this, (ArrowKeyStepper.__proto__ || Object.getPrototypeOf(ArrowKeyStepper)).call(this, props, context)); +},{}],30:[function(require,module,exports){ +module.exports = +/******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) +/******/ return installedModules[moduleId].exports; +/******/ +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ exports: {}, +/******/ id: moduleId, +/******/ loaded: false +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.loaded = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(0); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ function(module, exports, __webpack_require__) { - _this.state = { - scrollToColumn: 0, - scrollToRow: 0 - }; + module.exports = __webpack_require__(1); - _this._columnStartIndex = 0; - _this._columnStopIndex = 0; - _this._rowStartIndex = 0; - _this._rowStopIndex = 0; - _this._onKeyDown = _this._onKeyDown.bind(_this); - _this._onSectionRendered = _this._onSectionRendered.bind(_this); - return _this; - } +/***/ }, +/* 1 */ +/***/ function(module, exports, __webpack_require__) { - _createClass(ArrowKeyStepper, [{ - key: 'render', - value: function render() { - var _props = this.props; - var className = _props.className; - var children = _props.children; - var _state = this.state; - var scrollToColumn = _state.scrollToColumn; - var scrollToRow = _state.scrollToRow; + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _Highlighter = __webpack_require__(2); + + var _Highlighter2 = _interopRequireDefault(_Highlighter); + + var _utils = __webpack_require__(4); + + exports['default'] = _Highlighter2['default']; + exports.combineChunks = _utils.combineChunks; + exports.fillInChunks = _utils.fillInChunks; + exports.findAll = _utils.findAll; + exports.findChunks = _utils.findChunks; +/***/ }, +/* 2 */ +/***/ function(module, exports, __webpack_require__) { - return _react2.default.createElement( - 'div', - { - className: className, - onKeyDown: this._onKeyDown - }, - children({ - onSectionRendered: this._onSectionRendered, - scrollToColumn: scrollToColumn, - scrollToRow: scrollToRow - }) - ); - } - }, { - key: 'shouldComponentUpdate', - value: function shouldComponentUpdate(nextProps, nextState) { - return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState); - } - }, { - key: '_onKeyDown', - value: function _onKeyDown(event) { - var _props2 = this.props; - var columnCount = _props2.columnCount; - var rowCount = _props2.rowCount; + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + exports['default'] = Highlighter; + + function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } } + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _react = __webpack_require__(3); + + var _react2 = _interopRequireDefault(_react); + + var _utilsJs = __webpack_require__(4); + + var Chunks = _interopRequireWildcard(_utilsJs); + + Highlighter.propTypes = { + highlightClassName: _react.PropTypes.string, + highlightStyle: _react.PropTypes.object, + searchWords: _react.PropTypes.arrayOf(_react.PropTypes.string).isRequired, + textToHighlight: _react.PropTypes.string.isRequired, + sanitize: _react.PropTypes.func + }; + + /** + * Highlights all occurrences of search terms (searchText) within a string (textToHighlight). + * This function returns an array of strings and s (wrapping highlighted words). + */ + + function Highlighter(_ref) { + var _ref$highlightClassName = _ref.highlightClassName; + var highlightClassName = _ref$highlightClassName === undefined ? '' : _ref$highlightClassName; + var _ref$highlightStyle = _ref.highlightStyle; + var highlightStyle = _ref$highlightStyle === undefined ? {} : _ref$highlightStyle; + var searchWords = _ref.searchWords; + var textToHighlight = _ref.textToHighlight; + var sanitize = _ref.sanitize; + + var chunks = Chunks.findAll(textToHighlight, searchWords, sanitize); + + return _react2['default'].createElement( + 'span', + null, + chunks.map(function (chunk, index) { + var text = textToHighlight.substr(chunk.start, chunk.end - chunk.start); + + if (chunk.highlight) { + return _react2['default'].createElement( + 'mark', + { + className: highlightClassName, + key: index, + style: highlightStyle + }, + text + ); + } else { + return _react2['default'].createElement( + 'span', + { key: index }, + text + ); + } + }) + ); + } + + module.exports = exports['default']; - // The above cases all prevent default event event behavior. - // This is to keep the grid from scrolling after the snap-to update. +/***/ }, +/* 3 */ +/***/ function(module, exports) { - switch (event.key) { - case 'ArrowDown': - event.preventDefault(); - this.setState({ - scrollToRow: Math.min(this._rowStopIndex + 1, rowCount - 1) - }); - break; - case 'ArrowLeft': - event.preventDefault(); - this.setState({ - scrollToColumn: Math.max(this._columnStartIndex - 1, 0) - }); - break; - case 'ArrowRight': - event.preventDefault(); - this.setState({ - scrollToColumn: Math.min(this._columnStopIndex + 1, columnCount - 1) - }); - break; - case 'ArrowUp': - event.preventDefault(); - this.setState({ - scrollToRow: Math.max(this._rowStartIndex - 1, 0) - }); - break; - } - } - }, { - key: '_onSectionRendered', - value: function _onSectionRendered(_ref) { - var columnStartIndex = _ref.columnStartIndex; - var columnStopIndex = _ref.columnStopIndex; - var rowStartIndex = _ref.rowStartIndex; - var rowStopIndex = _ref.rowStopIndex; + module.exports = require("react"); - this._columnStartIndex = columnStartIndex; - this._columnStopIndex = columnStopIndex; - this._rowStartIndex = rowStartIndex; - this._rowStopIndex = rowStopIndex; - } - }]); +/***/ }, +/* 4 */ +/***/ function(module, exports) { + + /** + * Creates an array of chunk objects representing both higlightable and non highlightable pieces of text that match each search word. + * @param searchWords string[] + * @param textToSearch string + * @return {start:number, end:number, highlight:boolean}[] + */ + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + var findAll = function findAll(textToSearch, wordsToFind, sanitize) { + return fillInChunks(combineChunks(findChunks(textToSearch, wordsToFind, sanitize)), textToSearch.length); + }; + + exports.findAll = findAll; + /** + * Takes an array of {start:number, end:number} objects and combines chunks that overlap into single chunks. + * @param chunks {start:number, end:number}[] + * @return {start:number, end:number}[] + */ + var combineChunks = function combineChunks(chunks) { + chunks = chunks.sort(function (first, second) { + return first.start - second.start; + }).reduce(function (processedChunks, nextChunk) { + // First chunk just goes straight in the array... + if (processedChunks.length === 0) { + return [nextChunk]; + } else { + // ... subsequent chunks get checked to see if they overlap... + var prevChunk = processedChunks.pop(); + if (nextChunk.start <= prevChunk.end) { + // It may be the case that prevChunk completely surrounds nextChunk, so take the + // largest of the end indeces. + var endIndex = Math.max(prevChunk.end, nextChunk.end); + processedChunks.push({ start: prevChunk.start, end: endIndex }); + } else { + processedChunks.push(prevChunk, nextChunk); + } + return processedChunks; + } + }, []); + + return chunks; + }; + + exports.combineChunks = combineChunks; + /** + * Examine textToSearch for any matches. + * If we find matches, add them to the returned array as a "chunk" object ({start:number, end:number}). + * @param textToSearch string + * @param wordsToFind string[] + * @param sanitize Process and optionally modify textToSearch and wordsToFind before comparison; this can be used to eg. remove accents + * @return {start:number, end:number}[] + */ + var findChunks = function findChunks(textToSearch, wordsToFind) { + var sanitize = arguments.length <= 2 || arguments[2] === undefined ? identity : arguments[2]; + return wordsToFind.filter(function (searchWord) { + return searchWord; + }) // Remove empty words + .reduce(function (chunks, searchWord) { + var normalizedWord = sanitize(searchWord); + var normalizedText = sanitize(textToSearch); + var regex = new RegExp(normalizedWord, 'gi'); + var match = undefined; + while ((match = regex.exec(normalizedText)) != null) { + chunks.push({ start: match.index, end: regex.lastIndex }); + } + return chunks; + }, []); + }; + + exports.findChunks = findChunks; + /** + * Given a set of chunks to highlight, create an additional set of chunks + * to represent the bits of text between the highlighted text. + * @param chunksToHighlight {start:number, end:number}[] + * @param totalLength number + * @return {start:number, end:number, highlight:boolean}[] + */ + var fillInChunks = function fillInChunks(chunksToHighlight, totalLength) { + var allChunks = []; + var append = function append(start, end, highlight) { + if (end - start > 0) { + allChunks.push({ start: start, end: end, highlight: highlight }); + } + }; + + if (chunksToHighlight.length === 0) { + append(0, totalLength, false); + } else { + (function () { + var lastIndex = 0; + chunksToHighlight.forEach(function (chunk) { + append(lastIndex, chunk.start, false); + append(chunk.start, chunk.end, true); + lastIndex = chunk.end; + }); + append(lastIndex, totalLength, false); + })(); + } + return allChunks; + }; + + exports.fillInChunks = fillInChunks; + function identity(value) { + return value; + } - return ArrowKeyStepper; -}(_react.Component); +/***/ } +/******/ ]); -ArrowKeyStepper.propTypes = { - children: _react.PropTypes.func.isRequired, - className: _react.PropTypes.string, - columnCount: _react.PropTypes.number.isRequired, - rowCount: _react.PropTypes.number.isRequired -}; -exports.default = ArrowKeyStepper; -},{"react":undefined,"react-addons-shallow-compare":30}],37:[function(require,module,exports){ +},{"react":undefined}],31:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); -exports.ArrowKeyStepper = exports.default = undefined; - -var _ArrowKeyStepper2 = require('./ArrowKeyStepper'); - -var _ArrowKeyStepper3 = _interopRequireDefault(_ArrowKeyStepper2); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -exports.default = _ArrowKeyStepper3.default; -exports.ArrowKeyStepper = _ArrowKeyStepper3.default; -},{"./ArrowKeyStepper":36}],38:[function(require,module,exports){ -'use strict'; -Object.defineProperty(exports, "__esModule", { - value: true -}); +var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); @@ -3103,9 +3068,11 @@ var _react = require('react'); var _react2 = _interopRequireDefault(_react); -var _reactAddonsShallowCompare = require('react-addons-shallow-compare'); +var _reactSelect = require('react-select'); -var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); +var _reactSelect2 = _interopRequireDefault(_reactSelect); + +var _reactVirtualized = require('react-virtualized'); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -3115,172 +3082,225 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -/** - * Decorator component that automatically adjusts the width and height of a single child. - * Child component should not be declared as a child but should rather be specified by a `ChildComponent` property. - * All other properties will be passed through to the child component. - */ -var AutoSizer = function (_Component) { - _inherits(AutoSizer, _Component); - - function AutoSizer(props) { - _classCallCheck(this, AutoSizer); +var VirtualizedSelect = function (_Component) { + _inherits(VirtualizedSelect, _Component); - var _this = _possibleConstructorReturn(this, (AutoSizer.__proto__ || Object.getPrototypeOf(AutoSizer)).call(this, props)); + function VirtualizedSelect(props, context) { + _classCallCheck(this, VirtualizedSelect); - _this.state = { - height: 0, - width: 0 - }; + var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(VirtualizedSelect).call(this, props, context)); - _this._onResize = _this._onResize.bind(_this); - _this._onScroll = _this._onScroll.bind(_this); - _this._setRef = _this._setRef.bind(_this); + _this._renderMenu = _this._renderMenu.bind(_this); + _this._optionRenderer = _this._optionRenderer.bind(_this); return _this; } - _createClass(AutoSizer, [{ - key: 'componentDidMount', - value: function componentDidMount() { - // Delay access of parentNode until mount. - // This handles edge-cases where the component has already been unmounted before its ref has been set, - // As well as libraries like react-lite which have a slightly different lifecycle. - this._parentNode = this._autoSizer.parentNode; + /** See VirtualScroll#recomputeRowHeights */ - // Defer requiring resize handler in order to support server-side rendering. - // See issue #41 - this._detectElementResize = require('../vendor/detectElementResize'); - this._detectElementResize.addResizeListener(this._parentNode, this._onResize); - this._onResize(); - } - }, { - key: 'componentWillUnmount', - value: function componentWillUnmount() { - if (this._detectElementResize) { - this._detectElementResize.removeResizeListener(this._parentNode, this._onResize); + _createClass(VirtualizedSelect, [{ + key: 'recomputeOptionHeights', + value: function recomputeOptionHeights() { + var index = arguments.length <= 0 || arguments[0] === undefined ? 0 : arguments[0]; + + if (this._virtualScroll) { + this._virtualScroll.recomputeRowHeights(index); } } }, { key: 'render', value: function render() { - var _props = this.props; - var children = _props.children; - var disableHeight = _props.disableHeight; - var disableWidth = _props.disableWidth; - var _state = this.state; - var height = _state.height; - var width = _state.width; + var SelectComponent = this._getSelectComponent(); - // Outer div should not force width/height since that may prevent containers from shrinking. - // Inner component should overflow and use calculated width/height. - // See issue #68 for more information. + return _react2.default.createElement(SelectComponent, _extends({}, this.props, { + menuRenderer: this._renderMenu, + menuStyle: { overflow: 'hidden' } + })); + } - var outerStyle = { overflow: 'visible' }; + // See https://github.com/JedWatson/react-select/#effeciently-rendering-large-lists-with-windowing - if (!disableHeight) { - outerStyle.height = 0; - } + }, { + key: '_renderMenu', + value: function _renderMenu(_ref) { + var _this2 = this; - if (!disableWidth) { - outerStyle.width = 0; + var focusedOption = _ref.focusedOption; + var focusOption = _ref.focusOption; + var labelKey = _ref.labelKey; + var options = _ref.options; + var selectValue = _ref.selectValue; + var valueArray = _ref.valueArray; + var optionRenderer = this.props.optionRenderer; + + var focusedOptionIndex = options.indexOf(focusedOption); + var height = this._calculateVirtualScrollHeight({ options: options }); + var innerRowRenderer = optionRenderer || this._optionRenderer; + + function wrappedRowRenderer(_ref2) { + var index = _ref2.index; + + var option = options[index]; + + return innerRowRenderer({ + focusedOption: focusedOption, + focusedOptionIndex: focusedOptionIndex, + focusOption: focusOption, + labelKey: labelKey, + option: option, + optionIndex: index, + options: options, + selectValue: selectValue, + valueArray: valueArray + }); } return _react2.default.createElement( - 'div', - { - ref: this._setRef, - onScroll: this._onScroll, - style: outerStyle - }, - children({ height: height, width: width }) + _reactVirtualized.AutoSizer, + { disableHeight: true }, + function (_ref3) { + var width = _ref3.width; + return _react2.default.createElement(_reactVirtualized.VirtualScroll, { + className: 'VirtualSelectGrid', + height: height, + ref: function ref(_ref5) { + return _this2._virtualScroll = _ref5; + }, + rowCount: options.length, + rowHeight: function rowHeight(_ref4) { + var index = _ref4.index; + return _this2._getOptionHeight({ + option: options[index] + }); + }, + rowRenderer: wrappedRowRenderer, + scrollToIndex: focusedOptionIndex, + width: width + }); + } ); } }, { - key: 'shouldComponentUpdate', - value: function shouldComponentUpdate(nextProps, nextState) { - return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState); + key: '_calculateVirtualScrollHeight', + value: function _calculateVirtualScrollHeight(_ref6) { + var options = _ref6.options; + var maxHeight = this.props.maxHeight; + + + var height = 0; + + for (var optionIndex = 0; optionIndex < options.length; optionIndex++) { + var option = options[optionIndex]; + + height += this._getOptionHeight({ option: option }); + + if (height > maxHeight) { + return maxHeight; + } + } + + return height; } }, { - key: '_onResize', - value: function _onResize() { - var onResize = this.props.onResize; + key: '_getOptionHeight', + value: function _getOptionHeight(_ref7) { + var option = _ref7.option; + var optionHeight = this.props.optionHeight; + + + return optionHeight instanceof Function ? optionHeight({ option: option }) : optionHeight; + } + }, { + key: '_getSelectComponent', + value: function _getSelectComponent() { + var _props = this.props; + var async = _props.async; + var selectComponent = _props.selectComponent; + + + if (selectComponent) { + return selectComponent; + } else if (async) { + return _reactSelect2.default.Async; + } else { + return _reactSelect2.default; + } + } + }, { + key: '_optionRenderer', + value: function _optionRenderer(_ref8) { + var focusedOption = _ref8.focusedOption; + var focusOption = _ref8.focusOption; + var labelKey = _ref8.labelKey; + var option = _ref8.option; + var selectValue = _ref8.selectValue; - // Gaurd against AutoSizer component being removed from the DOM immediately after being added. - // This can result in invalid style values which can result in NaN values if we don't handle them. - // See issue #150 for more context. + var height = this._getOptionHeight({ option: option }); - var boundingRect = this._parentNode.getBoundingClientRect(); - var height = boundingRect.height || 0; - var width = boundingRect.width || 0; + var className = ['VirtualizedSelectOption']; - var style = getComputedStyle(this._parentNode); - var paddingLeft = parseInt(style.paddingLeft, 10) || 0; - var paddingRight = parseInt(style.paddingRight, 10) || 0; - var paddingTop = parseInt(style.paddingTop, 10) || 0; - var paddingBottom = parseInt(style.paddingBottom, 10) || 0; + if (option === focusedOption) { + className.push('VirtualizedSelectFocusedOption'); + } - this.setState({ - height: height - paddingTop - paddingBottom, - width: width - paddingLeft - paddingRight - }); + if (option.disabled) { + className.push('VirtualizedSelectDisabledOption'); + } - onResize({ height: height, width: width }); - } - }, { - key: '_onScroll', - value: function _onScroll(event) { - // Prevent detectElementResize library from being triggered by this scroll event. - event.stopPropagation(); - } - }, { - key: '_setRef', - value: function _setRef(autoSizer) { - this._autoSizer = autoSizer; + var events = option.disabled ? {} : { + onClick: function onClick() { + return selectValue(option); + }, + onMouseOver: function onMouseOver() { + return focusOption(option); + } + }; + + return _react2.default.createElement( + 'div', + _extends({ + className: className.join(' '), + style: { height: height } + }, events), + option[labelKey] + ); } }]); - return AutoSizer; + return VirtualizedSelect; }(_react.Component); -AutoSizer.propTypes = { - /** - * Function respondible for rendering children. - * This function should implement the following signature: - * ({ height, width }) => PropTypes.element - */ - children: _react.PropTypes.func.isRequired, - - /** Disable dynamic :height property */ - disableHeight: _react.PropTypes.bool, - - /** Disable dynamic :width property */ - disableWidth: _react.PropTypes.bool, - - /** Callback to be invoked on-resize: ({ height, width }) */ - onResize: _react.PropTypes.func.isRequired +VirtualizedSelect.propTypes = { + async: _react.PropTypes.bool, + maxHeight: _react.PropTypes.number.isRequired, + optionHeight: _react.PropTypes.oneOfType([_react.PropTypes.number, _react.PropTypes.func]).isRequired, + optionRenderer: _react.PropTypes.func, + selectComponent: _react.PropTypes.func }; -AutoSizer.defaultProps = { - onResize: function onResize() {} +VirtualizedSelect.defaultProps = { + async: false, + maxHeight: 200, + optionHeight: 35 }; -exports.default = AutoSizer; -},{"../vendor/detectElementResize":80,"react":undefined,"react-addons-shallow-compare":30}],39:[function(require,module,exports){ +exports.default = VirtualizedSelect; +},{"react":undefined,"react-select":undefined,"react-virtualized":75}],32:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); -exports.AutoSizer = exports.default = undefined; +exports.default = undefined; -var _AutoSizer2 = require('./AutoSizer'); +var _VirtualizedSelect = require('./VirtualizedSelect'); -var _AutoSizer3 = _interopRequireDefault(_AutoSizer2); +var _VirtualizedSelect2 = _interopRequireDefault(_VirtualizedSelect); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } -exports.default = _AutoSizer3.default; -exports.AutoSizer = _AutoSizer3.default; -},{"./AutoSizer":38}],40:[function(require,module,exports){ +exports.default = _VirtualizedSelect2.default; +},{"./VirtualizedSelect":31}],33:[function(require,module,exports){ +arguments[4][32][0].apply(exports,arguments) +},{"./VirtualizedSelect":32,"dup":32}],34:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { @@ -3297,305 +3317,149 @@ var _reactAddonsShallowCompare = require('react-addons-shallow-compare'); var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); -var _reactDom = require('react-dom'); - -var _reactDom2 = _interopRequireDefault(_reactDom); - -var _defaultCellSizeCache = require('./defaultCellSizeCache'); - -var _defaultCellSizeCache2 = _interopRequireDefault(_defaultCellSizeCache); - function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } - -/** - * Measures a Grid cell's contents by rendering them in a way that is not visible to the user. - * Either a fixed width or height may be provided if it is desirable to measure only in one direction. - */ -var CellMeasurer = function (_Component) { - _inherits(CellMeasurer, _Component); - - function CellMeasurer(props, state) { - _classCallCheck(this, CellMeasurer); - - var _this = _possibleConstructorReturn(this, (CellMeasurer.__proto__ || Object.getPrototypeOf(CellMeasurer)).call(this, props, state)); - - _this._cellSizeCache = props.cellSizeCache || new _defaultCellSizeCache2.default(); - - _this.getColumnWidth = _this.getColumnWidth.bind(_this); - _this.getRowHeight = _this.getRowHeight.bind(_this); - _this.resetMeasurements = _this.resetMeasurements.bind(_this); - _this.resetMeasurementForColumn = _this.resetMeasurementForColumn.bind(_this); - _this.resetMeasurementForRow = _this.resetMeasurementForRow.bind(_this); - return _this; - } - - _createClass(CellMeasurer, [{ - key: 'getColumnWidth', - value: function getColumnWidth(_ref) { - var index = _ref.index; - - if (this._cellSizeCache.hasColumnWidth(index)) { - return this._cellSizeCache.getColumnWidth(index); - } - - var rowCount = this.props.rowCount; - - - var maxWidth = 0; - - for (var rowIndex = 0; rowIndex < rowCount; rowIndex++) { - var _measureCell2 = this._measureCell({ - clientWidth: true, - columnIndex: index, - rowIndex: rowIndex - }); - - var width = _measureCell2.width; - - - maxWidth = Math.max(maxWidth, width); - } - - this._cellSizeCache.setColumnWidth(index, maxWidth); - - return maxWidth; - } - }, { - key: 'getRowHeight', - value: function getRowHeight(_ref2) { - var index = _ref2.index; - - if (this._cellSizeCache.hasRowHeight(index)) { - return this._cellSizeCache.getRowHeight(index); - } - - var columnCount = this.props.columnCount; - - - var maxHeight = 0; - - for (var columnIndex = 0; columnIndex < columnCount; columnIndex++) { - var _measureCell3 = this._measureCell({ - clientHeight: true, - columnIndex: columnIndex, - rowIndex: index - }); - - var height = _measureCell3.height; - - - maxHeight = Math.max(maxHeight, height); - } - - this._cellSizeCache.setRowHeight(index, maxHeight); - - return maxHeight; - } - }, { - key: 'resetMeasurementForColumn', - value: function resetMeasurementForColumn(columnIndex) { - this._cellSizeCache.clearColumnWidth(columnIndex); - } - }, { - key: 'resetMeasurementForRow', - value: function resetMeasurementForRow(rowIndex) { - this._cellSizeCache.clearRowHeight(rowIndex); - } - }, { - key: 'resetMeasurements', - value: function resetMeasurements() { - this._cellSizeCache.clearAllColumnWidths(); - this._cellSizeCache.clearAllRowHeights(); - } - }, { - key: 'componentDidMount', - value: function componentDidMount() { - this._renderAndMount(); - } - }, { - key: 'componentWillReceiveProps', - value: function componentWillReceiveProps(nextProps) { - var cellSizeCache = this.props.cellSizeCache; - - - if (cellSizeCache !== nextProps.cellSizeCache) { - this._cellSizeCache = nextProps.cellSizeCache; - } - - this._updateDivDimensions(nextProps); - } - }, { - key: 'componentWillUnmount', - value: function componentWillUnmount() { - this._unmountContainer(); - } - }, { - key: 'render', - value: function render() { - var children = this.props.children; - - - return children({ - getColumnWidth: this.getColumnWidth, - getRowHeight: this.getRowHeight, - resetMeasurements: this.resetMeasurements, - resetMeasurementForColumn: this.resetMeasurementForColumn, - resetMeasurementForRow: this.resetMeasurementForRow - }); - } - }, { - key: 'shouldComponentUpdate', - value: function shouldComponentUpdate(nextProps, nextState) { - return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState); - } - }, { - key: '_getContainerNode', - value: function _getContainerNode(props) { - var container = props.container; - +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - if (container) { - return _reactDom2.default.findDOMNode(typeof container === 'function' ? container() : container); - } else { - return document.body; - } - } - }, { - key: '_measureCell', - value: function _measureCell(_ref3) { - var _ref3$clientHeight = _ref3.clientHeight; - var clientHeight = _ref3$clientHeight === undefined ? false : _ref3$clientHeight; - var _ref3$clientWidth = _ref3.clientWidth; - var clientWidth = _ref3$clientWidth === undefined ? true : _ref3$clientWidth; - var columnIndex = _ref3.columnIndex; - var rowIndex = _ref3.rowIndex; - var cellRenderer = this.props.cellRenderer; +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } - var rendered = cellRenderer({ - columnIndex: columnIndex, - rowIndex: rowIndex - }); +/** + * This HOC decorates a virtualized component and responds to arrow-key events by scrolling one row or column at a time. + */ +var ArrowKeyStepper = function (_Component) { + _inherits(ArrowKeyStepper, _Component); - // Handle edge case where this method is called before the CellMeasurer has completed its initial render (and mounted). - this._renderAndMount(); + function ArrowKeyStepper(props, context) { + _classCallCheck(this, ArrowKeyStepper); - // @TODO Keep an eye on this for future React updates as the interface may change: - // https://twitter.com/soprano/status/737316379712331776 - _reactDom2.default.unstable_renderSubtreeIntoContainer(this, rendered, this._div); + var _this = _possibleConstructorReturn(this, (ArrowKeyStepper.__proto__ || Object.getPrototypeOf(ArrowKeyStepper)).call(this, props, context)); - var measurements = { - height: clientHeight && this._div.clientHeight, - width: clientWidth && this._div.clientWidth - }; + _this.state = { + scrollToColumn: 0, + scrollToRow: 0 + }; - _reactDom2.default.unmountComponentAtNode(this._div); + _this._columnStartIndex = 0; + _this._columnStopIndex = 0; + _this._rowStartIndex = 0; + _this._rowStopIndex = 0; - return measurements; - } - }, { - key: '_renderAndMount', - value: function _renderAndMount() { - if (!this._div) { - this._div = document.createElement('div'); - this._div.style.display = 'inline-block'; - this._div.style.position = 'absolute'; - this._div.style.visibility = 'hidden'; - this._div.style.zIndex = -1; + _this._onKeyDown = _this._onKeyDown.bind(_this); + _this._onSectionRendered = _this._onSectionRendered.bind(_this); + return _this; + } - this._updateDivDimensions(this.props); + _createClass(ArrowKeyStepper, [{ + key: 'render', + value: function render() { + var _props = this.props; + var className = _props.className; + var children = _props.children; + var _state = this.state; + var scrollToColumn = _state.scrollToColumn; + var scrollToRow = _state.scrollToRow; - this._containerNode = this._getContainerNode(this.props); - this._containerNode.appendChild(this._div); - } + + return _react2.default.createElement( + 'div', + { + className: className, + onKeyDown: this._onKeyDown + }, + children({ + onSectionRendered: this._onSectionRendered, + scrollToColumn: scrollToColumn, + scrollToRow: scrollToRow + }) + ); } }, { - key: '_unmountContainer', - value: function _unmountContainer() { - if (this._div) { - this._containerNode.removeChild(this._div); - - this._div = null; - } - - this._containerNode = null; + key: 'shouldComponentUpdate', + value: function shouldComponentUpdate(nextProps, nextState) { + return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState); } }, { - key: '_updateDivDimensions', - value: function _updateDivDimensions(props) { - var height = props.height; - var width = props.width; + key: '_onKeyDown', + value: function _onKeyDown(event) { + var _props2 = this.props; + var columnCount = _props2.columnCount; + var rowCount = _props2.rowCount; + // The above cases all prevent default event event behavior. + // This is to keep the grid from scrolling after the snap-to update. - if (height && height !== this._divHeight) { - this._divHeight = height; - this._div.style.height = height + 'px'; + switch (event.key) { + case 'ArrowDown': + event.preventDefault(); + this.setState({ + scrollToRow: Math.min(this._rowStopIndex + 1, rowCount - 1) + }); + break; + case 'ArrowLeft': + event.preventDefault(); + this.setState({ + scrollToColumn: Math.max(this._columnStartIndex - 1, 0) + }); + break; + case 'ArrowRight': + event.preventDefault(); + this.setState({ + scrollToColumn: Math.min(this._columnStopIndex + 1, columnCount - 1) + }); + break; + case 'ArrowUp': + event.preventDefault(); + this.setState({ + scrollToRow: Math.max(this._rowStartIndex - 1, 0) + }); + break; } + } + }, { + key: '_onSectionRendered', + value: function _onSectionRendered(_ref) { + var columnStartIndex = _ref.columnStartIndex; + var columnStopIndex = _ref.columnStopIndex; + var rowStartIndex = _ref.rowStartIndex; + var rowStopIndex = _ref.rowStopIndex; - if (width && width !== this._divWidth) { - this._divWidth = width; - this._div.style.width = width + 'px'; - } + this._columnStartIndex = columnStartIndex; + this._columnStopIndex = columnStopIndex; + this._rowStartIndex = rowStartIndex; + this._rowStopIndex = rowStopIndex; } }]); - return CellMeasurer; + return ArrowKeyStepper; }(_react.Component); -CellMeasurer.propTypes = { - /** - * Renders a cell given its indices. - * Should implement the following interface: ({ columnIndex: number, rowIndex: number }): PropTypes.node - */ - cellRenderer: _react.PropTypes.func.isRequired, - - /** - * Optional, custom caching strategy for cell sizes. - */ - cellSizeCache: _react.PropTypes.object, - - /** - * Function respondible for rendering a virtualized component. - * This function should implement the following signature: - * ({ getColumnWidth, getRowHeight, resetMeasurements }) => PropTypes.element - */ +ArrowKeyStepper.propTypes = { children: _react.PropTypes.func.isRequired, - - /** - * Number of columns in grid. - */ + className: _react.PropTypes.string, columnCount: _react.PropTypes.number.isRequired, + rowCount: _react.PropTypes.number.isRequired +}; +exports.default = ArrowKeyStepper; +},{"react":undefined,"react-addons-shallow-compare":18}],35:[function(require,module,exports){ +'use strict'; - /** - * A Node, Component instance, or function that returns either. - * If this property is not specified the document body will be used. - */ - container: _react2.default.PropTypes.oneOfType([_react2.default.PropTypes.func, _react2.default.PropTypes.node]), +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.ArrowKeyStepper = exports.default = undefined; - /** - * Assign a fixed :height in order to measure dynamic text :width only. - */ - height: _react.PropTypes.number, +var _ArrowKeyStepper2 = require('./ArrowKeyStepper'); - /** - * Number of rows in grid. - */ - rowCount: _react.PropTypes.number.isRequired, +var _ArrowKeyStepper3 = _interopRequireDefault(_ArrowKeyStepper2); - /** - * Assign a fixed :width in order to measure dynamic text :height only. - */ - width: _react.PropTypes.number -}; -exports.default = CellMeasurer; -},{"./defaultCellSizeCache":41,"react":undefined,"react-addons-shallow-compare":30,"react-dom":undefined}],41:[function(require,module,exports){ -"use strict"; +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +exports.default = _ArrowKeyStepper3.default; +exports.ArrowKeyStepper = _ArrowKeyStepper3.default; +},{"./ArrowKeyStepper":34}],36:[function(require,module,exports){ +'use strict'; Object.defineProperty(exports, "__esModule", { value: true @@ -3603,773 +3467,709 @@ Object.defineProperty(exports, "__esModule", { var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); +var _react = require('react'); + +var _react2 = _interopRequireDefault(_react); + +var _reactAddonsShallowCompare = require('react-addons-shallow-compare'); + +var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + /** - * Default CellMeasurer `cellSizeCache` implementation. - * Permanently caches all cell sizes (identified by column and row index) unless explicitly cleared. - * Can be configured to handle uniform cell widths and/or heights as a way of optimizing certain use cases. + * Decorator component that automatically adjusts the width and height of a single child. + * Child component should not be declared as a child but should rather be specified by a `ChildComponent` property. + * All other properties will be passed through to the child component. */ -var CellSizeCache = function () { - function CellSizeCache() { - var _ref = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; +var AutoSizer = function (_Component) { + _inherits(AutoSizer, _Component); - var _ref$uniformRowHeight = _ref.uniformRowHeight; - var uniformRowHeight = _ref$uniformRowHeight === undefined ? false : _ref$uniformRowHeight; - var _ref$uniformColumnWid = _ref.uniformColumnWidth; - var uniformColumnWidth = _ref$uniformColumnWid === undefined ? false : _ref$uniformColumnWid; + function AutoSizer(props) { + _classCallCheck(this, AutoSizer); - _classCallCheck(this, CellSizeCache); + var _this = _possibleConstructorReturn(this, (AutoSizer.__proto__ || Object.getPrototypeOf(AutoSizer)).call(this, props)); - this._uniformRowHeight = uniformRowHeight; - this._uniformColumnWidth = uniformColumnWidth; + _this.state = { + height: 0, + width: 0 + }; - this._cachedColumnWidths = {}; - this._cachedRowHeights = {}; + _this._onResize = _this._onResize.bind(_this); + _this._onScroll = _this._onScroll.bind(_this); + _this._setRef = _this._setRef.bind(_this); + return _this; } - _createClass(CellSizeCache, [{ - key: "clearAllColumnWidths", - value: function clearAllColumnWidths() { - this._cachedColumnWidth = undefined; - this._cachedColumnWidths = {}; - } - }, { - key: "clearAllRowHeights", - value: function clearAllRowHeights() { - this._cachedRowHeight = undefined; - this._cachedRowHeights = {}; - } - }, { - key: "clearColumnWidth", - value: function clearColumnWidth(index) { - this._cachedColumnWidth = undefined; + _createClass(AutoSizer, [{ + key: 'componentDidMount', + value: function componentDidMount() { + // Delay access of parentNode until mount. + // This handles edge-cases where the component has already been unmounted before its ref has been set, + // As well as libraries like react-lite which have a slightly different lifecycle. + this._parentNode = this._autoSizer.parentNode; - delete this._cachedColumnWidths[index]; - } - }, { - key: "clearRowHeight", - value: function clearRowHeight(index) { - this._cachedRowHeight = undefined; + // Defer requiring resize handler in order to support server-side rendering. + // See issue #41 + this._detectElementResize = require('../vendor/detectElementResize'); + this._detectElementResize.addResizeListener(this._parentNode, this._onResize); - delete this._cachedRowHeights[index]; + this._onResize(); } }, { - key: "getColumnWidth", - value: function getColumnWidth(index) { - return this._uniformColumnWidth ? this._cachedColumnWidth : this._cachedColumnWidths[index]; + key: 'componentWillUnmount', + value: function componentWillUnmount() { + if (this._detectElementResize) { + this._detectElementResize.removeResizeListener(this._parentNode, this._onResize); + } } }, { - key: "getRowHeight", - value: function getRowHeight(index) { - return this._uniformRowHeight ? this._cachedRowHeight : this._cachedRowHeights[index]; + key: 'render', + value: function render() { + var _props = this.props; + var children = _props.children; + var disableHeight = _props.disableHeight; + var disableWidth = _props.disableWidth; + var _state = this.state; + var height = _state.height; + var width = _state.width; + + // Outer div should not force width/height since that may prevent containers from shrinking. + // Inner component should overflow and use calculated width/height. + // See issue #68 for more information. + + var outerStyle = { overflow: 'visible' }; + + if (!disableHeight) { + outerStyle.height = 0; + } + + if (!disableWidth) { + outerStyle.width = 0; + } + + return _react2.default.createElement( + 'div', + { + ref: this._setRef, + onScroll: this._onScroll, + style: outerStyle + }, + children({ height: height, width: width }) + ); } }, { - key: "hasColumnWidth", - value: function hasColumnWidth(index) { - return this._uniformColumnWidth ? !!this._cachedColumnWidth : !!this._cachedColumnWidths[index]; + key: 'shouldComponentUpdate', + value: function shouldComponentUpdate(nextProps, nextState) { + return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState); } }, { - key: "hasRowHeight", - value: function hasRowHeight(index) { - return this._uniformRowHeight ? !!this._cachedRowHeight : !!this._cachedRowHeights[index]; + key: '_onResize', + value: function _onResize() { + var onResize = this.props.onResize; + + // Gaurd against AutoSizer component being removed from the DOM immediately after being added. + // This can result in invalid style values which can result in NaN values if we don't handle them. + // See issue #150 for more context. + + var boundingRect = this._parentNode.getBoundingClientRect(); + var height = boundingRect.height || 0; + var width = boundingRect.width || 0; + + var style = getComputedStyle(this._parentNode); + var paddingLeft = parseInt(style.paddingLeft, 10) || 0; + var paddingRight = parseInt(style.paddingRight, 10) || 0; + var paddingTop = parseInt(style.paddingTop, 10) || 0; + var paddingBottom = parseInt(style.paddingBottom, 10) || 0; + + this.setState({ + height: height - paddingTop - paddingBottom, + width: width - paddingLeft - paddingRight + }); + + onResize({ height: height, width: width }); } }, { - key: "setColumnWidth", - value: function setColumnWidth(index, width) { - this._cachedColumnWidth = width; - this._cachedColumnWidths[index] = width; + key: '_onScroll', + value: function _onScroll(event) { + // Prevent detectElementResize library from being triggered by this scroll event. + event.stopPropagation(); } }, { - key: "setRowHeight", - value: function setRowHeight(index, height) { - this._cachedRowHeight = height; - this._cachedRowHeights[index] = height; + key: '_setRef', + value: function _setRef(autoSizer) { + this._autoSizer = autoSizer; } }]); - return CellSizeCache; -}(); + return AutoSizer; +}(_react.Component); -exports.default = CellSizeCache; -},{}],42:[function(require,module,exports){ +AutoSizer.propTypes = { + /** + * Function respondible for rendering children. + * This function should implement the following signature: + * ({ height, width }) => PropTypes.element + */ + children: _react.PropTypes.func.isRequired, + + /** Disable dynamic :height property */ + disableHeight: _react.PropTypes.bool, + + /** Disable dynamic :width property */ + disableWidth: _react.PropTypes.bool, + + /** Callback to be invoked on-resize: ({ height, width }) */ + onResize: _react.PropTypes.func.isRequired +}; +AutoSizer.defaultProps = { + onResize: function onResize() {} +}; +exports.default = AutoSizer; +},{"../vendor/detectElementResize":78,"react":undefined,"react-addons-shallow-compare":18}],37:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); -exports.defaultCellSizeCache = exports.CellMeasurer = exports.default = undefined; - -var _CellMeasurer2 = require('./CellMeasurer'); - -var _CellMeasurer3 = _interopRequireDefault(_CellMeasurer2); +exports.AutoSizer = exports.default = undefined; -var _defaultCellSizeCache2 = require('./defaultCellSizeCache'); +var _AutoSizer2 = require('./AutoSizer'); -var _defaultCellSizeCache3 = _interopRequireDefault(_defaultCellSizeCache2); +var _AutoSizer3 = _interopRequireDefault(_AutoSizer2); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } -exports.default = _CellMeasurer3.default; -exports.CellMeasurer = _CellMeasurer3.default; -exports.defaultCellSizeCache = _defaultCellSizeCache3.default; -},{"./CellMeasurer":40,"./defaultCellSizeCache":41}],43:[function(require,module,exports){ +exports.default = _AutoSizer3.default; +exports.AutoSizer = _AutoSizer3.default; +},{"./AutoSizer":36}],38:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); -var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; - var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); var _react = require('react'); var _react2 = _interopRequireDefault(_react); -var _CollectionView = require('./CollectionView'); - -var _CollectionView2 = _interopRequireDefault(_CollectionView); - -var _calculateSizeAndPositionData2 = require('./utils/calculateSizeAndPositionData'); +var _reactAddonsShallowCompare = require('react-addons-shallow-compare'); -var _calculateSizeAndPositionData3 = _interopRequireDefault(_calculateSizeAndPositionData2); +var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); -var _getUpdatedOffsetForIndex = require('../utils/getUpdatedOffsetForIndex'); +var _reactDom = require('react-dom'); -var _getUpdatedOffsetForIndex2 = _interopRequireDefault(_getUpdatedOffsetForIndex); +var _reactDom2 = _interopRequireDefault(_reactDom); -var _reactAddonsShallowCompare = require('react-addons-shallow-compare'); +var _defaultCellSizeCache = require('./defaultCellSizeCache'); -var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); +var _defaultCellSizeCache2 = _interopRequireDefault(_defaultCellSizeCache); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } -function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -/** - * Renders scattered or non-linear data. - * Unlike Grid, which renders checkerboard data, Collection can render arbitrarily positioned- even overlapping- data. - */ -var Collection = function (_Component) { - _inherits(Collection, _Component); +/** + * Measures a Grid cell's contents by rendering them in a way that is not visible to the user. + * Either a fixed width or height may be provided if it is desirable to measure only in one direction. + */ +var CellMeasurer = function (_Component) { + _inherits(CellMeasurer, _Component); + + function CellMeasurer(props, state) { + _classCallCheck(this, CellMeasurer); + + var _this = _possibleConstructorReturn(this, (CellMeasurer.__proto__ || Object.getPrototypeOf(CellMeasurer)).call(this, props, state)); + + _this._cellSizeCache = props.cellSizeCache || new _defaultCellSizeCache2.default(); + + _this.getColumnWidth = _this.getColumnWidth.bind(_this); + _this.getRowHeight = _this.getRowHeight.bind(_this); + _this.resetMeasurements = _this.resetMeasurements.bind(_this); + _this.resetMeasurementForColumn = _this.resetMeasurementForColumn.bind(_this); + _this.resetMeasurementForRow = _this.resetMeasurementForRow.bind(_this); + return _this; + } + + _createClass(CellMeasurer, [{ + key: 'getColumnWidth', + value: function getColumnWidth(_ref) { + var index = _ref.index; + + if (this._cellSizeCache.hasColumnWidth(index)) { + return this._cellSizeCache.getColumnWidth(index); + } + + var rowCount = this.props.rowCount; + + + var maxWidth = 0; + + for (var rowIndex = 0; rowIndex < rowCount; rowIndex++) { + var _measureCell2 = this._measureCell({ + clientWidth: true, + columnIndex: index, + rowIndex: rowIndex + }); + + var width = _measureCell2.width; + + + maxWidth = Math.max(maxWidth, width); + } + + this._cellSizeCache.setColumnWidth(index, maxWidth); + + return maxWidth; + } + }, { + key: 'getRowHeight', + value: function getRowHeight(_ref2) { + var index = _ref2.index; + + if (this._cellSizeCache.hasRowHeight(index)) { + return this._cellSizeCache.getRowHeight(index); + } + + var columnCount = this.props.columnCount; - function Collection(props, context) { - _classCallCheck(this, Collection); - var _this = _possibleConstructorReturn(this, (Collection.__proto__ || Object.getPrototypeOf(Collection)).call(this, props, context)); + var maxHeight = 0; - _this._cellMetadata = []; - _this._lastRenderedCellIndices = []; + for (var columnIndex = 0; columnIndex < columnCount; columnIndex++) { + var _measureCell3 = this._measureCell({ + clientHeight: true, + columnIndex: columnIndex, + rowIndex: index + }); - // Cell cache during scroll (for perforamnce) - _this._cellCache = []; + var height = _measureCell3.height; - _this._isScrollingChange = _this._isScrollingChange.bind(_this); - return _this; - } - /** See Collection#recomputeCellSizesAndPositions */ + maxHeight = Math.max(maxHeight, height); + } + this._cellSizeCache.setRowHeight(index, maxHeight); - _createClass(Collection, [{ - key: 'recomputeCellSizesAndPositions', - value: function recomputeCellSizesAndPositions() { - this._cellCache = []; - this._collectionView.recomputeCellSizesAndPositions(); + return maxHeight; + } + }, { + key: 'resetMeasurementForColumn', + value: function resetMeasurementForColumn(columnIndex) { + this._cellSizeCache.clearColumnWidth(columnIndex); + } + }, { + key: 'resetMeasurementForRow', + value: function resetMeasurementForRow(rowIndex) { + this._cellSizeCache.clearRowHeight(rowIndex); + } + }, { + key: 'resetMeasurements', + value: function resetMeasurements() { + this._cellSizeCache.clearAllColumnWidths(); + this._cellSizeCache.clearAllRowHeights(); + } + }, { + key: 'componentDidMount', + value: function componentDidMount() { + this._renderAndMount(); } + }, { + key: 'componentWillReceiveProps', + value: function componentWillReceiveProps(nextProps) { + var cellSizeCache = this.props.cellSizeCache; - /** React lifecycle methods */ + if (cellSizeCache !== nextProps.cellSizeCache) { + this._cellSizeCache = nextProps.cellSizeCache; + } + + this._updateDivDimensions(nextProps); + } + }, { + key: 'componentWillUnmount', + value: function componentWillUnmount() { + this._unmountContainer(); + } }, { key: 'render', value: function render() { - var _this2 = this; + var children = this.props.children; - var props = _objectWithoutProperties(this.props, []); - return _react2.default.createElement(_CollectionView2.default, _extends({ - cellLayoutManager: this, - isScrollingChange: this._isScrollingChange, - ref: function ref(_ref) { - _this2._collectionView = _ref; - } - }, props)); + return children({ + getColumnWidth: this.getColumnWidth, + getRowHeight: this.getRowHeight, + resetMeasurements: this.resetMeasurements, + resetMeasurementForColumn: this.resetMeasurementForColumn, + resetMeasurementForRow: this.resetMeasurementForRow + }); } }, { key: 'shouldComponentUpdate', value: function shouldComponentUpdate(nextProps, nextState) { return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState); } + }, { + key: '_getContainerNode', + value: function _getContainerNode(props) { + var container = props.container; - /** CellLayoutManager interface */ + if (container) { + return _reactDom2.default.findDOMNode(typeof container === 'function' ? container() : container); + } else { + return document.body; + } + } }, { - key: 'calculateSizeAndPositionData', - value: function calculateSizeAndPositionData() { - var _props = this.props; - var cellCount = _props.cellCount; - var cellSizeAndPositionGetter = _props.cellSizeAndPositionGetter; - var sectionSize = _props.sectionSize; + key: '_measureCell', + value: function _measureCell(_ref3) { + var _ref3$clientHeight = _ref3.clientHeight; + var clientHeight = _ref3$clientHeight === undefined ? false : _ref3$clientHeight; + var _ref3$clientWidth = _ref3.clientWidth; + var clientWidth = _ref3$clientWidth === undefined ? true : _ref3$clientWidth; + var columnIndex = _ref3.columnIndex; + var rowIndex = _ref3.rowIndex; + var cellRenderer = this.props.cellRenderer; - var data = (0, _calculateSizeAndPositionData3.default)({ - cellCount: cellCount, - cellSizeAndPositionGetter: cellSizeAndPositionGetter, - sectionSize: sectionSize + var rendered = cellRenderer({ + columnIndex: columnIndex, + rowIndex: rowIndex }); - this._cellMetadata = data.cellMetadata; - this._sectionManager = data.sectionManager; - this._height = data.height; - this._width = data.width; - } + // Handle edge case where this method is called before the CellMeasurer has completed its initial render (and mounted). + this._renderAndMount(); - /** - * Returns the most recently rendered set of cell indices. - */ + // @TODO Keep an eye on this for future React updates as the interface may change: + // https://twitter.com/soprano/status/737316379712331776 + _reactDom2.default.unstable_renderSubtreeIntoContainer(this, rendered, this._div); - }, { - key: 'getLastRenderedIndices', - value: function getLastRenderedIndices() { - return this._lastRenderedCellIndices; - } + var measurements = { + height: clientHeight && this._div.clientHeight, + width: clientWidth && this._div.clientWidth + }; - /** - * Calculates the minimum amount of change from the current scroll position to ensure the specified cell is (fully) visible. - */ + _reactDom2.default.unmountComponentAtNode(this._div); + return measurements; + } }, { - key: 'getScrollPositionForCell', - value: function getScrollPositionForCell(_ref2) { - var align = _ref2.align; - var cellIndex = _ref2.cellIndex; - var height = _ref2.height; - var scrollLeft = _ref2.scrollLeft; - var scrollTop = _ref2.scrollTop; - var width = _ref2.width; - var cellCount = this.props.cellCount; - - - if (cellIndex >= 0 && cellIndex < cellCount) { - var cellMetadata = this._cellMetadata[cellIndex]; + key: '_renderAndMount', + value: function _renderAndMount() { + if (!this._div) { + this._div = document.createElement('div'); + this._div.style.display = 'inline-block'; + this._div.style.position = 'absolute'; + this._div.style.visibility = 'hidden'; + this._div.style.zIndex = -1; - scrollLeft = (0, _getUpdatedOffsetForIndex2.default)({ - align: align, - cellOffset: cellMetadata.x, - cellSize: cellMetadata.width, - containerSize: width, - currentOffset: scrollLeft, - targetIndex: cellIndex - }); + this._updateDivDimensions(this.props); - scrollTop = (0, _getUpdatedOffsetForIndex2.default)({ - align: align, - cellOffset: cellMetadata.y, - cellSize: cellMetadata.height, - containerSize: height, - currentOffset: scrollTop, - targetIndex: cellIndex - }); + this._containerNode = this._getContainerNode(this.props); + this._containerNode.appendChild(this._div); } - - return { - scrollLeft: scrollLeft, - scrollTop: scrollTop - }; } }, { - key: 'getTotalSize', - value: function getTotalSize() { - return { - height: this._height, - width: this._width - }; + key: '_unmountContainer', + value: function _unmountContainer() { + if (this._div) { + this._containerNode.removeChild(this._div); + + this._div = null; + } + + this._containerNode = null; } }, { - key: 'cellRenderers', - value: function cellRenderers(_ref3) { - var _this3 = this; - - var height = _ref3.height; - var isScrolling = _ref3.isScrolling; - var width = _ref3.width; - var x = _ref3.x; - var y = _ref3.y; - var _props2 = this.props; - var cellGroupRenderer = _props2.cellGroupRenderer; - var cellRenderer = _props2.cellRenderer; + key: '_updateDivDimensions', + value: function _updateDivDimensions(props) { + var height = props.height; + var width = props.width; - // Store for later calls to getLastRenderedIndices() - this._lastRenderedCellIndices = this._sectionManager.getCellIndices({ - height: height, - width: width, - x: x, - y: y - }); + if (height && height !== this._divHeight) { + this._divHeight = height; + this._div.style.height = height + 'px'; + } - return cellGroupRenderer({ - cellCache: this._cellCache, - cellRenderer: cellRenderer, - cellSizeAndPositionGetter: function cellSizeAndPositionGetter(_ref4) { - var index = _ref4.index; - return _this3._sectionManager.getCellMetadata({ index: index }); - }, - indices: this._lastRenderedCellIndices, - isScrolling: isScrolling - }); - } - }, { - key: '_isScrollingChange', - value: function _isScrollingChange(isScrolling) { - if (!isScrolling) { - this._cellCache = []; + if (width && width !== this._divWidth) { + this._divWidth = width; + this._div.style.width = width + 'px'; } } }]); - return Collection; + return CellMeasurer; }(_react.Component); -Collection.propTypes = { - 'aria-label': _react.PropTypes.string, - +CellMeasurer.propTypes = { /** - * Number of cells in Collection. + * Renders a cell given its indices. + * Should implement the following interface: ({ columnIndex: number, rowIndex: number }): PropTypes.node */ - cellCount: _react.PropTypes.number.isRequired, + cellRenderer: _react.PropTypes.func.isRequired, /** - * Responsible for rendering a group of cells given their indices. - * Should implement the following interface: ({ - * cellSizeAndPositionGetter:Function, - * indices: Array, - * cellRenderer: Function - * }): Array + * Optional, custom caching strategy for cell sizes. */ - cellGroupRenderer: _react.PropTypes.func.isRequired, + cellSizeCache: _react.PropTypes.object, /** - * Responsible for rendering a cell given an row and column index. - * Should implement the following interface: ({ index: number }): PropTypes.element + * Function respondible for rendering a virtualized component. + * This function should implement the following signature: + * ({ getColumnWidth, getRowHeight, resetMeasurements }) => PropTypes.element */ - cellRenderer: _react.PropTypes.func.isRequired, + children: _react.PropTypes.func.isRequired, /** - * Callback responsible for returning size and offset/position information for a given cell (index). - * ({ index: number }): { height: number, width: number, x: number, y: number } + * Number of columns in grid. */ - cellSizeAndPositionGetter: _react.PropTypes.func.isRequired, + columnCount: _react.PropTypes.number.isRequired, /** - * Optionally override the size of the sections a Collection's cells are split into. + * A Node, Component instance, or function that returns either. + * If this property is not specified the document body will be used. */ - sectionSize: _react.PropTypes.number -}; -Collection.defaultProps = { - 'aria-label': 'grid', - cellGroupRenderer: defaultCellGroupRenderer -}; -exports.default = Collection; - - -function defaultCellGroupRenderer(_ref5) { - var cellCache = _ref5.cellCache; - var cellRenderer = _ref5.cellRenderer; - var cellSizeAndPositionGetter = _ref5.cellSizeAndPositionGetter; - var indices = _ref5.indices; - var isScrolling = _ref5.isScrolling; - - return indices.map(function (index) { - var cellMetadata = cellSizeAndPositionGetter({ index: index }); - - // Avoid re-creating cells while scrolling. - // This can lead to the same cell being created many times and can cause performance issues for "heavy" cells. - // If a scroll is in progress- cache and reuse cells. - // This cache will be thrown away once scrolling complets. - var renderedCell = void 0; - - if (isScrolling) { - if (!(index in cellCache)) { - cellCache[index] = cellRenderer({ - index: index, - isScrolling: isScrolling - }); - } + container: _react2.default.PropTypes.oneOfType([_react2.default.PropTypes.func, _react2.default.PropTypes.node]), - renderedCell = cellCache[index]; - } else { - renderedCell = cellRenderer({ - index: index, - isScrolling: isScrolling - }); - } + /** + * Assign a fixed :height in order to measure dynamic text :width only. + */ + height: _react.PropTypes.number, - if (renderedCell == null || renderedCell === false) { - return null; - } + /** + * Number of rows in grid. + */ + rowCount: _react.PropTypes.number.isRequired, - return _react2.default.createElement( - 'div', - { - className: 'Collection__cell', - key: index, - style: { - height: cellMetadata.height, - left: cellMetadata.x, - top: cellMetadata.y, - width: cellMetadata.width - } - }, - renderedCell - ); - }).filter(function (renderedCell) { - return !!renderedCell; - }); -} -},{"../utils/getUpdatedOffsetForIndex":79,"./CollectionView":44,"./utils/calculateSizeAndPositionData":48,"react":undefined,"react-addons-shallow-compare":30}],44:[function(require,module,exports){ -'use strict'; + /** + * Assign a fixed :width in order to measure dynamic text :height only. + */ + width: _react.PropTypes.number +}; +exports.default = CellMeasurer; +},{"./defaultCellSizeCache":39,"react":undefined,"react-addons-shallow-compare":18,"react-dom":undefined}],39:[function(require,module,exports){ +"use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; - var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); -var _react = require('react'); - -var _react2 = _interopRequireDefault(_react); - -var _classnames = require('classnames'); - -var _classnames2 = _interopRequireDefault(_classnames); - -var _createCallbackMemoizer = require('../utils/createCallbackMemoizer'); - -var _createCallbackMemoizer2 = _interopRequireDefault(_createCallbackMemoizer); - -var _scrollbarSize = require('dom-helpers/util/scrollbarSize'); - -var _scrollbarSize2 = _interopRequireDefault(_scrollbarSize); - -var _raf = require('raf'); - -var _raf2 = _interopRequireDefault(_raf); - -var _reactAddonsShallowCompare = require('react-addons-shallow-compare'); - -var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } - -// @TODO It would be nice to refactor Grid to use this code as well. - -/** - * Specifies the number of miliseconds during which to disable pointer events while a scroll is in progress. - * This improves performance and makes scrolling smoother. - */ -var IS_SCROLLING_TIMEOUT = 150; - -/** - * Controls whether the Grid updates the DOM element's scrollLeft/scrollTop based on the current state or just observes it. - * This prevents Grid from interrupting mouse-wheel animations (see issue #2). - */ -var SCROLL_POSITION_CHANGE_REASONS = { - OBSERVED: 'observed', - REQUESTED: 'requested' -}; - /** - * Monitors changes in properties (eg. cellCount) and state (eg. scroll offsets) to determine when rendering needs to occur. - * This component does not render any visible content itself; it defers to the specified :cellLayoutManager. + * Default CellMeasurer `cellSizeCache` implementation. + * Permanently caches all cell sizes (identified by column and row index) unless explicitly cleared. + * Can be configured to handle uniform cell widths and/or heights as a way of optimizing certain use cases. */ +var CellSizeCache = function () { + function CellSizeCache() { + var _ref = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; -var CollectionView = function (_Component) { - _inherits(CollectionView, _Component); - - function CollectionView(props, context) { - _classCallCheck(this, CollectionView); - - var _this = _possibleConstructorReturn(this, (CollectionView.__proto__ || Object.getPrototypeOf(CollectionView)).call(this, props, context)); + var _ref$uniformRowHeight = _ref.uniformRowHeight; + var uniformRowHeight = _ref$uniformRowHeight === undefined ? false : _ref$uniformRowHeight; + var _ref$uniformColumnWid = _ref.uniformColumnWidth; + var uniformColumnWidth = _ref$uniformColumnWid === undefined ? false : _ref$uniformColumnWid; - _this.state = { - calculateSizeAndPositionDataOnNextUpdate: false, - isScrolling: false, - scrollLeft: 0, - scrollTop: 0 - }; + _classCallCheck(this, CellSizeCache); - // Invokes callbacks only when their values have changed. - _this._onSectionRenderedMemoizer = (0, _createCallbackMemoizer2.default)(); - _this._onScrollMemoizer = (0, _createCallbackMemoizer2.default)(false); + this._uniformRowHeight = uniformRowHeight; + this._uniformColumnWidth = uniformColumnWidth; - // Bind functions to instance so they don't lose context when passed around. - _this._invokeOnSectionRenderedHelper = _this._invokeOnSectionRenderedHelper.bind(_this); - _this._onScroll = _this._onScroll.bind(_this); - _this._updateScrollPositionForScrollToCell = _this._updateScrollPositionForScrollToCell.bind(_this); - return _this; + this._cachedColumnWidths = {}; + this._cachedRowHeights = {}; } - /** - * Forced recompute of cell sizes and positions. - * This function should be called if cell sizes have changed but nothing else has. - * Since cell positions are calculated by callbacks, the collection view has no way of detecting when the underlying data has changed. - */ + _createClass(CellSizeCache, [{ + key: "clearAllColumnWidths", + value: function clearAllColumnWidths() { + this._cachedColumnWidth = undefined; + this._cachedColumnWidths = {}; + } + }, { + key: "clearAllRowHeights", + value: function clearAllRowHeights() { + this._cachedRowHeight = undefined; + this._cachedRowHeights = {}; + } + }, { + key: "clearColumnWidth", + value: function clearColumnWidth(index) { + this._cachedColumnWidth = undefined; + delete this._cachedColumnWidths[index]; + } + }, { + key: "clearRowHeight", + value: function clearRowHeight(index) { + this._cachedRowHeight = undefined; - _createClass(CollectionView, [{ - key: 'recomputeCellSizesAndPositions', - value: function recomputeCellSizesAndPositions() { - this.setState({ - calculateSizeAndPositionDataOnNextUpdate: true - }); + delete this._cachedRowHeights[index]; + } + }, { + key: "getColumnWidth", + value: function getColumnWidth(index) { + return this._uniformColumnWidth ? this._cachedColumnWidth : this._cachedColumnWidths[index]; + } + }, { + key: "getRowHeight", + value: function getRowHeight(index) { + return this._uniformRowHeight ? this._cachedRowHeight : this._cachedRowHeights[index]; + } + }, { + key: "hasColumnWidth", + value: function hasColumnWidth(index) { + return this._uniformColumnWidth ? !!this._cachedColumnWidth : !!this._cachedColumnWidths[index]; + } + }, { + key: "hasRowHeight", + value: function hasRowHeight(index) { + return this._uniformRowHeight ? !!this._cachedRowHeight : !!this._cachedRowHeights[index]; + } + }, { + key: "setColumnWidth", + value: function setColumnWidth(index, width) { + this._cachedColumnWidth = width; + this._cachedColumnWidths[index] = width; + } + }, { + key: "setRowHeight", + value: function setRowHeight(index, height) { + this._cachedRowHeight = height; + this._cachedRowHeights[index] = height; } + }]); - /* ---------------------------- Component lifecycle methods ---------------------------- */ + return CellSizeCache; +}(); - }, { - key: 'componentDidMount', - value: function componentDidMount() { - var _props = this.props; - var cellLayoutManager = _props.cellLayoutManager; - var scrollLeft = _props.scrollLeft; - var scrollToCell = _props.scrollToCell; - var scrollTop = _props.scrollTop; +exports.default = CellSizeCache; +},{}],40:[function(require,module,exports){ +'use strict'; - // If this component was first rendered server-side, scrollbar size will be undefined. - // In that event we need to remeasure. +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.defaultCellSizeCache = exports.CellMeasurer = exports.default = undefined; - if (!this._scrollbarSizeMeasured) { - this._scrollbarSize = (0, _scrollbarSize2.default)(); - this._scrollbarSizeMeasured = true; - this.setState({}); - } +var _CellMeasurer2 = require('./CellMeasurer'); - if (scrollToCell >= 0) { - this._updateScrollPositionForScrollToCell(); - } else if (scrollLeft >= 0 || scrollTop >= 0) { - this._setScrollPosition({ scrollLeft: scrollLeft, scrollTop: scrollTop }); - } +var _CellMeasurer3 = _interopRequireDefault(_CellMeasurer2); - // Update onSectionRendered callback. - this._invokeOnSectionRenderedHelper(); +var _defaultCellSizeCache2 = require('./defaultCellSizeCache'); - var _cellLayoutManager$ge = cellLayoutManager.getTotalSize(); +var _defaultCellSizeCache3 = _interopRequireDefault(_defaultCellSizeCache2); - var totalHeight = _cellLayoutManager$ge.height; - var totalWidth = _cellLayoutManager$ge.width; +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - // Initialize onScroll callback. +exports.default = _CellMeasurer3.default; +exports.CellMeasurer = _CellMeasurer3.default; +exports.defaultCellSizeCache = _defaultCellSizeCache3.default; +},{"./CellMeasurer":38,"./defaultCellSizeCache":39}],41:[function(require,module,exports){ +'use strict'; - this._invokeOnScrollMemoizer({ - scrollLeft: scrollLeft || 0, - scrollTop: scrollTop || 0, - totalHeight: totalHeight, - totalWidth: totalWidth - }); - } - }, { - key: 'componentDidUpdate', - value: function componentDidUpdate(prevProps, prevState) { - var _props2 = this.props; - var height = _props2.height; - var scrollToCell = _props2.scrollToCell; - var width = _props2.width; - var _state = this.state; - var scrollLeft = _state.scrollLeft; - var scrollPositionChangeReason = _state.scrollPositionChangeReason; - var scrollToAlignment = _state.scrollToAlignment; - var scrollTop = _state.scrollTop; +Object.defineProperty(exports, "__esModule", { + value: true +}); - // Make sure requested changes to :scrollLeft or :scrollTop get applied. - // Assigning to scrollLeft/scrollTop tells the browser to interrupt any running scroll animations, - // And to discard any pending async changes to the scroll position that may have happened in the meantime (e.g. on a separate scrolling thread). - // So we only set these when we require an adjustment of the scroll position. - // See issue #2 for more information. +var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; - if (scrollPositionChangeReason === SCROLL_POSITION_CHANGE_REASONS.REQUESTED) { - if (scrollLeft >= 0 && scrollLeft !== prevState.scrollLeft && scrollLeft !== this._scrollingContainer.scrollLeft) { - this._scrollingContainer.scrollLeft = scrollLeft; - } - if (scrollTop >= 0 && scrollTop !== prevState.scrollTop && scrollTop !== this._scrollingContainer.scrollTop) { - this._scrollingContainer.scrollTop = scrollTop; - } - } +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); - // Update scroll offsets if the current :scrollToCell values requires it - if (height !== prevProps.height || scrollToAlignment !== prevProps.scrollToAlignment || scrollToCell !== prevProps.scrollToCell || width !== prevProps.width) { - this._updateScrollPositionForScrollToCell(); - } +var _react = require('react'); - // Update onRowsRendered callback if start/stop indices have changed - this._invokeOnSectionRenderedHelper(); - } - }, { - key: 'componentWillMount', - value: function componentWillMount() { - var cellLayoutManager = this.props.cellLayoutManager; +var _react2 = _interopRequireDefault(_react); +var _CollectionView = require('./CollectionView'); - cellLayoutManager.calculateSizeAndPositionData(); +var _CollectionView2 = _interopRequireDefault(_CollectionView); - // If this component is being rendered server-side, getScrollbarSize() will return undefined. - // We handle this case in componentDidMount() - this._scrollbarSize = (0, _scrollbarSize2.default)(); - if (this._scrollbarSize === undefined) { - this._scrollbarSizeMeasured = false; - this._scrollbarSize = 0; - } else { - this._scrollbarSizeMeasured = true; - } - } - }, { - key: 'componentWillUnmount', - value: function componentWillUnmount() { - if (this._disablePointerEventsTimeoutId) { - clearTimeout(this._disablePointerEventsTimeoutId); - } +var _calculateSizeAndPositionData2 = require('./utils/calculateSizeAndPositionData'); - if (this._setNextStateAnimationFrameId) { - _raf2.default.cancel(this._setNextStateAnimationFrameId); - } - } +var _calculateSizeAndPositionData3 = _interopRequireDefault(_calculateSizeAndPositionData2); - /** - * @private - * This method updates scrollLeft/scrollTop in state for the following conditions: - * 1) Empty content (0 rows or columns) - * 2) New scroll props overriding the current state - * 3) Cells-count or cells-size has changed, making previous scroll offsets invalid - */ +var _getUpdatedOffsetForIndex = require('../utils/getUpdatedOffsetForIndex'); - }, { - key: 'componentWillUpdate', - value: function componentWillUpdate(nextProps, nextState) { - if (nextProps.cellCount === 0 && (nextState.scrollLeft !== 0 || nextState.scrollTop !== 0)) { - this._setScrollPosition({ - scrollLeft: 0, - scrollTop: 0 - }); - } else if (nextProps.scrollLeft !== this.props.scrollLeft || nextProps.scrollTop !== this.props.scrollTop) { - this._setScrollPosition({ - scrollLeft: nextProps.scrollLeft, - scrollTop: nextProps.scrollTop - }); - } +var _getUpdatedOffsetForIndex2 = _interopRequireDefault(_getUpdatedOffsetForIndex); - if (nextProps.cellCount !== this.props.cellCount || nextProps.cellLayoutManager !== this.props.cellLayoutManager || nextState.calculateSizeAndPositionDataOnNextUpdate) { - nextProps.cellLayoutManager.calculateSizeAndPositionData(); - } +var _reactAddonsShallowCompare = require('react-addons-shallow-compare'); - if (nextState.calculateSizeAndPositionDataOnNextUpdate) { - this.setState({ - calculateSizeAndPositionDataOnNextUpdate: false - }); - } - } - }, { - key: 'render', - value: function render() { - var _this2 = this; +var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); - var _props3 = this.props; - var autoHeight = _props3.autoHeight; - var cellCount = _props3.cellCount; - var cellLayoutManager = _props3.cellLayoutManager; - var className = _props3.className; - var height = _props3.height; - var horizontalOverscanSize = _props3.horizontalOverscanSize; - var noContentRenderer = _props3.noContentRenderer; - var style = _props3.style; - var verticalOverscanSize = _props3.verticalOverscanSize; - var width = _props3.width; - var _state2 = this.state; - var isScrolling = _state2.isScrolling; - var scrollLeft = _state2.scrollLeft; - var scrollTop = _state2.scrollTop; +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - var _cellLayoutManager$ge2 = cellLayoutManager.getTotalSize(); +function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } - var totalHeight = _cellLayoutManager$ge2.height; - var totalWidth = _cellLayoutManager$ge2.width; +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - // Safely expand the rendered area by the specified overscan amount +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } - var left = Math.max(0, scrollLeft - horizontalOverscanSize); - var top = Math.max(0, scrollTop - verticalOverscanSize); - var right = Math.min(totalWidth, scrollLeft + width + horizontalOverscanSize); - var bottom = Math.min(totalHeight, scrollTop + height + verticalOverscanSize); +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } - var childrenToDisplay = height > 0 && width > 0 ? cellLayoutManager.cellRenderers({ - height: bottom - top, - isScrolling: isScrolling, - width: right - left, - x: left, - y: top - }) : []; +/** + * Renders scattered or non-linear data. + * Unlike Grid, which renders checkerboard data, Collection can render arbitrarily positioned- even overlapping- data. + */ +var Collection = function (_Component) { + _inherits(Collection, _Component); - var collectionStyle = { - height: autoHeight ? 'auto' : height, - width: width - }; + function Collection(props, context) { + _classCallCheck(this, Collection); - // Force browser to hide scrollbars when we know they aren't necessary. - // Otherwise once scrollbars appear they may not disappear again. - // For more info see issue #116 - var verticalScrollBarSize = totalHeight > height ? this._scrollbarSize : 0; - var horizontalScrollBarSize = totalWidth > width ? this._scrollbarSize : 0; - if (totalWidth + verticalScrollBarSize <= width) { - collectionStyle.overflowX = 'hidden'; - } - if (totalHeight + horizontalScrollBarSize <= height) { - collectionStyle.overflowY = 'hidden'; - } + var _this = _possibleConstructorReturn(this, (Collection.__proto__ || Object.getPrototypeOf(Collection)).call(this, props, context)); - return _react2.default.createElement( - 'div', - { - ref: function ref(_ref) { - _this2._scrollingContainer = _ref; - }, - 'aria-label': this.props['aria-label'], - className: (0, _classnames2.default)('Collection', className), - onScroll: this._onScroll, - role: 'grid', - style: _extends({}, collectionStyle, style), - tabIndex: 0 - }, - cellCount > 0 && _react2.default.createElement( - 'div', - { - className: 'Collection__innerScrollContainer', - style: { - height: totalHeight, - maxHeight: totalHeight, - maxWidth: totalWidth, - pointerEvents: isScrolling ? 'none' : '', - width: totalWidth - } - }, - childrenToDisplay - ), - cellCount === 0 && noContentRenderer() - ); + _this._cellMetadata = []; + _this._lastRenderedCellIndices = []; + + // Cell cache during scroll (for perforamnce) + _this._cellCache = []; + + _this._isScrollingChange = _this._isScrollingChange.bind(_this); + return _this; + } + + /** See Collection#recomputeCellSizesAndPositions */ + + + _createClass(Collection, [{ + key: 'recomputeCellSizesAndPositions', + value: function recomputeCellSizesAndPositions() { + this._cellCache = []; + this._collectionView.recomputeCellSizesAndPositions(); + } + + /** React lifecycle methods */ + + }, { + key: 'render', + value: function render() { + var _this2 = this; + + var props = _objectWithoutProperties(this.props, []); + + return _react2.default.createElement(_CollectionView2.default, _extends({ + cellLayoutManager: this, + isScrollingChange: this._isScrollingChange, + ref: function ref(_ref) { + _this2._collectionView = _ref; + } + }, props)); } }, { key: 'shouldComponentUpdate', @@ -4377,632 +4177,909 @@ var CollectionView = function (_Component) { return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState); } - /* ---------------------------- Helper methods ---------------------------- */ + /** CellLayoutManager interface */ + + }, { + key: 'calculateSizeAndPositionData', + value: function calculateSizeAndPositionData() { + var _props = this.props; + var cellCount = _props.cellCount; + var cellSizeAndPositionGetter = _props.cellSizeAndPositionGetter; + var sectionSize = _props.sectionSize; + + + var data = (0, _calculateSizeAndPositionData3.default)({ + cellCount: cellCount, + cellSizeAndPositionGetter: cellSizeAndPositionGetter, + sectionSize: sectionSize + }); + + this._cellMetadata = data.cellMetadata; + this._sectionManager = data.sectionManager; + this._height = data.height; + this._width = data.width; + } /** - * Sets an :isScrolling flag for a small window of time. - * This flag is used to disable pointer events on the scrollable portion of the Collection. - * This prevents jerky/stuttery mouse-wheel scrolling. + * Returns the most recently rendered set of cell indices. */ }, { - key: '_enablePointerEventsAfterDelay', - value: function _enablePointerEventsAfterDelay() { - var _this3 = this; + key: 'getLastRenderedIndices', + value: function getLastRenderedIndices() { + return this._lastRenderedCellIndices; + } - if (this._disablePointerEventsTimeoutId) { - clearTimeout(this._disablePointerEventsTimeoutId); - } + /** + * Calculates the minimum amount of change from the current scroll position to ensure the specified cell is (fully) visible. + */ - this._disablePointerEventsTimeoutId = setTimeout(function () { - var isScrollingChange = _this3.props.isScrollingChange; + }, { + key: 'getScrollPositionForCell', + value: function getScrollPositionForCell(_ref2) { + var align = _ref2.align; + var cellIndex = _ref2.cellIndex; + var height = _ref2.height; + var scrollLeft = _ref2.scrollLeft; + var scrollTop = _ref2.scrollTop; + var width = _ref2.width; + var cellCount = this.props.cellCount; - isScrollingChange(false); + if (cellIndex >= 0 && cellIndex < cellCount) { + var cellMetadata = this._cellMetadata[cellIndex]; - _this3._disablePointerEventsTimeoutId = null; - _this3.setState({ - isScrolling: false + scrollLeft = (0, _getUpdatedOffsetForIndex2.default)({ + align: align, + cellOffset: cellMetadata.x, + cellSize: cellMetadata.width, + containerSize: width, + currentOffset: scrollLeft, + targetIndex: cellIndex }); - }, IS_SCROLLING_TIMEOUT); - } - }, { - key: '_invokeOnSectionRenderedHelper', - value: function _invokeOnSectionRenderedHelper() { - var _props4 = this.props; - var cellLayoutManager = _props4.cellLayoutManager; - var onSectionRendered = _props4.onSectionRendered; + scrollTop = (0, _getUpdatedOffsetForIndex2.default)({ + align: align, + cellOffset: cellMetadata.y, + cellSize: cellMetadata.height, + containerSize: height, + currentOffset: scrollTop, + targetIndex: cellIndex + }); + } - this._onSectionRenderedMemoizer({ - callback: onSectionRendered, - indices: { - indices: cellLayoutManager.getLastRenderedIndices() - } - }); + return { + scrollLeft: scrollLeft, + scrollTop: scrollTop + }; } }, { - key: '_invokeOnScrollMemoizer', - value: function _invokeOnScrollMemoizer(_ref2) { - var _this4 = this; + key: 'getTotalSize', + value: function getTotalSize() { + return { + height: this._height, + width: this._width + }; + } + }, { + key: 'cellRenderers', + value: function cellRenderers(_ref3) { + var _this3 = this; - var scrollLeft = _ref2.scrollLeft; - var scrollTop = _ref2.scrollTop; - var totalHeight = _ref2.totalHeight; - var totalWidth = _ref2.totalWidth; + var height = _ref3.height; + var isScrolling = _ref3.isScrolling; + var width = _ref3.width; + var x = _ref3.x; + var y = _ref3.y; + var _props2 = this.props; + var cellGroupRenderer = _props2.cellGroupRenderer; + var cellRenderer = _props2.cellRenderer; - this._onScrollMemoizer({ - callback: function callback(_ref3) { - var scrollLeft = _ref3.scrollLeft; - var scrollTop = _ref3.scrollTop; - var _props5 = _this4.props; - var height = _props5.height; - var onScroll = _props5.onScroll; - var width = _props5.width; + // Store for later calls to getLastRenderedIndices() + this._lastRenderedCellIndices = this._sectionManager.getCellIndices({ + height: height, + width: width, + x: x, + y: y + }); - onScroll({ - clientHeight: height, - clientWidth: width, - scrollHeight: totalHeight, - scrollLeft: scrollLeft, - scrollTop: scrollTop, - scrollWidth: totalWidth - }); + return cellGroupRenderer({ + cellCache: this._cellCache, + cellRenderer: cellRenderer, + cellSizeAndPositionGetter: function cellSizeAndPositionGetter(_ref4) { + var index = _ref4.index; + return _this3._sectionManager.getCellMetadata({ index: index }); }, - indices: { - scrollLeft: scrollLeft, - scrollTop: scrollTop - } + indices: this._lastRenderedCellIndices, + isScrolling: isScrolling }); } + }, { + key: '_isScrollingChange', + value: function _isScrollingChange(isScrolling) { + if (!isScrolling) { + this._cellCache = []; + } + } + }]); - /** - * Updates the state during the next animation frame. - * Use this method to avoid multiple renders in a small span of time. - * This helps performance for bursty events (like onScroll). - */ + return Collection; +}(_react.Component); - }, { - key: '_setNextState', - value: function _setNextState(state) { - var _this5 = this; +Collection.propTypes = { + 'aria-label': _react.PropTypes.string, - if (this._setNextStateAnimationFrameId) { - _raf2.default.cancel(this._setNextStateAnimationFrameId); - } + /** + * Number of cells in Collection. + */ + cellCount: _react.PropTypes.number.isRequired, + + /** + * Responsible for rendering a group of cells given their indices. + * Should implement the following interface: ({ + * cellSizeAndPositionGetter:Function, + * indices: Array, + * cellRenderer: Function + * }): Array + */ + cellGroupRenderer: _react.PropTypes.func.isRequired, + + /** + * Responsible for rendering a cell given an row and column index. + * Should implement the following interface: ({ index: number }): PropTypes.element + */ + cellRenderer: _react.PropTypes.func.isRequired, + + /** + * Callback responsible for returning size and offset/position information for a given cell (index). + * ({ index: number }): { height: number, width: number, x: number, y: number } + */ + cellSizeAndPositionGetter: _react.PropTypes.func.isRequired, + + /** + * Optionally override the size of the sections a Collection's cells are split into. + */ + sectionSize: _react.PropTypes.number +}; +Collection.defaultProps = { + 'aria-label': 'grid', + cellGroupRenderer: defaultCellGroupRenderer +}; +exports.default = Collection; + + +function defaultCellGroupRenderer(_ref5) { + var cellCache = _ref5.cellCache; + var cellRenderer = _ref5.cellRenderer; + var cellSizeAndPositionGetter = _ref5.cellSizeAndPositionGetter; + var indices = _ref5.indices; + var isScrolling = _ref5.isScrolling; - this._setNextStateAnimationFrameId = (0, _raf2.default)(function () { - _this5._setNextStateAnimationFrameId = null; - _this5.setState(state); - }); - } - }, { - key: '_setScrollPosition', - value: function _setScrollPosition(_ref4) { - var scrollLeft = _ref4.scrollLeft; - var scrollTop = _ref4.scrollTop; + return indices.map(function (index) { + var cellMetadata = cellSizeAndPositionGetter({ index: index }); - var newState = { - scrollPositionChangeReason: SCROLL_POSITION_CHANGE_REASONS.REQUESTED - }; + // Avoid re-creating cells while scrolling. + // This can lead to the same cell being created many times and can cause performance issues for "heavy" cells. + // If a scroll is in progress- cache and reuse cells. + // This cache will be thrown away once scrolling complets. + var renderedCell = void 0; - if (scrollLeft >= 0) { - newState.scrollLeft = scrollLeft; + if (isScrolling) { + if (!(index in cellCache)) { + cellCache[index] = cellRenderer({ + index: index, + isScrolling: isScrolling + }); } - if (scrollTop >= 0) { - newState.scrollTop = scrollTop; - } + renderedCell = cellCache[index]; + } else { + renderedCell = cellRenderer({ + index: index, + isScrolling: isScrolling + }); + } - if (scrollLeft >= 0 && scrollLeft !== this.state.scrollLeft || scrollTop >= 0 && scrollTop !== this.state.scrollTop) { - this.setState(newState); - } + if (renderedCell == null || renderedCell === false) { + return null; } - }, { - key: '_updateScrollPositionForScrollToCell', - value: function _updateScrollPositionForScrollToCell() { - var _props6 = this.props; - var cellLayoutManager = _props6.cellLayoutManager; - var height = _props6.height; - var scrollToAlignment = _props6.scrollToAlignment; - var scrollToCell = _props6.scrollToCell; - var width = _props6.width; - var _state3 = this.state; - var scrollLeft = _state3.scrollLeft; - var scrollTop = _state3.scrollTop; + return _react2.default.createElement( + 'div', + { + className: 'Collection__cell', + key: index, + style: { + height: cellMetadata.height, + left: cellMetadata.x, + top: cellMetadata.y, + width: cellMetadata.width + } + }, + renderedCell + ); + }).filter(function (renderedCell) { + return !!renderedCell; + }); +} +},{"../utils/getUpdatedOffsetForIndex":77,"./CollectionView":42,"./utils/calculateSizeAndPositionData":46,"react":undefined,"react-addons-shallow-compare":18}],42:[function(require,module,exports){ +'use strict'; - if (scrollToCell >= 0) { - var scrollPosition = cellLayoutManager.getScrollPositionForCell({ - align: scrollToAlignment, - cellIndex: scrollToCell, - height: height, - scrollLeft: scrollLeft, - scrollTop: scrollTop, - width: width - }); +Object.defineProperty(exports, "__esModule", { + value: true +}); - if (scrollPosition.scrollLeft !== scrollLeft || scrollPosition.scrollTop !== scrollTop) { - this._setScrollPosition(scrollPosition); - } - } - } - }, { - key: '_onScroll', - value: function _onScroll(event) { - // In certain edge-cases React dispatches an onScroll event with an invalid target.scrollLeft / target.scrollTop. - // This invalid event can be detected by comparing event.target to this component's scrollable DOM element. - // See issue #404 for more information. - if (event.target !== this._scrollingContainer) { - return; - } +var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; - // Prevent pointer events from interrupting a smooth scroll - this._enablePointerEventsAfterDelay(); +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); - // When this component is shrunk drastically, React dispatches a series of back-to-back scroll events, - // Gradually converging on a scrollTop that is within the bounds of the new, smaller height. - // This causes a series of rapid renders that is slow for long lists. - // We can avoid that by doing some simple bounds checking to ensure that scrollTop never exceeds the total height. - var _props7 = this.props; - var cellLayoutManager = _props7.cellLayoutManager; - var height = _props7.height; - var isScrollingChange = _props7.isScrollingChange; - var width = _props7.width; +var _react = require('react'); - var scrollbarSize = this._scrollbarSize; +var _react2 = _interopRequireDefault(_react); - var _cellLayoutManager$ge3 = cellLayoutManager.getTotalSize(); +var _classnames = require('classnames'); - var totalHeight = _cellLayoutManager$ge3.height; - var totalWidth = _cellLayoutManager$ge3.width; +var _classnames2 = _interopRequireDefault(_classnames); - var scrollLeft = Math.max(0, Math.min(totalWidth - width + scrollbarSize, event.target.scrollLeft)); - var scrollTop = Math.max(0, Math.min(totalHeight - height + scrollbarSize, event.target.scrollTop)); +var _createCallbackMemoizer = require('../utils/createCallbackMemoizer'); - // Certain devices (like Apple touchpad) rapid-fire duplicate events. - // Don't force a re-render if this is the case. - // The mouse may move faster then the animation frame does. - // Use requestAnimationFrame to avoid over-updating. - if (this.state.scrollLeft !== scrollLeft || this.state.scrollTop !== scrollTop) { - // Browsers with cancelable scroll events (eg. Firefox) interrupt scrolling animations if scrollTop/scrollLeft is set. - // Other browsers (eg. Safari) don't scroll as well without the help under certain conditions (DOM or style changes during scrolling). - // All things considered, this seems to be the best current work around that I'm aware of. - // For more information see https://github.com/bvaughn/react-virtualized/pull/124 - var scrollPositionChangeReason = event.cancelable ? SCROLL_POSITION_CHANGE_REASONS.OBSERVED : SCROLL_POSITION_CHANGE_REASONS.REQUESTED; +var _createCallbackMemoizer2 = _interopRequireDefault(_createCallbackMemoizer); - // Synchronously set :isScrolling the first time (since _setNextState will reschedule its animation frame each time it's called) - if (!this.state.isScrolling) { - isScrollingChange(true); +var _scrollbarSize = require('dom-helpers/util/scrollbarSize'); - this.setState({ - isScrolling: true - }); - } +var _scrollbarSize2 = _interopRequireDefault(_scrollbarSize); - this._setNextState({ - isScrolling: true, - scrollLeft: scrollLeft, - scrollPositionChangeReason: scrollPositionChangeReason, - scrollTop: scrollTop - }); - } +var _raf = require('raf'); - this._invokeOnScrollMemoizer({ - scrollLeft: scrollLeft, - scrollTop: scrollTop, - totalWidth: totalWidth, - totalHeight: totalHeight - }); - } - }]); +var _raf2 = _interopRequireDefault(_raf); - return CollectionView; -}(_react.Component); +var _reactAddonsShallowCompare = require('react-addons-shallow-compare'); -CollectionView.propTypes = { - 'aria-label': _react.PropTypes.string, +var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); - /** - * Removes fixed height from the scrollingContainer so that the total height - * of rows can stretch the window. Intended for use with WindowScroller - */ - autoHeight: _react.PropTypes.bool, +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - /** - * Number of cells in collection. - */ - cellCount: _react.PropTypes.number.isRequired, +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - /** - * Calculates cell sizes and positions and manages rendering the appropriate cells given a specified window. - */ - cellLayoutManager: _react.PropTypes.object.isRequired, +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } - /** - * Optional custom CSS class name to attach to root Collection element. - */ - className: _react.PropTypes.string, +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } - /** - * Height of Collection; this property determines the number of visible (vs virtualized) rows. - */ - height: _react.PropTypes.number.isRequired, +// @TODO It would be nice to refactor Grid to use this code as well. - /** - * Enables the `Collection` to horiontally "overscan" its content similar to how `Grid` does. - * This can reduce flicker around the edges when a user scrolls quickly. - */ - horizontalOverscanSize: _react.PropTypes.number.isRequired, +/** + * Specifies the number of miliseconds during which to disable pointer events while a scroll is in progress. + * This improves performance and makes scrolling smoother. + */ +var IS_SCROLLING_TIMEOUT = 150; - isScrollingChange: _react.PropTypes.func, +/** + * Controls whether the Grid updates the DOM element's scrollLeft/scrollTop based on the current state or just observes it. + * This prevents Grid from interrupting mouse-wheel animations (see issue #2). + */ +var SCROLL_POSITION_CHANGE_REASONS = { + OBSERVED: 'observed', + REQUESTED: 'requested' +}; - /** - * Optional renderer to be used in place of rows when either :rowCount or :cellCount is 0. - */ - noContentRenderer: _react.PropTypes.func.isRequired, +/** + * Monitors changes in properties (eg. cellCount) and state (eg. scroll offsets) to determine when rendering needs to occur. + * This component does not render any visible content itself; it defers to the specified :cellLayoutManager. + */ - /** - * Callback invoked whenever the scroll offset changes within the inner scrollable region. - * This callback can be used to sync scrolling between lists, tables, or grids. - * ({ clientHeight, clientWidth, scrollHeight, scrollLeft, scrollTop, scrollWidth }): void - */ - onScroll: _react.PropTypes.func.isRequired, +var CollectionView = function (_Component) { + _inherits(CollectionView, _Component); - /** - * Callback invoked with information about the section of the Collection that was just rendered. - * This callback is passed a named :indices parameter which is an Array of the most recently rendered section indices. - */ - onSectionRendered: _react.PropTypes.func.isRequired, + function CollectionView(props, context) { + _classCallCheck(this, CollectionView); - /** - * Horizontal offset. - */ - scrollLeft: _react.PropTypes.number, + var _this = _possibleConstructorReturn(this, (CollectionView.__proto__ || Object.getPrototypeOf(CollectionView)).call(this, props, context)); - /** - * Controls scroll-to-cell behavior of the Grid. - * The default ("auto") scrolls the least amount possible to ensure that the specified cell is fully visible. - * Use "start" to align cells to the top/left of the Grid and "end" to align bottom/right. - */ - scrollToAlignment: _react.PropTypes.oneOf(['auto', 'end', 'start', 'center']).isRequired, + _this.state = { + calculateSizeAndPositionDataOnNextUpdate: false, + isScrolling: false, + scrollLeft: 0, + scrollTop: 0 + }; + + // Invokes callbacks only when their values have changed. + _this._onSectionRenderedMemoizer = (0, _createCallbackMemoizer2.default)(); + _this._onScrollMemoizer = (0, _createCallbackMemoizer2.default)(false); - /** - * Cell index to ensure visible (by forcefully scrolling if necessary). - */ - scrollToCell: _react.PropTypes.number, + // Bind functions to instance so they don't lose context when passed around. + _this._invokeOnSectionRenderedHelper = _this._invokeOnSectionRenderedHelper.bind(_this); + _this._onScroll = _this._onScroll.bind(_this); + _this._updateScrollPositionForScrollToCell = _this._updateScrollPositionForScrollToCell.bind(_this); + return _this; + } /** - * Vertical offset. + * Forced recompute of cell sizes and positions. + * This function should be called if cell sizes have changed but nothing else has. + * Since cell positions are calculated by callbacks, the collection view has no way of detecting when the underlying data has changed. */ - scrollTop: _react.PropTypes.number, - /** - * Optional custom inline style to attach to root Collection element. - */ - style: _react.PropTypes.object, - /** - * Enables the `Collection` to vertically "overscan" its content similar to how `Grid` does. - * This can reduce flicker around the edges when a user scrolls quickly. - */ - verticalOverscanSize: _react.PropTypes.number.isRequired, + _createClass(CollectionView, [{ + key: 'recomputeCellSizesAndPositions', + value: function recomputeCellSizesAndPositions() { + this.setState({ + calculateSizeAndPositionDataOnNextUpdate: true + }); + } - /** - * Width of Collection; this property determines the number of visible (vs virtualized) columns. - */ - width: _react.PropTypes.number.isRequired -}; -CollectionView.defaultProps = { - 'aria-label': 'grid', - horizontalOverscanSize: 0, - noContentRenderer: function noContentRenderer() { - return null; - }, - onScroll: function onScroll() { - return null; - }, - onSectionRendered: function onSectionRendered() { - return null; - }, - scrollToAlignment: 'auto', - style: {}, - verticalOverscanSize: 0 -}; -exports.default = CollectionView; -},{"../utils/createCallbackMemoizer":78,"classnames":undefined,"dom-helpers/util/scrollbarSize":19,"raf":29,"react":undefined,"react-addons-shallow-compare":30}],45:[function(require,module,exports){ -'use strict'; + /* ---------------------------- Component lifecycle methods ---------------------------- */ -Object.defineProperty(exports, "__esModule", { - value: true -}); + }, { + key: 'componentDidMount', + value: function componentDidMount() { + var _props = this.props; + var cellLayoutManager = _props.cellLayoutManager; + var scrollLeft = _props.scrollLeft; + var scrollToCell = _props.scrollToCell; + var scrollTop = _props.scrollTop; -var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + // If this component was first rendered server-side, scrollbar size will be undefined. + // In that event we need to remeasure. -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + if (!this._scrollbarSizeMeasured) { + this._scrollbarSize = (0, _scrollbarSize2.default)(); + this._scrollbarSizeMeasured = true; + this.setState({}); + } -/** - * A section of the Window. - * Window Sections are used to group nearby cells. - * This enables us to more quickly determine which cells to display in a given region of the Window. - * Sections have a fixed size and contain 0 to many cells (tracked by their indices). - */ -var Section = function () { - function Section(_ref) { - var height = _ref.height; - var width = _ref.width; - var x = _ref.x; - var y = _ref.y; + if (scrollToCell >= 0) { + this._updateScrollPositionForScrollToCell(); + } else if (scrollLeft >= 0 || scrollTop >= 0) { + this._setScrollPosition({ scrollLeft: scrollLeft, scrollTop: scrollTop }); + } - _classCallCheck(this, Section); + // Update onSectionRendered callback. + this._invokeOnSectionRenderedHelper(); - this.height = height; - this.width = width; - this.x = x; - this.y = y; + var _cellLayoutManager$ge = cellLayoutManager.getTotalSize(); - this._indexMap = {}; - this._indices = []; - } + var totalHeight = _cellLayoutManager$ge.height; + var totalWidth = _cellLayoutManager$ge.width; - /** Add a cell to this section. */ + // Initialize onScroll callback. + this._invokeOnScrollMemoizer({ + scrollLeft: scrollLeft || 0, + scrollTop: scrollTop || 0, + totalHeight: totalHeight, + totalWidth: totalWidth + }); + } + }, { + key: 'componentDidUpdate', + value: function componentDidUpdate(prevProps, prevState) { + var _props2 = this.props; + var height = _props2.height; + var scrollToCell = _props2.scrollToCell; + var width = _props2.width; + var _state = this.state; + var scrollLeft = _state.scrollLeft; + var scrollPositionChangeReason = _state.scrollPositionChangeReason; + var scrollToAlignment = _state.scrollToAlignment; + var scrollTop = _state.scrollTop; - _createClass(Section, [{ - key: 'addCellIndex', - value: function addCellIndex(_ref2) { - var index = _ref2.index; + // Make sure requested changes to :scrollLeft or :scrollTop get applied. + // Assigning to scrollLeft/scrollTop tells the browser to interrupt any running scroll animations, + // And to discard any pending async changes to the scroll position that may have happened in the meantime (e.g. on a separate scrolling thread). + // So we only set these when we require an adjustment of the scroll position. + // See issue #2 for more information. - if (!this._indexMap[index]) { - this._indexMap[index] = true; - this._indices.push(index); + if (scrollPositionChangeReason === SCROLL_POSITION_CHANGE_REASONS.REQUESTED) { + if (scrollLeft >= 0 && scrollLeft !== prevState.scrollLeft && scrollLeft !== this._scrollingContainer.scrollLeft) { + this._scrollingContainer.scrollLeft = scrollLeft; + } + if (scrollTop >= 0 && scrollTop !== prevState.scrollTop && scrollTop !== this._scrollingContainer.scrollTop) { + this._scrollingContainer.scrollTop = scrollTop; + } + } + + // Update scroll offsets if the current :scrollToCell values requires it + if (height !== prevProps.height || scrollToAlignment !== prevProps.scrollToAlignment || scrollToCell !== prevProps.scrollToCell || width !== prevProps.width) { + this._updateScrollPositionForScrollToCell(); } + + // Update onRowsRendered callback if start/stop indices have changed + this._invokeOnSectionRenderedHelper(); } + }, { + key: 'componentWillMount', + value: function componentWillMount() { + var cellLayoutManager = this.props.cellLayoutManager; - /** Get all cell indices that have been added to this section. */ + cellLayoutManager.calculateSizeAndPositionData(); + + // If this component is being rendered server-side, getScrollbarSize() will return undefined. + // We handle this case in componentDidMount() + this._scrollbarSize = (0, _scrollbarSize2.default)(); + if (this._scrollbarSize === undefined) { + this._scrollbarSizeMeasured = false; + this._scrollbarSize = 0; + } else { + this._scrollbarSizeMeasured = true; + } + } }, { - key: 'getCellIndices', - value: function getCellIndices() { - return this._indices; + key: 'componentWillUnmount', + value: function componentWillUnmount() { + if (this._disablePointerEventsTimeoutId) { + clearTimeout(this._disablePointerEventsTimeoutId); + } + + if (this._setNextStateAnimationFrameId) { + _raf2.default.cancel(this._setNextStateAnimationFrameId); + } } - /** Intended for debugger/test purposes only */ + /** + * @private + * This method updates scrollLeft/scrollTop in state for the following conditions: + * 1) Empty content (0 rows or columns) + * 2) New scroll props overriding the current state + * 3) Cells-count or cells-size has changed, making previous scroll offsets invalid + */ }, { - key: 'toString', - value: function toString() { - return this.x + ',' + this.y + ' ' + this.width + 'x' + this.height; + key: 'componentWillUpdate', + value: function componentWillUpdate(nextProps, nextState) { + if (nextProps.cellCount === 0 && (nextState.scrollLeft !== 0 || nextState.scrollTop !== 0)) { + this._setScrollPosition({ + scrollLeft: 0, + scrollTop: 0 + }); + } else if (nextProps.scrollLeft !== this.props.scrollLeft || nextProps.scrollTop !== this.props.scrollTop) { + this._setScrollPosition({ + scrollLeft: nextProps.scrollLeft, + scrollTop: nextProps.scrollTop + }); + } + + if (nextProps.cellCount !== this.props.cellCount || nextProps.cellLayoutManager !== this.props.cellLayoutManager || nextState.calculateSizeAndPositionDataOnNextUpdate) { + nextProps.cellLayoutManager.calculateSizeAndPositionData(); + } + + if (nextState.calculateSizeAndPositionDataOnNextUpdate) { + this.setState({ + calculateSizeAndPositionDataOnNextUpdate: false + }); + } } - }]); + }, { + key: 'render', + value: function render() { + var _this2 = this; - return Section; -}(); /** @rlow */ + var _props3 = this.props; + var autoHeight = _props3.autoHeight; + var cellCount = _props3.cellCount; + var cellLayoutManager = _props3.cellLayoutManager; + var className = _props3.className; + var height = _props3.height; + var horizontalOverscanSize = _props3.horizontalOverscanSize; + var noContentRenderer = _props3.noContentRenderer; + var style = _props3.style; + var verticalOverscanSize = _props3.verticalOverscanSize; + var width = _props3.width; + var _state2 = this.state; + var isScrolling = _state2.isScrolling; + var scrollLeft = _state2.scrollLeft; + var scrollTop = _state2.scrollTop; + + var _cellLayoutManager$ge2 = cellLayoutManager.getTotalSize(); + var totalHeight = _cellLayoutManager$ge2.height; + var totalWidth = _cellLayoutManager$ge2.width; -exports.default = Section; -},{}],46:[function(require,module,exports){ -'use strict'; + // Safely expand the rendered area by the specified overscan amount -Object.defineProperty(exports, "__esModule", { - value: true -}); + var left = Math.max(0, scrollLeft - horizontalOverscanSize); + var top = Math.max(0, scrollTop - verticalOverscanSize); + var right = Math.min(totalWidth, scrollLeft + width + horizontalOverscanSize); + var bottom = Math.min(totalHeight, scrollTop + height + verticalOverscanSize); + + var childrenToDisplay = height > 0 && width > 0 ? cellLayoutManager.cellRenderers({ + height: bottom - top, + isScrolling: isScrolling, + width: right - left, + x: left, + y: top + }) : []; -var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /** - * Window Sections are used to group nearby cells. - * This enables us to more quickly determine which cells to display in a given region of the Window. - * - */ + var collectionStyle = { + height: autoHeight ? 'auto' : height, + width: width + }; + // Force browser to hide scrollbars when we know they aren't necessary. + // Otherwise once scrollbars appear they may not disappear again. + // For more info see issue #116 + var verticalScrollBarSize = totalHeight > height ? this._scrollbarSize : 0; + var horizontalScrollBarSize = totalWidth > width ? this._scrollbarSize : 0; + if (totalWidth + verticalScrollBarSize <= width) { + collectionStyle.overflowX = 'hidden'; + } + if (totalHeight + horizontalScrollBarSize <= height) { + collectionStyle.overflowY = 'hidden'; + } -var _Section = require('./Section'); + return _react2.default.createElement( + 'div', + { + ref: function ref(_ref) { + _this2._scrollingContainer = _ref; + }, + 'aria-label': this.props['aria-label'], + className: (0, _classnames2.default)('Collection', className), + onScroll: this._onScroll, + role: 'grid', + style: _extends({}, collectionStyle, style), + tabIndex: 0 + }, + cellCount > 0 && _react2.default.createElement( + 'div', + { + className: 'Collection__innerScrollContainer', + style: { + height: totalHeight, + maxHeight: totalHeight, + maxWidth: totalWidth, + pointerEvents: isScrolling ? 'none' : '', + width: totalWidth + } + }, + childrenToDisplay + ), + cellCount === 0 && noContentRenderer() + ); + } + }, { + key: 'shouldComponentUpdate', + value: function shouldComponentUpdate(nextProps, nextState) { + return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState); + } -var _Section2 = _interopRequireDefault(_Section); + /* ---------------------------- Helper methods ---------------------------- */ -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + /** + * Sets an :isScrolling flag for a small window of time. + * This flag is used to disable pointer events on the scrollable portion of the Collection. + * This prevents jerky/stuttery mouse-wheel scrolling. + */ -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + }, { + key: '_enablePointerEventsAfterDelay', + value: function _enablePointerEventsAfterDelay() { + var _this3 = this; -var SECTION_SIZE = 100; + if (this._disablePointerEventsTimeoutId) { + clearTimeout(this._disablePointerEventsTimeoutId); + } -/** - * Contains 0 to many Sections. - * Grows (and adds Sections) dynamically as cells are registered. - * Automatically adds cells to the appropriate Section(s). - */ -var SectionManager = function () { - function SectionManager() { - var sectionSize = arguments.length <= 0 || arguments[0] === undefined ? SECTION_SIZE : arguments[0]; + this._disablePointerEventsTimeoutId = setTimeout(function () { + var isScrollingChange = _this3.props.isScrollingChange; - _classCallCheck(this, SectionManager); - this._sectionSize = sectionSize; + isScrollingChange(false); - this._cellMetadata = []; - this._sections = {}; - } + _this3._disablePointerEventsTimeoutId = null; + _this3.setState({ + isScrolling: false + }); + }, IS_SCROLLING_TIMEOUT); + } + }, { + key: '_invokeOnSectionRenderedHelper', + value: function _invokeOnSectionRenderedHelper() { + var _props4 = this.props; + var cellLayoutManager = _props4.cellLayoutManager; + var onSectionRendered = _props4.onSectionRendered; - /** - * Gets all cell indices contained in the specified region. - * A region may encompass 1 or more Sections. - */ + this._onSectionRenderedMemoizer({ + callback: onSectionRendered, + indices: { + indices: cellLayoutManager.getLastRenderedIndices() + } + }); + } + }, { + key: '_invokeOnScrollMemoizer', + value: function _invokeOnScrollMemoizer(_ref2) { + var _this4 = this; - _createClass(SectionManager, [{ - key: 'getCellIndices', - value: function getCellIndices(_ref) { - var height = _ref.height; - var width = _ref.width; - var x = _ref.x; - var y = _ref.y; + var scrollLeft = _ref2.scrollLeft; + var scrollTop = _ref2.scrollTop; + var totalHeight = _ref2.totalHeight; + var totalWidth = _ref2.totalWidth; - var indices = {}; + this._onScrollMemoizer({ + callback: function callback(_ref3) { + var scrollLeft = _ref3.scrollLeft; + var scrollTop = _ref3.scrollTop; + var _props5 = _this4.props; + var height = _props5.height; + var onScroll = _props5.onScroll; + var width = _props5.width; - this.getSections({ height: height, width: width, x: x, y: y }).forEach(function (section) { - return section.getCellIndices().forEach(function (index) { - indices[index] = index; - }); - }); - // Object keys are strings; this function returns numbers - return Object.keys(indices).map(function (index) { - return indices[index]; + onScroll({ + clientHeight: height, + clientWidth: width, + scrollHeight: totalHeight, + scrollLeft: scrollLeft, + scrollTop: scrollTop, + scrollWidth: totalWidth + }); + }, + indices: { + scrollLeft: scrollLeft, + scrollTop: scrollTop + } }); } - /** Get size and position information for the cell specified. */ + /** + * Updates the state during the next animation frame. + * Use this method to avoid multiple renders in a small span of time. + * This helps performance for bursty events (like onScroll). + */ }, { - key: 'getCellMetadata', - value: function getCellMetadata(_ref2) { - var index = _ref2.index; + key: '_setNextState', + value: function _setNextState(state) { + var _this5 = this; - return this._cellMetadata[index]; + if (this._setNextStateAnimationFrameId) { + _raf2.default.cancel(this._setNextStateAnimationFrameId); + } + + this._setNextStateAnimationFrameId = (0, _raf2.default)(function () { + _this5._setNextStateAnimationFrameId = null; + _this5.setState(state); + }); } + }, { + key: '_setScrollPosition', + value: function _setScrollPosition(_ref4) { + var scrollLeft = _ref4.scrollLeft; + var scrollTop = _ref4.scrollTop; - /** Get all Sections overlapping the specified region. */ + var newState = { + scrollPositionChangeReason: SCROLL_POSITION_CHANGE_REASONS.REQUESTED + }; - }, { - key: 'getSections', - value: function getSections(_ref3) { - var height = _ref3.height; - var width = _ref3.width; - var x = _ref3.x; - var y = _ref3.y; + if (scrollLeft >= 0) { + newState.scrollLeft = scrollLeft; + } - var sectionXStart = Math.floor(x / this._sectionSize); - var sectionXStop = Math.floor((x + width - 1) / this._sectionSize); - var sectionYStart = Math.floor(y / this._sectionSize); - var sectionYStop = Math.floor((y + height - 1) / this._sectionSize); + if (scrollTop >= 0) { + newState.scrollTop = scrollTop; + } - var sections = []; + if (scrollLeft >= 0 && scrollLeft !== this.state.scrollLeft || scrollTop >= 0 && scrollTop !== this.state.scrollTop) { + this.setState(newState); + } + } + }, { + key: '_updateScrollPositionForScrollToCell', + value: function _updateScrollPositionForScrollToCell() { + var _props6 = this.props; + var cellLayoutManager = _props6.cellLayoutManager; + var height = _props6.height; + var scrollToAlignment = _props6.scrollToAlignment; + var scrollToCell = _props6.scrollToCell; + var width = _props6.width; + var _state3 = this.state; + var scrollLeft = _state3.scrollLeft; + var scrollTop = _state3.scrollTop; - for (var sectionX = sectionXStart; sectionX <= sectionXStop; sectionX++) { - for (var sectionY = sectionYStart; sectionY <= sectionYStop; sectionY++) { - var key = sectionX + '.' + sectionY; - if (!this._sections[key]) { - this._sections[key] = new _Section2.default({ - height: this._sectionSize, - width: this._sectionSize, - x: sectionX * this._sectionSize, - y: sectionY * this._sectionSize - }); - } + if (scrollToCell >= 0) { + var scrollPosition = cellLayoutManager.getScrollPositionForCell({ + align: scrollToAlignment, + cellIndex: scrollToCell, + height: height, + scrollLeft: scrollLeft, + scrollTop: scrollTop, + width: width + }); - sections.push(this._sections[key]); + if (scrollPosition.scrollLeft !== scrollLeft || scrollPosition.scrollTop !== scrollTop) { + this._setScrollPosition(scrollPosition); } } + } + }, { + key: '_onScroll', + value: function _onScroll(event) { + // In certain edge-cases React dispatches an onScroll event with an invalid target.scrollLeft / target.scrollTop. + // This invalid event can be detected by comparing event.target to this component's scrollable DOM element. + // See issue #404 for more information. + if (event.target !== this._scrollingContainer) { + return; + } - return sections; - } + // Prevent pointer events from interrupting a smooth scroll + this._enablePointerEventsAfterDelay(); - /** Total number of Sections based on the currently registered cells. */ + // When this component is shrunk drastically, React dispatches a series of back-to-back scroll events, + // Gradually converging on a scrollTop that is within the bounds of the new, smaller height. + // This causes a series of rapid renders that is slow for long lists. + // We can avoid that by doing some simple bounds checking to ensure that scrollTop never exceeds the total height. + var _props7 = this.props; + var cellLayoutManager = _props7.cellLayoutManager; + var height = _props7.height; + var isScrollingChange = _props7.isScrollingChange; + var width = _props7.width; - }, { - key: 'getTotalSectionCount', - value: function getTotalSectionCount() { - return Object.keys(this._sections).length; - } + var scrollbarSize = this._scrollbarSize; - /** Intended for debugger/test purposes only */ + var _cellLayoutManager$ge3 = cellLayoutManager.getTotalSize(); - }, { - key: 'toString', - value: function toString() { - var _this = this; + var totalHeight = _cellLayoutManager$ge3.height; + var totalWidth = _cellLayoutManager$ge3.width; - return Object.keys(this._sections).map(function (index) { - return _this._sections[index].toString(); - }); - } + var scrollLeft = Math.max(0, Math.min(totalWidth - width + scrollbarSize, event.target.scrollLeft)); + var scrollTop = Math.max(0, Math.min(totalHeight - height + scrollbarSize, event.target.scrollTop)); - /** Adds a cell to the appropriate Sections and registers it metadata for later retrievable. */ + // Certain devices (like Apple touchpad) rapid-fire duplicate events. + // Don't force a re-render if this is the case. + // The mouse may move faster then the animation frame does. + // Use requestAnimationFrame to avoid over-updating. + if (this.state.scrollLeft !== scrollLeft || this.state.scrollTop !== scrollTop) { + // Browsers with cancelable scroll events (eg. Firefox) interrupt scrolling animations if scrollTop/scrollLeft is set. + // Other browsers (eg. Safari) don't scroll as well without the help under certain conditions (DOM or style changes during scrolling). + // All things considered, this seems to be the best current work around that I'm aware of. + // For more information see https://github.com/bvaughn/react-virtualized/pull/124 + var scrollPositionChangeReason = event.cancelable ? SCROLL_POSITION_CHANGE_REASONS.OBSERVED : SCROLL_POSITION_CHANGE_REASONS.REQUESTED; - }, { - key: 'registerCell', - value: function registerCell(_ref4) { - var cellMetadatum = _ref4.cellMetadatum; - var index = _ref4.index; + // Synchronously set :isScrolling the first time (since _setNextState will reschedule its animation frame each time it's called) + if (!this.state.isScrolling) { + isScrollingChange(true); - this._cellMetadata[index] = cellMetadatum; + this.setState({ + isScrolling: true + }); + } - this.getSections(cellMetadatum).forEach(function (section) { - return section.addCellIndex({ index: index }); + this._setNextState({ + isScrolling: true, + scrollLeft: scrollLeft, + scrollPositionChangeReason: scrollPositionChangeReason, + scrollTop: scrollTop + }); + } + + this._invokeOnScrollMemoizer({ + scrollLeft: scrollLeft, + scrollTop: scrollTop, + totalWidth: totalWidth, + totalHeight: totalHeight }); } }]); - return SectionManager; -}(); + return CollectionView; +}(_react.Component); -exports.default = SectionManager; -},{"./Section":45}],47:[function(require,module,exports){ -'use strict'; +CollectionView.propTypes = { + 'aria-label': _react.PropTypes.string, -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.Collection = exports.default = undefined; + /** + * Removes fixed height from the scrollingContainer so that the total height + * of rows can stretch the window. Intended for use with WindowScroller + */ + autoHeight: _react.PropTypes.bool, -var _Collection2 = require('./Collection'); + /** + * Number of cells in collection. + */ + cellCount: _react.PropTypes.number.isRequired, -var _Collection3 = _interopRequireDefault(_Collection2); + /** + * Calculates cell sizes and positions and manages rendering the appropriate cells given a specified window. + */ + cellLayoutManager: _react.PropTypes.object.isRequired, -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + /** + * Optional custom CSS class name to attach to root Collection element. + */ + className: _react.PropTypes.string, -exports.default = _Collection3.default; -exports.Collection = _Collection3.default; -},{"./Collection":43}],48:[function(require,module,exports){ -'use strict'; + /** + * Height of Collection; this property determines the number of visible (vs virtualized) rows. + */ + height: _react.PropTypes.number.isRequired, -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = calculateSizeAndPositionData; + /** + * Enables the `Collection` to horiontally "overscan" its content similar to how `Grid` does. + * This can reduce flicker around the edges when a user scrolls quickly. + */ + horizontalOverscanSize: _react.PropTypes.number.isRequired, -var _SectionManager = require('../SectionManager'); + isScrollingChange: _react.PropTypes.func, -var _SectionManager2 = _interopRequireDefault(_SectionManager); + /** + * Optional renderer to be used in place of rows when either :rowCount or :cellCount is 0. + */ + noContentRenderer: _react.PropTypes.func.isRequired, -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + /** + * Callback invoked whenever the scroll offset changes within the inner scrollable region. + * This callback can be used to sync scrolling between lists, tables, or grids. + * ({ clientHeight, clientWidth, scrollHeight, scrollLeft, scrollTop, scrollWidth }): void + */ + onScroll: _react.PropTypes.func.isRequired, -function calculateSizeAndPositionData(_ref) { - var cellCount = _ref.cellCount; - var cellSizeAndPositionGetter = _ref.cellSizeAndPositionGetter; - var sectionSize = _ref.sectionSize; + /** + * Callback invoked with information about the section of the Collection that was just rendered. + * This callback is passed a named :indices parameter which is an Array of the most recently rendered section indices. + */ + onSectionRendered: _react.PropTypes.func.isRequired, - var cellMetadata = []; - var sectionManager = new _SectionManager2.default(sectionSize); - var height = 0; - var width = 0; + /** + * Horizontal offset. + */ + scrollLeft: _react.PropTypes.number, - for (var index = 0; index < cellCount; index++) { - var cellMetadatum = cellSizeAndPositionGetter({ index: index }); + /** + * Controls scroll-to-cell behavior of the Grid. + * The default ("auto") scrolls the least amount possible to ensure that the specified cell is fully visible. + * Use "start" to align cells to the top/left of the Grid and "end" to align bottom/right. + */ + scrollToAlignment: _react.PropTypes.oneOf(['auto', 'end', 'start', 'center']).isRequired, - if (cellMetadatum.height == null || isNaN(cellMetadatum.height) || cellMetadatum.width == null || isNaN(cellMetadatum.width) || cellMetadatum.x == null || isNaN(cellMetadatum.x) || cellMetadatum.y == null || isNaN(cellMetadatum.y)) { - throw Error('Invalid metadata returned for cell ' + index + ':\n x:' + cellMetadatum.x + ', y:' + cellMetadatum.y + ', width:' + cellMetadatum.width + ', height:' + cellMetadatum.height); - } + /** + * Cell index to ensure visible (by forcefully scrolling if necessary). + */ + scrollToCell: _react.PropTypes.number, - height = Math.max(height, cellMetadatum.y + cellMetadatum.height); - width = Math.max(width, cellMetadatum.x + cellMetadatum.width); + /** + * Vertical offset. + */ + scrollTop: _react.PropTypes.number, - cellMetadata[index] = cellMetadatum; - sectionManager.registerCell({ - cellMetadatum: cellMetadatum, - index: index - }); - } + /** + * Optional custom inline style to attach to root Collection element. + */ + style: _react.PropTypes.object, - return { - cellMetadata: cellMetadata, - height: height, - sectionManager: sectionManager, - width: width - }; -} -},{"../SectionManager":46}],49:[function(require,module,exports){ + /** + * Enables the `Collection` to vertically "overscan" its content similar to how `Grid` does. + * This can reduce flicker around the edges when a user scrolls quickly. + */ + verticalOverscanSize: _react.PropTypes.number.isRequired, + + /** + * Width of Collection; this property determines the number of visible (vs virtualized) columns. + */ + width: _react.PropTypes.number.isRequired +}; +CollectionView.defaultProps = { + 'aria-label': 'grid', + horizontalOverscanSize: 0, + noContentRenderer: function noContentRenderer() { + return null; + }, + onScroll: function onScroll() { + return null; + }, + onSectionRendered: function onSectionRendered() { + return null; + }, + scrollToAlignment: 'auto', + style: {}, + verticalOverscanSize: 0 +}; +exports.default = CollectionView; +},{"../utils/createCallbackMemoizer":76,"classnames":undefined,"dom-helpers/util/scrollbarSize":80,"raf":81,"react":undefined,"react-addons-shallow-compare":18}],43:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { @@ -5011,300 +5088,306 @@ Object.defineProperty(exports, "__esModule", { var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); -var _react = require('react'); - -var _reactAddonsShallowCompare = require('react-addons-shallow-compare'); - -var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); - -var _Grid = require('../Grid'); - -var _Grid2 = _interopRequireDefault(_Grid); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } - /** - * High-order component that auto-calculates column-widths for `Grid` cells. + * A section of the Window. + * Window Sections are used to group nearby cells. + * This enables us to more quickly determine which cells to display in a given region of the Window. + * Sections have a fixed size and contain 0 to many cells (tracked by their indices). */ -var ColumnSizer = function (_Component) { - _inherits(ColumnSizer, _Component); +var Section = function () { + function Section(_ref) { + var height = _ref.height; + var width = _ref.width; + var x = _ref.x; + var y = _ref.y; - function ColumnSizer(props, context) { - _classCallCheck(this, ColumnSizer); + _classCallCheck(this, Section); - var _this = _possibleConstructorReturn(this, (ColumnSizer.__proto__ || Object.getPrototypeOf(ColumnSizer)).call(this, props, context)); + this.height = height; + this.width = width; + this.x = x; + this.y = y; - _this._registerChild = _this._registerChild.bind(_this); - return _this; + this._indexMap = {}; + this._indices = []; } - _createClass(ColumnSizer, [{ - key: 'componentDidUpdate', - value: function componentDidUpdate(prevProps, prevState) { - var _props = this.props; - var columnMaxWidth = _props.columnMaxWidth; - var columnMinWidth = _props.columnMinWidth; - var columnCount = _props.columnCount; - var width = _props.width; + /** Add a cell to this section. */ - if (columnMaxWidth !== prevProps.columnMaxWidth || columnMinWidth !== prevProps.columnMinWidth || columnCount !== prevProps.columnCount || width !== prevProps.width) { - if (this._registeredChild) { - this._registeredChild.recomputeGridSize(); - } + _createClass(Section, [{ + key: 'addCellIndex', + value: function addCellIndex(_ref2) { + var index = _ref2.index; + + if (!this._indexMap[index]) { + this._indexMap[index] = true; + this._indices.push(index); } } - }, { - key: 'render', - value: function render() { - var _props2 = this.props; - var children = _props2.children; - var columnMaxWidth = _props2.columnMaxWidth; - var columnMinWidth = _props2.columnMinWidth; - var columnCount = _props2.columnCount; - var width = _props2.width; - - - var safeColumnMinWidth = columnMinWidth || 1; - - var safeColumnMaxWidth = columnMaxWidth ? Math.min(columnMaxWidth, width) : width; - - var columnWidth = width / columnCount; - columnWidth = Math.max(safeColumnMinWidth, columnWidth); - columnWidth = Math.min(safeColumnMaxWidth, columnWidth); - columnWidth = Math.floor(columnWidth); - var adjustedWidth = Math.min(width, columnWidth * columnCount); + /** Get all cell indices that have been added to this section. */ - return children({ - adjustedWidth: adjustedWidth, - getColumnWidth: function getColumnWidth() { - return columnWidth; - }, - registerChild: this._registerChild - }); - } }, { - key: 'shouldComponentUpdate', - value: function shouldComponentUpdate(nextProps, nextState) { - return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState); + key: 'getCellIndices', + value: function getCellIndices() { + return this._indices; } - }, { - key: '_registerChild', - value: function _registerChild(child) { - if (child !== null && !(child instanceof _Grid2.default)) { - throw Error('Unexpected child type registered; only Grid children are supported.'); - } - this._registeredChild = child; + /** Intended for debugger/test purposes only */ - if (this._registeredChild) { - this._registeredChild.recomputeGridSize(); - } + }, { + key: 'toString', + value: function toString() { + return this.x + ',' + this.y + ' ' + this.width + 'x' + this.height; } }]); - return ColumnSizer; -}(_react.Component); - -ColumnSizer.propTypes = { - /** - * Function respondible for rendering a virtualized Grid. - * This function should implement the following signature: - * ({ adjustedWidth, getColumnWidth, registerChild }) => PropTypes.element - * - * The specified :getColumnWidth function should be passed to the Grid's :columnWidth property. - * The :registerChild should be passed to the Grid's :ref property. - * The :adjustedWidth property is optional; it reflects the lesser of the overall width or the width of all columns. - */ - children: _react.PropTypes.func.isRequired, - - /** Optional maximum allowed column width */ - columnMaxWidth: _react.PropTypes.number, - - /** Optional minimum allowed column width */ - columnMinWidth: _react.PropTypes.number, + return Section; +}(); /** @rlow */ - /** Number of columns in Grid or FlexTable child */ - columnCount: _react.PropTypes.number.isRequired, - /** Width of Grid or FlexTable child */ - width: _react.PropTypes.number.isRequired -}; -exports.default = ColumnSizer; -},{"../Grid":62,"react":undefined,"react-addons-shallow-compare":30}],50:[function(require,module,exports){ +exports.default = Section; +},{}],44:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); -exports.ColumnSizer = exports.default = undefined; -var _ColumnSizer2 = require('./ColumnSizer'); +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /** + * Window Sections are used to group nearby cells. + * This enables us to more quickly determine which cells to display in a given region of the Window. + * + */ -var _ColumnSizer3 = _interopRequireDefault(_ColumnSizer2); + +var _Section = require('./Section'); + +var _Section2 = _interopRequireDefault(_Section); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } -exports.default = _ColumnSizer3.default; -exports.ColumnSizer = _ColumnSizer3.default; -},{"./ColumnSizer":49}],51:[function(require,module,exports){ -'use strict'; +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -Object.defineProperty(exports, "__esModule", { - value: true -}); +var SECTION_SIZE = 100; -var _react = require('react'); +/** + * Contains 0 to many Sections. + * Grows (and adds Sections) dynamically as cells are registered. + * Automatically adds cells to the appropriate Section(s). + */ +var SectionManager = function () { + function SectionManager() { + var sectionSize = arguments.length <= 0 || arguments[0] === undefined ? SECTION_SIZE : arguments[0]; -var _defaultHeaderRenderer = require('./defaultHeaderRenderer'); + _classCallCheck(this, SectionManager); -var _defaultHeaderRenderer2 = _interopRequireDefault(_defaultHeaderRenderer); + this._sectionSize = sectionSize; -var _defaultCellRenderer = require('./defaultCellRenderer'); + this._cellMetadata = []; + this._sections = {}; + } -var _defaultCellRenderer2 = _interopRequireDefault(_defaultCellRenderer); + /** + * Gets all cell indices contained in the specified region. + * A region may encompass 1 or more Sections. + */ -var _defaultCellDataGetter = require('./defaultCellDataGetter'); -var _defaultCellDataGetter2 = _interopRequireDefault(_defaultCellDataGetter); + _createClass(SectionManager, [{ + key: 'getCellIndices', + value: function getCellIndices(_ref) { + var height = _ref.height; + var width = _ref.width; + var x = _ref.x; + var y = _ref.y; -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + var indices = {}; -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + this.getSections({ height: height, width: width, x: x, y: y }).forEach(function (section) { + return section.getCellIndices().forEach(function (index) { + indices[index] = index; + }); + }); -function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + // Object keys are strings; this function returns numbers + return Object.keys(indices).map(function (index) { + return indices[index]; + }); + } -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + /** Get size and position information for the cell specified. */ -/** - * Describes the header and cell contents of a table column. - */ -var Column = function (_Component) { - _inherits(Column, _Component); + }, { + key: 'getCellMetadata', + value: function getCellMetadata(_ref2) { + var index = _ref2.index; - function Column() { - _classCallCheck(this, Column); + return this._cellMetadata[index]; + } - return _possibleConstructorReturn(this, (Column.__proto__ || Object.getPrototypeOf(Column)).apply(this, arguments)); - } + /** Get all Sections overlapping the specified region. */ - return Column; -}(_react.Component); + }, { + key: 'getSections', + value: function getSections(_ref3) { + var height = _ref3.height; + var width = _ref3.width; + var x = _ref3.x; + var y = _ref3.y; -Column.defaultProps = { - cellDataGetter: _defaultCellDataGetter2.default, - cellRenderer: _defaultCellRenderer2.default, - flexGrow: 0, - flexShrink: 1, - headerRenderer: _defaultHeaderRenderer2.default, - style: {} -}; -Column.propTypes = { - /** Optional aria-label value to set on the column header */ - 'aria-label': _react.PropTypes.string, + var sectionXStart = Math.floor(x / this._sectionSize); + var sectionXStop = Math.floor((x + width - 1) / this._sectionSize); + var sectionYStart = Math.floor(y / this._sectionSize); + var sectionYStop = Math.floor((y + height - 1) / this._sectionSize); - /** - * Callback responsible for returning a cell's data, given its :dataKey - * ({ columnData: any, dataKey: string, rowData: any }): any - */ - cellDataGetter: _react.PropTypes.func, + var sections = []; - /** - * Callback responsible for rendering a cell's contents. - * ({ cellData: any, columnData: any, dataKey: string, rowData: any, rowIndex: number }): node - */ - cellRenderer: _react.PropTypes.func, + for (var sectionX = sectionXStart; sectionX <= sectionXStop; sectionX++) { + for (var sectionY = sectionYStart; sectionY <= sectionYStop; sectionY++) { + var key = sectionX + '.' + sectionY; - /** Optional CSS class to apply to cell */ - className: _react.PropTypes.string, + if (!this._sections[key]) { + this._sections[key] = new _Section2.default({ + height: this._sectionSize, + width: this._sectionSize, + x: sectionX * this._sectionSize, + y: sectionY * this._sectionSize + }); + } + + sections.push(this._sections[key]); + } + } + + return sections; + } + + /** Total number of Sections based on the currently registered cells. */ + + }, { + key: 'getTotalSectionCount', + value: function getTotalSectionCount() { + return Object.keys(this._sections).length; + } + + /** Intended for debugger/test purposes only */ + + }, { + key: 'toString', + value: function toString() { + var _this = this; - /** Optional additional data passed to this column's :cellDataGetter */ - columnData: _react.PropTypes.object, + return Object.keys(this._sections).map(function (index) { + return _this._sections[index].toString(); + }); + } - /** Uniquely identifies the row-data attribute correspnding to this cell */ - dataKey: _react.PropTypes.any.isRequired, + /** Adds a cell to the appropriate Sections and registers it metadata for later retrievable. */ - /** If sort is enabled for the table at large, disable it for this column */ - disableSort: _react.PropTypes.bool, + }, { + key: 'registerCell', + value: function registerCell(_ref4) { + var cellMetadatum = _ref4.cellMetadatum; + var index = _ref4.index; - /** Flex grow style; defaults to 0 */ - flexGrow: _react.PropTypes.number, + this._cellMetadata[index] = cellMetadatum; - /** Flex shrink style; defaults to 1 */ - flexShrink: _react.PropTypes.number, + this.getSections(cellMetadatum).forEach(function (section) { + return section.addCellIndex({ index: index }); + }); + } + }]); - /** Optional CSS class to apply to this column's header */ - headerClassName: _react.PropTypes.string, + return SectionManager; +}(); - /** - * Optional callback responsible for rendering a column header contents. - * ({ columnData: object, dataKey: string, disableSort: boolean, label: string, sortBy: string, sortDirection: string }): PropTypes.node - */ - headerRenderer: _react.PropTypes.func.isRequired, +exports.default = SectionManager; +},{"./Section":43}],45:[function(require,module,exports){ +'use strict'; - /** Header label for this column */ - label: _react.PropTypes.string, +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.Collection = exports.default = undefined; - /** Maximum width of column; this property will only be used if :flexGrow is > 0. */ - maxWidth: _react.PropTypes.number, +var _Collection2 = require('./Collection'); - /** Minimum width of column. */ - minWidth: _react.PropTypes.number, +var _Collection3 = _interopRequireDefault(_Collection2); - /** Optional inline style to apply to cell */ - style: _react.PropTypes.object, +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - /** Flex basis (width) for this column; This value can grow or shrink based on :flexGrow and :flexShrink properties. */ - width: _react.PropTypes.number.isRequired -}; -exports.default = Column; -},{"./defaultCellDataGetter":55,"./defaultCellRenderer":56,"./defaultHeaderRenderer":57,"react":undefined}],52:[function(require,module,exports){ +exports.default = _Collection3.default; +exports.Collection = _Collection3.default; +},{"./Collection":41}],46:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = calculateSizeAndPositionData; -var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; +var _SectionManager = require('../SectionManager'); -var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); +var _SectionManager2 = _interopRequireDefault(_SectionManager); -var _classnames = require('classnames'); +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } -var _classnames2 = _interopRequireDefault(_classnames); +function calculateSizeAndPositionData(_ref) { + var cellCount = _ref.cellCount; + var cellSizeAndPositionGetter = _ref.cellSizeAndPositionGetter; + var sectionSize = _ref.sectionSize; -var _FlexColumn = require('./FlexColumn'); + var cellMetadata = []; + var sectionManager = new _SectionManager2.default(sectionSize); + var height = 0; + var width = 0; -var _FlexColumn2 = _interopRequireDefault(_FlexColumn); + for (var index = 0; index < cellCount; index++) { + var cellMetadatum = cellSizeAndPositionGetter({ index: index }); -var _react = require('react'); + if (cellMetadatum.height == null || isNaN(cellMetadatum.height) || cellMetadatum.width == null || isNaN(cellMetadatum.width) || cellMetadatum.x == null || isNaN(cellMetadatum.x) || cellMetadatum.y == null || isNaN(cellMetadatum.y)) { + throw Error('Invalid metadata returned for cell ' + index + ':\n x:' + cellMetadatum.x + ', y:' + cellMetadatum.y + ', width:' + cellMetadatum.width + ', height:' + cellMetadatum.height); + } -var _react2 = _interopRequireDefault(_react); + height = Math.max(height, cellMetadatum.y + cellMetadatum.height); + width = Math.max(width, cellMetadatum.x + cellMetadatum.width); -var _reactDom = require('react-dom'); + cellMetadata[index] = cellMetadatum; + sectionManager.registerCell({ + cellMetadatum: cellMetadatum, + index: index + }); + } -var _reactAddonsShallowCompare = require('react-addons-shallow-compare'); + return { + cellMetadata: cellMetadata, + height: height, + sectionManager: sectionManager, + width: width + }; +} +},{"../SectionManager":44}],47:[function(require,module,exports){ +'use strict'; -var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); +Object.defineProperty(exports, "__esModule", { + value: true +}); -var _Grid = require('../Grid'); +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); -var _Grid2 = _interopRequireDefault(_Grid); +var _react = require('react'); -var _defaultRowRenderer = require('./defaultRowRenderer'); +var _reactAddonsShallowCompare = require('react-addons-shallow-compare'); -var _defaultRowRenderer2 = _interopRequireDefault(_defaultRowRenderer); +var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); -var _SortDirection = require('./SortDirection'); +var _Grid = require('../Grid'); -var _SortDirection2 = _interopRequireDefault(_SortDirection); +var _Grid2 = _interopRequireDefault(_Grid); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -5315,140 +5398,65 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** - * Table component with fixed headers and virtualized rows for improved performance with large data sets. - * This component expects explicit width, height, and padding parameters. + * High-order component that auto-calculates column-widths for `Grid` cells. */ -var FlexTable = function (_Component) { - _inherits(FlexTable, _Component); - - function FlexTable(props) { - _classCallCheck(this, FlexTable); +var ColumnSizer = function (_Component) { + _inherits(ColumnSizer, _Component); - var _this = _possibleConstructorReturn(this, (FlexTable.__proto__ || Object.getPrototypeOf(FlexTable)).call(this, props)); + function ColumnSizer(props, context) { + _classCallCheck(this, ColumnSizer); - _this.state = { - scrollbarWidth: 0 - }; + var _this = _possibleConstructorReturn(this, (ColumnSizer.__proto__ || Object.getPrototypeOf(ColumnSizer)).call(this, props, context)); - _this._cellClassName = _this._cellClassName.bind(_this); - _this._cellStyle = _this._cellStyle.bind(_this); - _this._createColumn = _this._createColumn.bind(_this); - _this._createRow = _this._createRow.bind(_this); - _this._onScroll = _this._onScroll.bind(_this); - _this._onSectionRendered = _this._onSectionRendered.bind(_this); + _this._registerChild = _this._registerChild.bind(_this); return _this; } - _createClass(FlexTable, [{ - key: 'forceUpdateGrid', - value: function forceUpdateGrid() { - this.Grid.forceUpdate(); - } - - /** See Grid#measureAllCells */ - - }, { - key: 'measureAllRows', - value: function measureAllRows() { - this.Grid.measureAllCells(); - } - - /** See Grid#recomputeGridSize */ - - }, { - key: 'recomputeRowHeights', - value: function recomputeRowHeights() { - var index = arguments.length <= 0 || arguments[0] === undefined ? 0 : arguments[0]; - - this.Grid.recomputeGridSize({ - rowIndex: index - }); - this.forceUpdateGrid(); - } - }, { - key: 'componentDidMount', - value: function componentDidMount() { - this._setScrollbarWidth(); - } - }, { + _createClass(ColumnSizer, [{ key: 'componentDidUpdate', - value: function componentDidUpdate() { - this._setScrollbarWidth(); - } - }, { - key: 'render', - value: function render() { - var _this2 = this; - + value: function componentDidUpdate(prevProps, prevState) { var _props = this.props; - var children = _props.children; - var className = _props.className; - var disableHeader = _props.disableHeader; - var gridClassName = _props.gridClassName; - var gridStyle = _props.gridStyle; - var headerHeight = _props.headerHeight; - var height = _props.height; - var noRowsRenderer = _props.noRowsRenderer; - var rowClassName = _props.rowClassName; - var rowStyle = _props.rowStyle; - var scrollToIndex = _props.scrollToIndex; - var style = _props.style; + var columnMaxWidth = _props.columnMaxWidth; + var columnMinWidth = _props.columnMinWidth; + var columnCount = _props.columnCount; var width = _props.width; - var scrollbarWidth = this.state.scrollbarWidth; - - - var availableRowsHeight = height - headerHeight; - - var rowClass = rowClassName instanceof Function ? rowClassName({ index: -1 }) : rowClassName; - var rowStyleObject = rowStyle instanceof Function ? rowStyle({ index: -1 }) : rowStyle; - // Precompute and cache column styles before rendering rows and columns to speed things up - this._cachedColumnStyles = []; - _react2.default.Children.toArray(children).forEach(function (column, index) { - _this2._cachedColumnStyles[index] = _this2._getFlexStyleForColumn(column, column.props.style); - }); - // Note that we specify :numChildren, :scrollbarWidth, :sortBy, and :sortDirection as properties on Grid even though these have nothing to do with Grid. - // This is done because Grid is a pure component and won't update unless its properties or state has changed. - // Any property that should trigger a re-render of Grid then is specified here to avoid a stale display. - return _react2.default.createElement( - 'div', - { - className: (0, _classnames2.default)('FlexTable', className), - style: style - }, - !disableHeader && _react2.default.createElement( - 'div', - { - className: (0, _classnames2.default)('FlexTable__headerRow', rowClass), - style: _extends({}, rowStyleObject, { - height: headerHeight, - paddingRight: scrollbarWidth, - width: width - }) - }, - this._getRenderedHeaderRow() - ), - _react2.default.createElement(_Grid2.default, _extends({}, this.props, { - autoContainerWidth: true, - className: (0, _classnames2.default)('FlexTable__Grid', gridClassName), - cellClassName: this._cellClassName, - cellRenderer: this._createRow, - cellStyle: this._cellStyle, - columnWidth: width, - columnCount: 1, - height: availableRowsHeight, - noContentRenderer: noRowsRenderer, - onScroll: this._onScroll, - onSectionRendered: this._onSectionRendered, - ref: function ref(_ref) { - _this2.Grid = _ref; - }, - scrollbarWidth: scrollbarWidth, - scrollToRow: scrollToIndex, - style: gridStyle - })) - ); + if (columnMaxWidth !== prevProps.columnMaxWidth || columnMinWidth !== prevProps.columnMinWidth || columnCount !== prevProps.columnCount || width !== prevProps.width) { + if (this._registeredChild) { + this._registeredChild.recomputeGridSize(); + } + } + } + }, { + key: 'render', + value: function render() { + var _props2 = this.props; + var children = _props2.children; + var columnMaxWidth = _props2.columnMaxWidth; + var columnMinWidth = _props2.columnMinWidth; + var columnCount = _props2.columnCount; + var width = _props2.width; + + + var safeColumnMinWidth = columnMinWidth || 1; + + var safeColumnMaxWidth = columnMaxWidth ? Math.min(columnMaxWidth, width) : width; + + var columnWidth = width / columnCount; + columnWidth = Math.max(safeColumnMinWidth, columnWidth); + columnWidth = Math.min(safeColumnMaxWidth, columnWidth); + columnWidth = Math.floor(columnWidth); + + var adjustedWidth = Math.min(width, columnWidth * columnCount); + + return children({ + adjustedWidth: adjustedWidth, + getColumnWidth: function getColumnWidth() { + return columnWidth; + }, + registerChild: this._registerChild + }); } }, { key: 'shouldComponentUpdate', @@ -5456,780 +5464,867 @@ var FlexTable = function (_Component) { return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState); } }, { - key: '_cellClassName', - value: function _cellClassName(_ref2) { - var rowIndex = _ref2.rowIndex; - var rowWrapperClassName = this.props.rowWrapperClassName; + key: '_registerChild', + value: function _registerChild(child) { + if (child !== null && !(child instanceof _Grid2.default)) { + throw Error('Unexpected child type registered; only Grid children are supported.'); + } + this._registeredChild = child; - return rowWrapperClassName instanceof Function ? rowWrapperClassName({ index: rowIndex - 1 }) : rowWrapperClassName; + if (this._registeredChild) { + this._registeredChild.recomputeGridSize(); + } } - }, { - key: '_cellStyle', - value: function _cellStyle(_ref3) { - var rowIndex = _ref3.rowIndex; - var rowWrapperStyle = this.props.rowWrapperStyle; + }]); + return ColumnSizer; +}(_react.Component); - return rowWrapperStyle instanceof Function ? rowWrapperStyle({ index: rowIndex - 1 }) : rowWrapperStyle; - } - }, { - key: '_createColumn', - value: function _createColumn(_ref4) { - var column = _ref4.column; - var columnIndex = _ref4.columnIndex; - var isScrolling = _ref4.isScrolling; - var rowData = _ref4.rowData; - var rowIndex = _ref4.rowIndex; - var _column$props = column.props; - var cellDataGetter = _column$props.cellDataGetter; - var cellRenderer = _column$props.cellRenderer; - var className = _column$props.className; - var columnData = _column$props.columnData; - var dataKey = _column$props.dataKey; +ColumnSizer.propTypes = { + /** + * Function respondible for rendering a virtualized Grid. + * This function should implement the following signature: + * ({ adjustedWidth, getColumnWidth, registerChild }) => PropTypes.element + * + * The specified :getColumnWidth function should be passed to the Grid's :columnWidth property. + * The :registerChild should be passed to the Grid's :ref property. + * The :adjustedWidth property is optional; it reflects the lesser of the overall width or the width of all columns. + */ + children: _react.PropTypes.func.isRequired, + /** Optional maximum allowed column width */ + columnMaxWidth: _react.PropTypes.number, - var cellData = cellDataGetter({ columnData: columnData, dataKey: dataKey, rowData: rowData }); - var renderedCell = cellRenderer({ cellData: cellData, columnData: columnData, dataKey: dataKey, isScrolling: isScrolling, rowData: rowData, rowIndex: rowIndex }); + /** Optional minimum allowed column width */ + columnMinWidth: _react.PropTypes.number, - var style = this._cachedColumnStyles[columnIndex]; + /** Number of columns in Grid or FlexTable child */ + columnCount: _react.PropTypes.number.isRequired, - var title = typeof renderedCell === 'string' ? renderedCell : null; + /** Width of Grid or FlexTable child */ + width: _react.PropTypes.number.isRequired +}; +exports.default = ColumnSizer; +},{"../Grid":60,"react":undefined,"react-addons-shallow-compare":18}],48:[function(require,module,exports){ +'use strict'; - return _react2.default.createElement( - 'div', - { - key: 'Row' + rowIndex + '-Col' + columnIndex, - className: (0, _classnames2.default)('FlexTable__rowColumn', className), - style: style, - title: title - }, - renderedCell - ); - } - }, { - key: '_createHeader', - value: function _createHeader(_ref5) { - var column = _ref5.column; - var index = _ref5.index; - var _props2 = this.props; - var headerClassName = _props2.headerClassName; - var headerStyle = _props2.headerStyle; - var onHeaderClick = _props2.onHeaderClick; - var sort = _props2.sort; - var sortBy = _props2.sortBy; - var sortDirection = _props2.sortDirection; - var _column$props2 = column.props; - var dataKey = _column$props2.dataKey; - var disableSort = _column$props2.disableSort; - var headerRenderer = _column$props2.headerRenderer; - var label = _column$props2.label; - var columnData = _column$props2.columnData; +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.ColumnSizer = exports.default = undefined; - var sortEnabled = !disableSort && sort; +var _ColumnSizer2 = require('./ColumnSizer'); - var classNames = (0, _classnames2.default)('FlexTable__headerColumn', headerClassName, column.props.headerClassName, { - 'FlexTable__sortableHeaderColumn': sortEnabled - }); - var style = this._getFlexStyleForColumn(column, headerStyle); +var _ColumnSizer3 = _interopRequireDefault(_ColumnSizer2); - var renderedHeader = headerRenderer({ - columnData: columnData, - dataKey: dataKey, - disableSort: disableSort, - label: label, - sortBy: sortBy, - sortDirection: sortDirection - }); +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - var a11yProps = {}; +exports.default = _ColumnSizer3.default; +exports.ColumnSizer = _ColumnSizer3.default; +},{"./ColumnSizer":47}],49:[function(require,module,exports){ +'use strict'; - if (sortEnabled || onHeaderClick) { - (function () { - // If this is a sortable header, clicking it should update the table data's sorting. - var newSortDirection = sortBy !== dataKey || sortDirection === _SortDirection2.default.DESC ? _SortDirection2.default.ASC : _SortDirection2.default.DESC; +Object.defineProperty(exports, "__esModule", { + value: true +}); - var onClick = function onClick() { - sortEnabled && sort({ - sortBy: dataKey, - sortDirection: newSortDirection - }); - onHeaderClick && onHeaderClick({ columnData: columnData, dataKey: dataKey }); - }; +var _react = require('react'); - var onKeyDown = function onKeyDown(event) { - if (event.key === 'Enter' || event.key === ' ') { - onClick(); - } - }; +var _defaultHeaderRenderer = require('./defaultHeaderRenderer'); - a11yProps['aria-label'] = column.props['aria-label'] || label || dataKey; - a11yProps.role = 'rowheader'; - a11yProps.tabIndex = 0; - a11yProps.onClick = onClick; - a11yProps.onKeyDown = onKeyDown; - })(); - } +var _defaultHeaderRenderer2 = _interopRequireDefault(_defaultHeaderRenderer); - return _react2.default.createElement( - 'div', - _extends({}, a11yProps, { - key: 'Header-Col' + index, - className: classNames, - style: style - }), - renderedHeader - ); - } - }, { - key: '_createRow', - value: function _createRow(_ref6) { - var _this3 = this; +var _defaultCellRenderer = require('./defaultCellRenderer'); + +var _defaultCellRenderer2 = _interopRequireDefault(_defaultCellRenderer); + +var _defaultCellDataGetter = require('./defaultCellDataGetter'); + +var _defaultCellDataGetter2 = _interopRequireDefault(_defaultCellDataGetter); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +/** + * Describes the header and cell contents of a table column. + */ +var Column = function (_Component) { + _inherits(Column, _Component); + + function Column() { + _classCallCheck(this, Column); + + return _possibleConstructorReturn(this, (Column.__proto__ || Object.getPrototypeOf(Column)).apply(this, arguments)); + } + + return Column; +}(_react.Component); + +Column.defaultProps = { + cellDataGetter: _defaultCellDataGetter2.default, + cellRenderer: _defaultCellRenderer2.default, + flexGrow: 0, + flexShrink: 1, + headerRenderer: _defaultHeaderRenderer2.default, + style: {} +}; +Column.propTypes = { + /** Optional aria-label value to set on the column header */ + 'aria-label': _react.PropTypes.string, + + /** + * Callback responsible for returning a cell's data, given its :dataKey + * ({ columnData: any, dataKey: string, rowData: any }): any + */ + cellDataGetter: _react.PropTypes.func, + + /** + * Callback responsible for rendering a cell's contents. + * ({ cellData: any, columnData: any, dataKey: string, rowData: any, rowIndex: number }): node + */ + cellRenderer: _react.PropTypes.func, + + /** Optional CSS class to apply to cell */ + className: _react.PropTypes.string, + + /** Optional additional data passed to this column's :cellDataGetter */ + columnData: _react.PropTypes.object, + + /** Uniquely identifies the row-data attribute correspnding to this cell */ + dataKey: _react.PropTypes.any.isRequired, - var index = _ref6.rowIndex; - var isScrolling = _ref6.isScrolling; - var _props3 = this.props; - var children = _props3.children; - var onRowClick = _props3.onRowClick; - var onRowDoubleClick = _props3.onRowDoubleClick; - var onRowMouseOver = _props3.onRowMouseOver; - var onRowMouseOut = _props3.onRowMouseOut; - var rowClassName = _props3.rowClassName; - var rowGetter = _props3.rowGetter; - var rowRenderer = _props3.rowRenderer; - var rowStyle = _props3.rowStyle; - var scrollbarWidth = this.state.scrollbarWidth; + /** If sort is enabled for the table at large, disable it for this column */ + disableSort: _react.PropTypes.bool, + /** Flex grow style; defaults to 0 */ + flexGrow: _react.PropTypes.number, - var rowClass = rowClassName instanceof Function ? rowClassName({ index: index }) : rowClassName; - var rowStyleObject = rowStyle instanceof Function ? rowStyle({ index: index }) : rowStyle; - var rowData = rowGetter({ index: index }); + /** Flex shrink style; defaults to 1 */ + flexShrink: _react.PropTypes.number, - var columns = _react2.default.Children.toArray(children).map(function (column, columnIndex) { - return _this3._createColumn({ - column: column, - columnIndex: columnIndex, - isScrolling: isScrolling, - rowData: rowData, - rowIndex: index, - scrollbarWidth: scrollbarWidth - }); - }); + /** Optional CSS class to apply to this column's header */ + headerClassName: _react.PropTypes.string, - var className = (0, _classnames2.default)('FlexTable__row', rowClass); - var style = _extends({}, rowStyleObject, { - height: this._getRowHeight(index), - paddingRight: scrollbarWidth - }); + /** + * Optional callback responsible for rendering a column header contents. + * ({ columnData: object, dataKey: string, disableSort: boolean, label: string, sortBy: string, sortDirection: string }): PropTypes.node + */ + headerRenderer: _react.PropTypes.func.isRequired, - return rowRenderer({ - className: className, - columns: columns, - index: index, - isScrolling: isScrolling, - onRowClick: onRowClick, - onRowDoubleClick: onRowDoubleClick, - onRowMouseOver: onRowMouseOver, - onRowMouseOut: onRowMouseOut, - rowData: rowData, - style: style - }); - } + /** Header label for this column */ + label: _react.PropTypes.string, - /** - * Determines the flex-shrink, flex-grow, and width values for a cell (header or column). - */ + /** Maximum width of column; this property will only be used if :flexGrow is > 0. */ + maxWidth: _react.PropTypes.number, - }, { - key: '_getFlexStyleForColumn', - value: function _getFlexStyleForColumn(column) { - var customStyle = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; + /** Minimum width of column. */ + minWidth: _react.PropTypes.number, - var flexValue = column.props.flexGrow + ' ' + column.props.flexShrink + ' ' + column.props.width + 'px'; + /** Optional inline style to apply to cell */ + style: _react.PropTypes.object, - var style = _extends({}, customStyle, { - flex: flexValue, - msFlex: flexValue, - WebkitFlex: flexValue - }); + /** Flex basis (width) for this column; This value can grow or shrink based on :flexGrow and :flexShrink properties. */ + width: _react.PropTypes.number.isRequired +}; +exports.default = Column; +},{"./defaultCellDataGetter":53,"./defaultCellRenderer":54,"./defaultHeaderRenderer":55,"react":undefined}],50:[function(require,module,exports){ +'use strict'; - if (column.props.maxWidth) { - style.maxWidth = column.props.maxWidth; - } +Object.defineProperty(exports, "__esModule", { + value: true +}); - if (column.props.minWidth) { - style.minWidth = column.props.minWidth; - } +var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; - return style; - } - }, { - key: '_getRenderedHeaderRow', - value: function _getRenderedHeaderRow() { - var _this4 = this; +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); - var _props4 = this.props; - var children = _props4.children; - var disableHeader = _props4.disableHeader; +var _classnames = require('classnames'); - var items = disableHeader ? [] : _react2.default.Children.toArray(children); +var _classnames2 = _interopRequireDefault(_classnames); - return items.map(function (column, index) { - return _this4._createHeader({ column: column, index: index }); - }); - } - }, { - key: '_getRowHeight', - value: function _getRowHeight(rowIndex) { - var rowHeight = this.props.rowHeight; +var _FlexColumn = require('./FlexColumn'); +var _FlexColumn2 = _interopRequireDefault(_FlexColumn); - return rowHeight instanceof Function ? rowHeight({ index: rowIndex }) : rowHeight; - } - }, { - key: '_onScroll', - value: function _onScroll(_ref7) { - var clientHeight = _ref7.clientHeight; - var scrollHeight = _ref7.scrollHeight; - var scrollTop = _ref7.scrollTop; - var onScroll = this.props.onScroll; +var _react = require('react'); +var _react2 = _interopRequireDefault(_react); - onScroll({ clientHeight: clientHeight, scrollHeight: scrollHeight, scrollTop: scrollTop }); - } - }, { - key: '_onSectionRendered', - value: function _onSectionRendered(_ref8) { - var rowOverscanStartIndex = _ref8.rowOverscanStartIndex; - var rowOverscanStopIndex = _ref8.rowOverscanStopIndex; - var rowStartIndex = _ref8.rowStartIndex; - var rowStopIndex = _ref8.rowStopIndex; - var onRowsRendered = this.props.onRowsRendered; +var _reactDom = require('react-dom'); +var _reactAddonsShallowCompare = require('react-addons-shallow-compare'); - onRowsRendered({ - overscanStartIndex: rowOverscanStartIndex, - overscanStopIndex: rowOverscanStopIndex, - startIndex: rowStartIndex, - stopIndex: rowStopIndex - }); - } - }, { - key: '_setScrollbarWidth', - value: function _setScrollbarWidth() { - var Grid = (0, _reactDom.findDOMNode)(this.Grid); - var clientWidth = Grid.clientWidth || 0; - var offsetWidth = Grid.offsetWidth || 0; - var scrollbarWidth = offsetWidth - clientWidth; +var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); - this.setState({ scrollbarWidth: scrollbarWidth }); - } - }]); +var _Grid = require('../Grid'); - return FlexTable; -}(_react.Component); +var _Grid2 = _interopRequireDefault(_Grid); -FlexTable.propTypes = { - 'aria-label': _react.PropTypes.string, +var _defaultRowRenderer = require('./defaultRowRenderer'); - /** - * Removes fixed height from the scrollingContainer so that the total height - * of rows can stretch the window. Intended for use with WindowScroller - */ - autoHeight: _react.PropTypes.bool, +var _defaultRowRenderer2 = _interopRequireDefault(_defaultRowRenderer); - /** One or more FlexColumns describing the data displayed in this row */ - children: function children(props, propName, componentName) { - var children = _react2.default.Children.toArray(props.children); - for (var i = 0; i < children.length; i++) { - if (children[i].type !== _FlexColumn2.default) { - return new Error('FlexTable only accepts children of type FlexColumn'); - } - } - }, +var _SortDirection = require('./SortDirection'); - /** Optional CSS class name */ - className: _react.PropTypes.string, +var _SortDirection2 = _interopRequireDefault(_SortDirection); - /** Disable rendering the header at all */ - disableHeader: _react.PropTypes.bool, +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - /** - * Used to estimate the total height of a FlexTable before all of its rows have actually been measured. - * The estimated total height is adjusted as rows are rendered. - */ - estimatedRowSize: _react.PropTypes.number.isRequired, +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - /** Optional custom CSS class name to attach to inner Grid element. */ - gridClassName: _react.PropTypes.string, +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } - /** Optional inline style to attach to inner Grid element. */ - gridStyle: _react.PropTypes.object, +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } - /** Optional CSS class to apply to all column headers */ - headerClassName: _react.PropTypes.string, +/** + * Table component with fixed headers and virtualized rows for improved performance with large data sets. + * This component expects explicit width, height, and padding parameters. + */ +var FlexTable = function (_Component) { + _inherits(FlexTable, _Component); - /** Fixed height of header row */ - headerHeight: _react.PropTypes.number.isRequired, + function FlexTable(props) { + _classCallCheck(this, FlexTable); - /** Fixed/available height for out DOM element */ - height: _react.PropTypes.number.isRequired, + var _this = _possibleConstructorReturn(this, (FlexTable.__proto__ || Object.getPrototypeOf(FlexTable)).call(this, props)); - /** Optional renderer to be used in place of table body rows when rowCount is 0 */ - noRowsRenderer: _react.PropTypes.func, + _this.state = { + scrollbarWidth: 0 + }; - /** - * Optional callback when a column's header is clicked. - * ({ columnData: any, dataKey: string }): void - */ - onHeaderClick: _react.PropTypes.func, + _this._cellClassName = _this._cellClassName.bind(_this); + _this._cellStyle = _this._cellStyle.bind(_this); + _this._createColumn = _this._createColumn.bind(_this); + _this._createRow = _this._createRow.bind(_this); + _this._onScroll = _this._onScroll.bind(_this); + _this._onSectionRendered = _this._onSectionRendered.bind(_this); + return _this; + } - /** Optional custom inline style to attach to table header columns. */ - headerStyle: _react.PropTypes.object, + _createClass(FlexTable, [{ + key: 'forceUpdateGrid', + value: function forceUpdateGrid() { + this.Grid.forceUpdate(); + } - /** - * Callback invoked when a user clicks on a table row. - * ({ index: number }): void - */ - onRowClick: _react.PropTypes.func, + /** See Grid#measureAllCells */ + + }, { + key: 'measureAllRows', + value: function measureAllRows() { + this.Grid.measureAllCells(); + } + + /** See Grid#recomputeGridSize */ + + }, { + key: 'recomputeRowHeights', + value: function recomputeRowHeights() { + var index = arguments.length <= 0 || arguments[0] === undefined ? 0 : arguments[0]; - /** - * Callback invoked when a user double-clicks on a table row. - * ({ index: number }): void - */ - onRowDoubleClick: _react.PropTypes.func, + this.Grid.recomputeGridSize({ + rowIndex: index + }); + this.forceUpdateGrid(); + } + }, { + key: 'componentDidMount', + value: function componentDidMount() { + this._setScrollbarWidth(); + } + }, { + key: 'componentDidUpdate', + value: function componentDidUpdate() { + this._setScrollbarWidth(); + } + }, { + key: 'render', + value: function render() { + var _this2 = this; - /** - * Callback invoked when the mouse leaves a table row. - * ({ index: number }): void - */ - onRowMouseOut: _react.PropTypes.func, + var _props = this.props; + var children = _props.children; + var className = _props.className; + var disableHeader = _props.disableHeader; + var gridClassName = _props.gridClassName; + var gridStyle = _props.gridStyle; + var headerHeight = _props.headerHeight; + var height = _props.height; + var noRowsRenderer = _props.noRowsRenderer; + var rowClassName = _props.rowClassName; + var rowStyle = _props.rowStyle; + var scrollToIndex = _props.scrollToIndex; + var style = _props.style; + var width = _props.width; + var scrollbarWidth = this.state.scrollbarWidth; - /** - * Callback invoked when a user moves the mouse over a table row. - * ({ index: number }): void - */ - onRowMouseOver: _react.PropTypes.func, - /** - * Callback invoked with information about the slice of rows that were just rendered. - * ({ startIndex, stopIndex }): void - */ - onRowsRendered: _react.PropTypes.func, + var availableRowsHeight = height - headerHeight; - /** - * Callback invoked whenever the scroll offset changes within the inner scrollable region. - * This callback can be used to sync scrolling between lists, tables, or grids. - * ({ clientHeight, scrollHeight, scrollTop }): void - */ - onScroll: _react.PropTypes.func.isRequired, + var rowClass = rowClassName instanceof Function ? rowClassName({ index: -1 }) : rowClassName; + var rowStyleObject = rowStyle instanceof Function ? rowStyle({ index: -1 }) : rowStyle; - /** - * Number of rows to render above/below the visible bounds of the list. - * These rows can help for smoother scrolling on touch devices. - */ - overscanRowCount: _react.PropTypes.number.isRequired, + // Precompute and cache column styles before rendering rows and columns to speed things up + this._cachedColumnStyles = []; + _react2.default.Children.toArray(children).forEach(function (column, index) { + _this2._cachedColumnStyles[index] = _this2._getFlexStyleForColumn(column, column.props.style); + }); - /** - * Optional CSS class to apply to all table rows (including the header row). - * This property can be a CSS class name (string) or a function that returns a class name. - * If a function is provided its signature should be: ({ index: number }): string - */ - rowClassName: _react.PropTypes.oneOfType([_react.PropTypes.string, _react.PropTypes.func]), + // Note that we specify :numChildren, :scrollbarWidth, :sortBy, and :sortDirection as properties on Grid even though these have nothing to do with Grid. + // This is done because Grid is a pure component and won't update unless its properties or state has changed. + // Any property that should trigger a re-render of Grid then is specified here to avoid a stale display. + return _react2.default.createElement( + 'div', + { + className: (0, _classnames2.default)('FlexTable', className), + style: style + }, + !disableHeader && _react2.default.createElement( + 'div', + { + className: (0, _classnames2.default)('FlexTable__headerRow', rowClass), + style: _extends({}, rowStyleObject, { + height: headerHeight, + paddingRight: scrollbarWidth, + width: width + }) + }, + this._getRenderedHeaderRow() + ), + _react2.default.createElement(_Grid2.default, _extends({}, this.props, { + autoContainerWidth: true, + className: (0, _classnames2.default)('FlexTable__Grid', gridClassName), + cellClassName: this._cellClassName, + cellRenderer: this._createRow, + cellStyle: this._cellStyle, + columnWidth: width, + columnCount: 1, + height: availableRowsHeight, + noContentRenderer: noRowsRenderer, + onScroll: this._onScroll, + onSectionRendered: this._onSectionRendered, + ref: function ref(_ref) { + _this2.Grid = _ref; + }, + scrollbarWidth: scrollbarWidth, + scrollToRow: scrollToIndex, + style: gridStyle + })) + ); + } + }, { + key: 'shouldComponentUpdate', + value: function shouldComponentUpdate(nextProps, nextState) { + return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState); + } + }, { + key: '_cellClassName', + value: function _cellClassName(_ref2) { + var rowIndex = _ref2.rowIndex; + var rowWrapperClassName = this.props.rowWrapperClassName; - /** - * Callback responsible for returning a data row given an index. - * ({ index: number }): any - */ - rowGetter: _react.PropTypes.func.isRequired, - /** - * Either a fixed row height (number) or a function that returns the height of a row given its index. - * ({ index: number }): number - */ - rowHeight: _react.PropTypes.oneOfType([_react.PropTypes.number, _react.PropTypes.func]).isRequired, + return rowWrapperClassName instanceof Function ? rowWrapperClassName({ index: rowIndex - 1 }) : rowWrapperClassName; + } + }, { + key: '_cellStyle', + value: function _cellStyle(_ref3) { + var rowIndex = _ref3.rowIndex; + var rowWrapperStyle = this.props.rowWrapperStyle; - /** Number of rows in table. */ - rowCount: _react.PropTypes.number.isRequired, - /** - * Responsible for rendering a table row given an array of columns: - * Should implement the following interface: ({ - * className: string, - * columns: Array, - * index: number, - * isScrolling: boolean, - * onRowClick: ?Function, - * onRowDoubleClick: ?Function, - * onRowMouseOver: ?Function, - * onRowMouseOut: ?Function, - * rowData: any, - * style: any - * }): PropTypes.node - */ - rowRenderer: _react.PropTypes.func, + return rowWrapperStyle instanceof Function ? rowWrapperStyle({ index: rowIndex - 1 }) : rowWrapperStyle; + } + }, { + key: '_createColumn', + value: function _createColumn(_ref4) { + var column = _ref4.column; + var columnIndex = _ref4.columnIndex; + var isScrolling = _ref4.isScrolling; + var rowData = _ref4.rowData; + var rowIndex = _ref4.rowIndex; + var _column$props = column.props; + var cellDataGetter = _column$props.cellDataGetter; + var cellRenderer = _column$props.cellRenderer; + var className = _column$props.className; + var columnData = _column$props.columnData; + var dataKey = _column$props.dataKey; - /** Optional custom inline style to attach to table rows. */ - rowStyle: _react.PropTypes.oneOfType([_react.PropTypes.object, _react.PropTypes.func]).isRequired, - /** Optional custom CSS class for individual rows */ - rowWrapperClassName: _react.PropTypes.oneOfType([_react.PropTypes.string, _react.PropTypes.func]), + var cellData = cellDataGetter({ columnData: columnData, dataKey: dataKey, rowData: rowData }); + var renderedCell = cellRenderer({ cellData: cellData, columnData: columnData, dataKey: dataKey, isScrolling: isScrolling, rowData: rowData, rowIndex: rowIndex }); - /** Optional custom CSS class for individual rows */ - rowWrapperStyle: _react.PropTypes.oneOfType([_react.PropTypes.object, _react.PropTypes.func]), + var style = this._cachedColumnStyles[columnIndex]; - /** See Grid#scrollToAlignment */ - scrollToAlignment: _react.PropTypes.oneOf(['auto', 'end', 'start', 'center']).isRequired, + var title = typeof renderedCell === 'string' ? renderedCell : null; - /** Row index to ensure visible (by forcefully scrolling if necessary) */ - scrollToIndex: _react.PropTypes.number, + return _react2.default.createElement( + 'div', + { + key: 'Row' + rowIndex + '-Col' + columnIndex, + className: (0, _classnames2.default)('FlexTable__rowColumn', className), + style: style, + title: title + }, + renderedCell + ); + } + }, { + key: '_createHeader', + value: function _createHeader(_ref5) { + var column = _ref5.column; + var index = _ref5.index; + var _props2 = this.props; + var headerClassName = _props2.headerClassName; + var headerStyle = _props2.headerStyle; + var onHeaderClick = _props2.onHeaderClick; + var sort = _props2.sort; + var sortBy = _props2.sortBy; + var sortDirection = _props2.sortDirection; + var _column$props2 = column.props; + var dataKey = _column$props2.dataKey; + var disableSort = _column$props2.disableSort; + var headerRenderer = _column$props2.headerRenderer; + var label = _column$props2.label; + var columnData = _column$props2.columnData; - /** Vertical offset. */ - scrollTop: _react.PropTypes.number, + var sortEnabled = !disableSort && sort; - /** - * Sort function to be called if a sortable header is clicked. - * ({ sortBy: string, sortDirection: SortDirection }): void - */ - sort: _react.PropTypes.func, + var classNames = (0, _classnames2.default)('FlexTable__headerColumn', headerClassName, column.props.headerClassName, { + 'FlexTable__sortableHeaderColumn': sortEnabled + }); + var style = this._getFlexStyleForColumn(column, headerStyle); - /** FlexTable data is currently sorted by this :dataKey (if it is sorted at all) */ - sortBy: _react.PropTypes.string, + var renderedHeader = headerRenderer({ + columnData: columnData, + dataKey: dataKey, + disableSort: disableSort, + label: label, + sortBy: sortBy, + sortDirection: sortDirection + }); - /** FlexTable data is currently sorted in this direction (if it is sorted at all) */ - sortDirection: _react.PropTypes.oneOf([_SortDirection2.default.ASC, _SortDirection2.default.DESC]), + var a11yProps = {}; - /** Optional inline style */ - style: _react.PropTypes.object, + if (sortEnabled || onHeaderClick) { + (function () { + // If this is a sortable header, clicking it should update the table data's sorting. + var newSortDirection = sortBy !== dataKey || sortDirection === _SortDirection2.default.DESC ? _SortDirection2.default.ASC : _SortDirection2.default.DESC; - /** Tab index for focus */ - tabIndex: _react.PropTypes.number, + var onClick = function onClick() { + sortEnabled && sort({ + sortBy: dataKey, + sortDirection: newSortDirection + }); + onHeaderClick && onHeaderClick({ columnData: columnData, dataKey: dataKey }); + }; - /** Width of list */ - width: _react.PropTypes.number.isRequired -}; -FlexTable.defaultProps = { - disableHeader: false, - estimatedRowSize: 30, - headerHeight: 0, - headerStyle: {}, - noRowsRenderer: function noRowsRenderer() { - return null; - }, - onRowsRendered: function onRowsRendered() { - return null; - }, - onScroll: function onScroll() { - return null; - }, - overscanRowCount: 10, - rowRenderer: _defaultRowRenderer2.default, - rowStyle: {}, - scrollToAlignment: 'auto', - style: {} -}; -exports.default = FlexTable; -},{"../Grid":62,"./FlexColumn":51,"./SortDirection":53,"./defaultRowRenderer":58,"classnames":undefined,"react":undefined,"react-addons-shallow-compare":30,"react-dom":undefined}],53:[function(require,module,exports){ -'use strict'; + var onKeyDown = function onKeyDown(event) { + if (event.key === 'Enter' || event.key === ' ') { + onClick(); + } + }; -Object.defineProperty(exports, "__esModule", { - value: true -}); -var SortDirection = { - /** - * Sort items in ascending order. - * This means arranging from the lowest value to the highest (e.g. a-z, 0-9). - */ - ASC: 'ASC', + a11yProps['aria-label'] = column.props['aria-label'] || label || dataKey; + a11yProps.role = 'rowheader'; + a11yProps.tabIndex = 0; + a11yProps.onClick = onClick; + a11yProps.onKeyDown = onKeyDown; + })(); + } - /** - * Sort items in descending order. - * This means arranging from the highest value to the lowest (e.g. z-a, 9-0). - */ - DESC: 'DESC' -}; + return _react2.default.createElement( + 'div', + _extends({}, a11yProps, { + key: 'Header-Col' + index, + className: classNames, + style: style + }), + renderedHeader + ); + } + }, { + key: '_createRow', + value: function _createRow(_ref6) { + var _this3 = this; -exports.default = SortDirection; -},{}],54:[function(require,module,exports){ -'use strict'; + var index = _ref6.rowIndex; + var isScrolling = _ref6.isScrolling; + var _props3 = this.props; + var children = _props3.children; + var onRowClick = _props3.onRowClick; + var onRowDoubleClick = _props3.onRowDoubleClick; + var onRowMouseOver = _props3.onRowMouseOver; + var onRowMouseOut = _props3.onRowMouseOut; + var rowClassName = _props3.rowClassName; + var rowGetter = _props3.rowGetter; + var rowRenderer = _props3.rowRenderer; + var rowStyle = _props3.rowStyle; + var scrollbarWidth = this.state.scrollbarWidth; -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = SortIndicator; -var _react = require('react'); + var rowClass = rowClassName instanceof Function ? rowClassName({ index: index }) : rowClassName; + var rowStyleObject = rowStyle instanceof Function ? rowStyle({ index: index }) : rowStyle; + var rowData = rowGetter({ index: index }); -var _react2 = _interopRequireDefault(_react); + var columns = _react2.default.Children.toArray(children).map(function (column, columnIndex) { + return _this3._createColumn({ + column: column, + columnIndex: columnIndex, + isScrolling: isScrolling, + rowData: rowData, + rowIndex: index, + scrollbarWidth: scrollbarWidth + }); + }); -var _classnames = require('classnames'); + var className = (0, _classnames2.default)('FlexTable__row', rowClass); + var style = _extends({}, rowStyleObject, { + height: this._getRowHeight(index), + paddingRight: scrollbarWidth + }); -var _classnames2 = _interopRequireDefault(_classnames); + return rowRenderer({ + className: className, + columns: columns, + index: index, + isScrolling: isScrolling, + onRowClick: onRowClick, + onRowDoubleClick: onRowDoubleClick, + onRowMouseOver: onRowMouseOver, + onRowMouseOut: onRowMouseOut, + rowData: rowData, + style: style + }); + } -var _SortDirection = require('./SortDirection'); + /** + * Determines the flex-shrink, flex-grow, and width values for a cell (header or column). + */ -var _SortDirection2 = _interopRequireDefault(_SortDirection); + }, { + key: '_getFlexStyleForColumn', + value: function _getFlexStyleForColumn(column) { + var customStyle = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + var flexValue = column.props.flexGrow + ' ' + column.props.flexShrink + ' ' + column.props.width + 'px'; -/** - * Displayed beside a header to indicate that a FlexTable is currently sorted by this column. - */ -function SortIndicator(_ref) { - var sortDirection = _ref.sortDirection; + var style = _extends({}, customStyle, { + flex: flexValue, + msFlex: flexValue, + WebkitFlex: flexValue + }); - var classNames = (0, _classnames2.default)('FlexTable__sortableHeaderIcon', { - 'FlexTable__sortableHeaderIcon--ASC': sortDirection === _SortDirection2.default.ASC, - 'FlexTable__sortableHeaderIcon--DESC': sortDirection === _SortDirection2.default.DESC - }); + if (column.props.maxWidth) { + style.maxWidth = column.props.maxWidth; + } - return _react2.default.createElement( - 'svg', - { - className: classNames, - width: 18, - height: 18, - viewBox: '0 0 24 24' - }, - sortDirection === _SortDirection2.default.ASC ? _react2.default.createElement('path', { d: 'M7 14l5-5 5 5z' }) : _react2.default.createElement('path', { d: 'M7 10l5 5 5-5z' }), - _react2.default.createElement('path', { d: 'M0 0h24v24H0z', fill: 'none' }) - ); -} -SortIndicator.propTypes = { - sortDirection: _react.PropTypes.oneOf([_SortDirection2.default.ASC, _SortDirection2.default.DESC]) -}; -},{"./SortDirection":53,"classnames":undefined,"react":undefined}],55:[function(require,module,exports){ -'use strict'; + if (column.props.minWidth) { + style.minWidth = column.props.minWidth; + } -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = defaultCellDataGetter; + return style; + } + }, { + key: '_getRenderedHeaderRow', + value: function _getRenderedHeaderRow() { + var _this4 = this; + var _props4 = this.props; + var children = _props4.children; + var disableHeader = _props4.disableHeader; -/** - * Default accessor for returning a cell value for a given attribute. - * This function expects to operate on either a vanilla Object or an Immutable Map. - * You should override the column's cellDataGetter if your data is some other type of object. - */ -function defaultCellDataGetter(_ref) { - var columnData = _ref.columnData; - var dataKey = _ref.dataKey; - var rowData = _ref.rowData; + var items = disableHeader ? [] : _react2.default.Children.toArray(children); - if (rowData.get instanceof Function) { - return rowData.get(dataKey); - } else { - return rowData[dataKey]; - } -} -},{}],56:[function(require,module,exports){ -'use strict'; + return items.map(function (column, index) { + return _this4._createHeader({ column: column, index: index }); + }); + } + }, { + key: '_getRowHeight', + value: function _getRowHeight(rowIndex) { + var rowHeight = this.props.rowHeight; -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = defaultCellRenderer; + return rowHeight instanceof Function ? rowHeight({ index: rowIndex }) : rowHeight; + } + }, { + key: '_onScroll', + value: function _onScroll(_ref7) { + var clientHeight = _ref7.clientHeight; + var scrollHeight = _ref7.scrollHeight; + var scrollTop = _ref7.scrollTop; + var onScroll = this.props.onScroll; -/** - * Default cell renderer that displays an attribute as a simple string - * You should override the column's cellRenderer if your data is some other type of object. - */ -function defaultCellRenderer(_ref) { - var cellData = _ref.cellData; - var cellDataKey = _ref.cellDataKey; - var columnData = _ref.columnData; - var rowData = _ref.rowData; - var rowIndex = _ref.rowIndex; - if (cellData == null) { - return ''; - } else { - return String(cellData); - } -} -},{}],57:[function(require,module,exports){ -'use strict'; + onScroll({ clientHeight: clientHeight, scrollHeight: scrollHeight, scrollTop: scrollTop }); + } + }, { + key: '_onSectionRendered', + value: function _onSectionRendered(_ref8) { + var rowOverscanStartIndex = _ref8.rowOverscanStartIndex; + var rowOverscanStopIndex = _ref8.rowOverscanStopIndex; + var rowStartIndex = _ref8.rowStartIndex; + var rowStopIndex = _ref8.rowStopIndex; + var onRowsRendered = this.props.onRowsRendered; -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = defaultHeaderRenderer; -var _react = require('react'); + onRowsRendered({ + overscanStartIndex: rowOverscanStartIndex, + overscanStopIndex: rowOverscanStopIndex, + startIndex: rowStartIndex, + stopIndex: rowStopIndex + }); + } + }, { + key: '_setScrollbarWidth', + value: function _setScrollbarWidth() { + var Grid = (0, _reactDom.findDOMNode)(this.Grid); + var clientWidth = Grid.clientWidth || 0; + var offsetWidth = Grid.offsetWidth || 0; + var scrollbarWidth = offsetWidth - clientWidth; -var _react2 = _interopRequireDefault(_react); + this.setState({ scrollbarWidth: scrollbarWidth }); + } + }]); -var _SortIndicator = require('./SortIndicator'); + return FlexTable; +}(_react.Component); -var _SortIndicator2 = _interopRequireDefault(_SortIndicator); +FlexTable.propTypes = { + 'aria-label': _react.PropTypes.string, -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + /** + * Removes fixed height from the scrollingContainer so that the total height + * of rows can stretch the window. Intended for use with WindowScroller + */ + autoHeight: _react.PropTypes.bool, -/** - * Default table header renderer. - */ -function defaultHeaderRenderer(_ref) { - var columnData = _ref.columnData; - var dataKey = _ref.dataKey; - var disableSort = _ref.disableSort; - var label = _ref.label; - var sortBy = _ref.sortBy; - var sortDirection = _ref.sortDirection; + /** One or more FlexColumns describing the data displayed in this row */ + children: function children(props, propName, componentName) { + var children = _react2.default.Children.toArray(props.children); + for (var i = 0; i < children.length; i++) { + if (children[i].type !== _FlexColumn2.default) { + return new Error('FlexTable only accepts children of type FlexColumn'); + } + } + }, - var showSortIndicator = sortBy === dataKey; - var children = [_react2.default.createElement( - 'span', - { - className: 'FlexTable__headerTruncatedText', - key: 'label', - title: label - }, - label - )]; + /** Optional CSS class name */ + className: _react.PropTypes.string, - if (showSortIndicator) { - children.push(_react2.default.createElement(_SortIndicator2.default, { - key: 'SortIndicator', - sortDirection: sortDirection - })); - } + /** Disable rendering the header at all */ + disableHeader: _react.PropTypes.bool, - return children; -} -},{"./SortIndicator":54,"react":undefined}],58:[function(require,module,exports){ -'use strict'; + /** + * Used to estimate the total height of a FlexTable before all of its rows have actually been measured. + * The estimated total height is adjusted as rows are rendered. + */ + estimatedRowSize: _react.PropTypes.number.isRequired, -Object.defineProperty(exports, "__esModule", { - value: true -}); + /** Optional custom CSS class name to attach to inner Grid element. */ + gridClassName: _react.PropTypes.string, -var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; + /** Optional inline style to attach to inner Grid element. */ + gridStyle: _react.PropTypes.object, -exports.default = defaultRowRenderer; + /** Optional CSS class to apply to all column headers */ + headerClassName: _react.PropTypes.string, -var _react = require('react'); + /** Fixed height of header row */ + headerHeight: _react.PropTypes.number.isRequired, -var _react2 = _interopRequireDefault(_react); + /** Fixed/available height for out DOM element */ + height: _react.PropTypes.number.isRequired, -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + /** Optional renderer to be used in place of table body rows when rowCount is 0 */ + noRowsRenderer: _react.PropTypes.func, -/** - * Default row renderer for FlexTable. - */ -function defaultRowRenderer(_ref) { - var className = _ref.className; - var columns = _ref.columns; - var index = _ref.index; - var isScrolling = _ref.isScrolling; - var onRowClick = _ref.onRowClick; - var onRowDoubleClick = _ref.onRowDoubleClick; - var onRowMouseOver = _ref.onRowMouseOver; - var onRowMouseOut = _ref.onRowMouseOut; - var rowData = _ref.rowData; - var style = _ref.style; + /** + * Optional callback when a column's header is clicked. + * ({ columnData: any, dataKey: string }): void + */ + onHeaderClick: _react.PropTypes.func, - var a11yProps = {}; + /** Optional custom inline style to attach to table header columns. */ + headerStyle: _react.PropTypes.object, - if (onRowClick || onRowDoubleClick || onRowMouseOver || onRowMouseOut) { - a11yProps['aria-label'] = 'row'; - a11yProps.role = 'row'; - a11yProps.tabIndex = 0; + /** + * Callback invoked when a user clicks on a table row. + * ({ index: number }): void + */ + onRowClick: _react.PropTypes.func, - if (onRowClick) { - a11yProps.onClick = function () { - return onRowClick({ index: index }); - }; - } - if (onRowDoubleClick) { - a11yProps.onDoubleClick = function () { - return onRowDoubleClick({ index: index }); - }; - } - if (onRowMouseOut) { - a11yProps.onMouseOut = function () { - return onRowMouseOut({ index: index }); - }; - } - if (onRowMouseOver) { - a11yProps.onMouseOver = function () { - return onRowMouseOver({ index: index }); - }; - } - } + /** + * Callback invoked when a user double-clicks on a table row. + * ({ index: number }): void + */ + onRowDoubleClick: _react.PropTypes.func, - return _react2.default.createElement( - 'div', - _extends({}, a11yProps, { - className: className, - style: style - }), - columns - ); -} -},{"react":undefined}],59:[function(require,module,exports){ -'use strict'; + /** + * Callback invoked when the mouse leaves a table row. + * ({ index: number }): void + */ + onRowMouseOut: _react.PropTypes.func, -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.SortIndicator = exports.SortDirection = exports.FlexColumn = exports.FlexTable = exports.defaultRowRenderer = exports.defaultHeaderRenderer = exports.defaultCellRenderer = exports.defaultCellDataGetter = exports.default = undefined; + /** + * Callback invoked when a user moves the mouse over a table row. + * ({ index: number }): void + */ + onRowMouseOver: _react.PropTypes.func, -var _FlexTable2 = require('./FlexTable'); + /** + * Callback invoked with information about the slice of rows that were just rendered. + * ({ startIndex, stopIndex }): void + */ + onRowsRendered: _react.PropTypes.func, -var _FlexTable3 = _interopRequireDefault(_FlexTable2); + /** + * Callback invoked whenever the scroll offset changes within the inner scrollable region. + * This callback can be used to sync scrolling between lists, tables, or grids. + * ({ clientHeight, scrollHeight, scrollTop }): void + */ + onScroll: _react.PropTypes.func.isRequired, -var _defaultCellDataGetter2 = require('./defaultCellDataGetter'); + /** + * Number of rows to render above/below the visible bounds of the list. + * These rows can help for smoother scrolling on touch devices. + */ + overscanRowCount: _react.PropTypes.number.isRequired, -var _defaultCellDataGetter3 = _interopRequireDefault(_defaultCellDataGetter2); + /** + * Optional CSS class to apply to all table rows (including the header row). + * This property can be a CSS class name (string) or a function that returns a class name. + * If a function is provided its signature should be: ({ index: number }): string + */ + rowClassName: _react.PropTypes.oneOfType([_react.PropTypes.string, _react.PropTypes.func]), -var _defaultCellRenderer2 = require('./defaultCellRenderer'); + /** + * Callback responsible for returning a data row given an index. + * ({ index: number }): any + */ + rowGetter: _react.PropTypes.func.isRequired, -var _defaultCellRenderer3 = _interopRequireDefault(_defaultCellRenderer2); + /** + * Either a fixed row height (number) or a function that returns the height of a row given its index. + * ({ index: number }): number + */ + rowHeight: _react.PropTypes.oneOfType([_react.PropTypes.number, _react.PropTypes.func]).isRequired, -var _defaultHeaderRenderer2 = require('./defaultHeaderRenderer'); + /** Number of rows in table. */ + rowCount: _react.PropTypes.number.isRequired, -var _defaultHeaderRenderer3 = _interopRequireDefault(_defaultHeaderRenderer2); + /** + * Responsible for rendering a table row given an array of columns: + * Should implement the following interface: ({ + * className: string, + * columns: Array, + * index: number, + * isScrolling: boolean, + * onRowClick: ?Function, + * onRowDoubleClick: ?Function, + * onRowMouseOver: ?Function, + * onRowMouseOut: ?Function, + * rowData: any, + * style: any + * }): PropTypes.node + */ + rowRenderer: _react.PropTypes.func, -var _defaultRowRenderer2 = require('./defaultRowRenderer'); + /** Optional custom inline style to attach to table rows. */ + rowStyle: _react.PropTypes.oneOfType([_react.PropTypes.object, _react.PropTypes.func]).isRequired, -var _defaultRowRenderer3 = _interopRequireDefault(_defaultRowRenderer2); + /** Optional custom CSS class for individual rows */ + rowWrapperClassName: _react.PropTypes.oneOfType([_react.PropTypes.string, _react.PropTypes.func]), -var _FlexColumn2 = require('./FlexColumn'); + /** Optional custom CSS class for individual rows */ + rowWrapperStyle: _react.PropTypes.oneOfType([_react.PropTypes.object, _react.PropTypes.func]), + + /** See Grid#scrollToAlignment */ + scrollToAlignment: _react.PropTypes.oneOf(['auto', 'end', 'start', 'center']).isRequired, + + /** Row index to ensure visible (by forcefully scrolling if necessary) */ + scrollToIndex: _react.PropTypes.number, -var _FlexColumn3 = _interopRequireDefault(_FlexColumn2); + /** Vertical offset. */ + scrollTop: _react.PropTypes.number, -var _SortDirection2 = require('./SortDirection'); + /** + * Sort function to be called if a sortable header is clicked. + * ({ sortBy: string, sortDirection: SortDirection }): void + */ + sort: _react.PropTypes.func, -var _SortDirection3 = _interopRequireDefault(_SortDirection2); + /** FlexTable data is currently sorted by this :dataKey (if it is sorted at all) */ + sortBy: _react.PropTypes.string, -var _SortIndicator2 = require('./SortIndicator'); + /** FlexTable data is currently sorted in this direction (if it is sorted at all) */ + sortDirection: _react.PropTypes.oneOf([_SortDirection2.default.ASC, _SortDirection2.default.DESC]), -var _SortIndicator3 = _interopRequireDefault(_SortIndicator2); + /** Optional inline style */ + style: _react.PropTypes.object, -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + /** Tab index for focus */ + tabIndex: _react.PropTypes.number, -exports.default = _FlexTable3.default; -exports.defaultCellDataGetter = _defaultCellDataGetter3.default; -exports.defaultCellRenderer = _defaultCellRenderer3.default; -exports.defaultHeaderRenderer = _defaultHeaderRenderer3.default; -exports.defaultRowRenderer = _defaultRowRenderer3.default; -exports.FlexTable = _FlexTable3.default; -exports.FlexColumn = _FlexColumn3.default; -exports.SortDirection = _SortDirection3.default; -exports.SortIndicator = _SortIndicator3.default; -},{"./FlexColumn":51,"./FlexTable":52,"./SortDirection":53,"./SortIndicator":54,"./defaultCellDataGetter":55,"./defaultCellRenderer":56,"./defaultHeaderRenderer":57,"./defaultRowRenderer":58}],60:[function(require,module,exports){ + /** Width of list */ + width: _react.PropTypes.number.isRequired +}; +FlexTable.defaultProps = { + disableHeader: false, + estimatedRowSize: 30, + headerHeight: 0, + headerStyle: {}, + noRowsRenderer: function noRowsRenderer() { + return null; + }, + onRowsRendered: function onRowsRendered() { + return null; + }, + onScroll: function onScroll() { + return null; + }, + overscanRowCount: 10, + rowRenderer: _defaultRowRenderer2.default, + rowStyle: {}, + scrollToAlignment: 'auto', + style: {} +}; +exports.default = FlexTable; +},{"../Grid":60,"./FlexColumn":49,"./SortDirection":51,"./defaultRowRenderer":56,"classnames":undefined,"react":undefined,"react-addons-shallow-compare":18,"react-dom":undefined}],51:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); -exports.DEFAULT_SCROLLING_RESET_TIME_INTERVAL = undefined; +var SortDirection = { + /** + * Sort items in ascending order. + * This means arranging from the lowest value to the highest (e.g. a-z, 0-9). + */ + ASC: 'ASC', -var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; + /** + * Sort items in descending order. + * This means arranging from the highest value to the lowest (e.g. z-a, 9-0). + */ + DESC: 'DESC' +}; -var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); +exports.default = SortDirection; +},{}],52:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = SortIndicator; var _react = require('react'); @@ -6239,1557 +6334,1554 @@ var _classnames = require('classnames'); var _classnames2 = _interopRequireDefault(_classnames); -var _calculateSizeAndPositionDataAndUpdateScrollOffset = require('./utils/calculateSizeAndPositionDataAndUpdateScrollOffset'); - -var _calculateSizeAndPositionDataAndUpdateScrollOffset2 = _interopRequireDefault(_calculateSizeAndPositionDataAndUpdateScrollOffset); - -var _ScalingCellSizeAndPositionManager = require('./utils/ScalingCellSizeAndPositionManager'); - -var _ScalingCellSizeAndPositionManager2 = _interopRequireDefault(_ScalingCellSizeAndPositionManager); - -var _createCallbackMemoizer = require('../utils/createCallbackMemoizer'); - -var _createCallbackMemoizer2 = _interopRequireDefault(_createCallbackMemoizer); - -var _getOverscanIndices = require('./utils/getOverscanIndices'); - -var _getOverscanIndices2 = _interopRequireDefault(_getOverscanIndices); - -var _scrollbarSize = require('dom-helpers/util/scrollbarSize'); - -var _scrollbarSize2 = _interopRequireDefault(_scrollbarSize); - -var _raf = require('raf'); - -var _raf2 = _interopRequireDefault(_raf); - -var _reactAddonsShallowCompare = require('react-addons-shallow-compare'); - -var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); - -var _updateScrollIndexHelper = require('./utils/updateScrollIndexHelper'); - -var _updateScrollIndexHelper2 = _interopRequireDefault(_updateScrollIndexHelper); - -var _defaultCellRangeRenderer = require('./defaultCellRangeRenderer'); +var _SortDirection = require('./SortDirection'); -var _defaultCellRangeRenderer2 = _interopRequireDefault(_defaultCellRangeRenderer); +var _SortDirection2 = _interopRequireDefault(_SortDirection); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } - -/** - * Specifies the number of miliseconds during which to disable pointer events while a scroll is in progress. - * This improves performance and makes scrolling smoother. - */ -var DEFAULT_SCROLLING_RESET_TIME_INTERVAL = exports.DEFAULT_SCROLLING_RESET_TIME_INTERVAL = 150; - /** - * Controls whether the Grid updates the DOM element's scrollLeft/scrollTop based on the current state or just observes it. - * This prevents Grid from interrupting mouse-wheel animations (see issue #2). + * Displayed beside a header to indicate that a FlexTable is currently sorted by this column. */ -var SCROLL_POSITION_CHANGE_REASONS = { - OBSERVED: 'observed', - REQUESTED: 'requested' -}; +function SortIndicator(_ref) { + var sortDirection = _ref.sortDirection; -/** - * Renders tabular data with virtualization along the vertical and horizontal axes. - * Row heights and column widths must be known ahead of time and specified as properties. - */ + var classNames = (0, _classnames2.default)('FlexTable__sortableHeaderIcon', { + 'FlexTable__sortableHeaderIcon--ASC': sortDirection === _SortDirection2.default.ASC, + 'FlexTable__sortableHeaderIcon--DESC': sortDirection === _SortDirection2.default.DESC + }); -var Grid = function (_Component) { - _inherits(Grid, _Component); + return _react2.default.createElement( + 'svg', + { + className: classNames, + width: 18, + height: 18, + viewBox: '0 0 24 24' + }, + sortDirection === _SortDirection2.default.ASC ? _react2.default.createElement('path', { d: 'M7 14l5-5 5 5z' }) : _react2.default.createElement('path', { d: 'M7 10l5 5 5-5z' }), + _react2.default.createElement('path', { d: 'M0 0h24v24H0z', fill: 'none' }) + ); +} +SortIndicator.propTypes = { + sortDirection: _react.PropTypes.oneOf([_SortDirection2.default.ASC, _SortDirection2.default.DESC]) +}; +},{"./SortDirection":51,"classnames":undefined,"react":undefined}],53:[function(require,module,exports){ +'use strict'; - function Grid(props, context) { - _classCallCheck(this, Grid); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = defaultCellDataGetter; - var _this = _possibleConstructorReturn(this, (Grid.__proto__ || Object.getPrototypeOf(Grid)).call(this, props, context)); - _this.state = { - isScrolling: false, - scrollDirectionHorizontal: _getOverscanIndices.SCROLL_DIRECTION_FIXED, - scrollDirectionVertical: _getOverscanIndices.SCROLL_DIRECTION_FIXED, - scrollLeft: 0, - scrollTop: 0 - }; +/** + * Default accessor for returning a cell value for a given attribute. + * This function expects to operate on either a vanilla Object or an Immutable Map. + * You should override the column's cellDataGetter if your data is some other type of object. + */ +function defaultCellDataGetter(_ref) { + var columnData = _ref.columnData; + var dataKey = _ref.dataKey; + var rowData = _ref.rowData; - // Invokes onSectionRendered callback only when start/stop row or column indices change - _this._onGridRenderedMemoizer = (0, _createCallbackMemoizer2.default)(); - _this._onScrollMemoizer = (0, _createCallbackMemoizer2.default)(false); + if (rowData.get instanceof Function) { + return rowData.get(dataKey); + } else { + return rowData[dataKey]; + } +} +},{}],54:[function(require,module,exports){ +'use strict'; - // Bind functions to instance so they don't lose context when passed around - _this._enablePointerEventsAfterDelayCallback = _this._enablePointerEventsAfterDelayCallback.bind(_this); - _this._invokeOnGridRenderedHelper = _this._invokeOnGridRenderedHelper.bind(_this); - _this._onScroll = _this._onScroll.bind(_this); - _this._setNextStateCallback = _this._setNextStateCallback.bind(_this); - _this._updateScrollLeftForScrollToColumn = _this._updateScrollLeftForScrollToColumn.bind(_this); - _this._updateScrollTopForScrollToRow = _this._updateScrollTopForScrollToRow.bind(_this); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = defaultCellRenderer; - _this._columnWidthGetter = _this._wrapSizeGetter(props.columnWidth); - _this._rowHeightGetter = _this._wrapSizeGetter(props.rowHeight); - _this._columnSizeAndPositionManager = new _ScalingCellSizeAndPositionManager2.default({ - cellCount: props.columnCount, - cellSizeGetter: function cellSizeGetter(index) { - return _this._columnWidthGetter(index); - }, - estimatedCellSize: _this._getEstimatedColumnSize(props) - }); - _this._rowSizeAndPositionManager = new _ScalingCellSizeAndPositionManager2.default({ - cellCount: props.rowCount, - cellSizeGetter: function cellSizeGetter(index) { - return _this._rowHeightGetter(index); - }, - estimatedCellSize: _this._getEstimatedRowSize(props) - }); +/** + * Default cell renderer that displays an attribute as a simple string + * You should override the column's cellRenderer if your data is some other type of object. + */ +function defaultCellRenderer(_ref) { + var cellData = _ref.cellData; + var cellDataKey = _ref.cellDataKey; + var columnData = _ref.columnData; + var rowData = _ref.rowData; + var rowIndex = _ref.rowIndex; - // See defaultCellRangeRenderer() for more information on the usage of this cache - _this._cellCache = {}; - return _this; + if (cellData == null) { + return ''; + } else { + return String(cellData); } +} +},{}],55:[function(require,module,exports){ +'use strict'; - /** - * Pre-measure all columns and rows in a Grid. - * Typically cells are only measured as needed and estimated sizes are used for cells that have not yet been measured. - * This method ensures that the next call to getTotalSize() returns an exact size (as opposed to just an estimated one). - */ +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = defaultHeaderRenderer; +var _react = require('react'); - _createClass(Grid, [{ - key: 'measureAllCells', - value: function measureAllCells() { - var _props = this.props; - var columnCount = _props.columnCount; - var rowCount = _props.rowCount; +var _react2 = _interopRequireDefault(_react); +var _SortIndicator = require('./SortIndicator'); - this._columnSizeAndPositionManager.getSizeAndPositionOfCell(columnCount - 1); - this._rowSizeAndPositionManager.getSizeAndPositionOfCell(rowCount - 1); - } +var _SortIndicator2 = _interopRequireDefault(_SortIndicator); - /** - * Forced recompute of row heights and column widths. - * This function should be called if dynamic column or row sizes have changed but nothing else has. - * Since Grid only receives :columnCount and :rowCount it has no way of detecting when the underlying data changes. - */ +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - }, { - key: 'recomputeGridSize', - value: function recomputeGridSize() { - var _ref = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; +/** + * Default table header renderer. + */ +function defaultHeaderRenderer(_ref) { + var columnData = _ref.columnData; + var dataKey = _ref.dataKey; + var disableSort = _ref.disableSort; + var label = _ref.label; + var sortBy = _ref.sortBy; + var sortDirection = _ref.sortDirection; - var _ref$columnIndex = _ref.columnIndex; - var columnIndex = _ref$columnIndex === undefined ? 0 : _ref$columnIndex; - var _ref$rowIndex = _ref.rowIndex; - var rowIndex = _ref$rowIndex === undefined ? 0 : _ref$rowIndex; + var showSortIndicator = sortBy === dataKey; + var children = [_react2.default.createElement( + 'span', + { + className: 'FlexTable__headerTruncatedText', + key: 'label', + title: label + }, + label + )]; - this._columnSizeAndPositionManager.resetCell(columnIndex); - this._rowSizeAndPositionManager.resetCell(rowIndex); + if (showSortIndicator) { + children.push(_react2.default.createElement(_SortIndicator2.default, { + key: 'SortIndicator', + sortDirection: sortDirection + })); + } - // Clear cell cache in case we are scrolling; - // Invalid row heights likely mean invalid cached content as well. - this._cellCache = {}; + return children; +} +},{"./SortIndicator":52,"react":undefined}],56:[function(require,module,exports){ +'use strict'; - this.forceUpdate(); - } - }, { - key: 'componentDidMount', - value: function componentDidMount() { - var _props2 = this.props; - var scrollLeft = _props2.scrollLeft; - var scrollToColumn = _props2.scrollToColumn; - var scrollTop = _props2.scrollTop; - var scrollToRow = _props2.scrollToRow; +Object.defineProperty(exports, "__esModule", { + value: true +}); - // If this component was first rendered server-side, scrollbar size will be undefined. - // In that event we need to remeasure. +var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; - if (!this._scrollbarSizeMeasured) { - this._scrollbarSize = (0, _scrollbarSize2.default)(); - this._scrollbarSizeMeasured = true; - this.setState({}); - } +exports.default = defaultRowRenderer; - if (scrollLeft >= 0 || scrollTop >= 0) { - this._setScrollPosition({ scrollLeft: scrollLeft, scrollTop: scrollTop }); - } +var _react = require('react'); - if (scrollToColumn >= 0 || scrollToRow >= 0) { - this._updateScrollLeftForScrollToColumn(); - this._updateScrollTopForScrollToRow(); - } +var _react2 = _interopRequireDefault(_react); - // Update onRowsRendered callback - this._invokeOnGridRenderedHelper(); +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - // Initialize onScroll callback - this._invokeOnScrollMemoizer({ - scrollLeft: scrollLeft || 0, - scrollTop: scrollTop || 0, - totalColumnsWidth: this._columnSizeAndPositionManager.getTotalSize(), - totalRowsHeight: this._rowSizeAndPositionManager.getTotalSize() - }); - } +/** + * Default row renderer for FlexTable. + */ +function defaultRowRenderer(_ref) { + var className = _ref.className; + var columns = _ref.columns; + var index = _ref.index; + var isScrolling = _ref.isScrolling; + var onRowClick = _ref.onRowClick; + var onRowDoubleClick = _ref.onRowDoubleClick; + var onRowMouseOver = _ref.onRowMouseOver; + var onRowMouseOut = _ref.onRowMouseOut; + var rowData = _ref.rowData; + var style = _ref.style; - /** - * @private - * This method updates scrollLeft/scrollTop in state for the following conditions: - * 1) New scroll-to-cell props have been set - */ + var a11yProps = {}; - }, { - key: 'componentDidUpdate', - value: function componentDidUpdate(prevProps, prevState) { - var _this2 = this; + if (onRowClick || onRowDoubleClick || onRowMouseOver || onRowMouseOut) { + a11yProps['aria-label'] = 'row'; + a11yProps.role = 'row'; + a11yProps.tabIndex = 0; - var _props3 = this.props; - var autoHeight = _props3.autoHeight; - var columnCount = _props3.columnCount; - var height = _props3.height; - var rowCount = _props3.rowCount; - var scrollToAlignment = _props3.scrollToAlignment; - var scrollToColumn = _props3.scrollToColumn; - var scrollToRow = _props3.scrollToRow; - var width = _props3.width; - var _state = this.state; - var scrollLeft = _state.scrollLeft; - var scrollPositionChangeReason = _state.scrollPositionChangeReason; - var scrollTop = _state.scrollTop; + if (onRowClick) { + a11yProps.onClick = function () { + return onRowClick({ index: index }); + }; + } + if (onRowDoubleClick) { + a11yProps.onDoubleClick = function () { + return onRowDoubleClick({ index: index }); + }; + } + if (onRowMouseOut) { + a11yProps.onMouseOut = function () { + return onRowMouseOut({ index: index }); + }; + } + if (onRowMouseOver) { + a11yProps.onMouseOver = function () { + return onRowMouseOver({ index: index }); + }; + } + } - // Handle edge case where column or row count has only just increased over 0. - // In this case we may have to restore a previously-specified scroll offset. - // For more info see bvaughn/react-virtualized/issues/218 + return _react2.default.createElement( + 'div', + _extends({}, a11yProps, { + className: className, + style: style + }), + columns + ); +} +},{"react":undefined}],57:[function(require,module,exports){ +'use strict'; - var columnOrRowCountJustIncreasedFromZero = columnCount > 0 && prevProps.columnCount === 0 || rowCount > 0 && prevProps.rowCount === 0; +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.SortIndicator = exports.SortDirection = exports.FlexColumn = exports.FlexTable = exports.defaultRowRenderer = exports.defaultHeaderRenderer = exports.defaultCellRenderer = exports.defaultCellDataGetter = exports.default = undefined; - // Make sure requested changes to :scrollLeft or :scrollTop get applied. - // Assigning to scrollLeft/scrollTop tells the browser to interrupt any running scroll animations, - // And to discard any pending async changes to the scroll position that may have happened in the meantime (e.g. on a separate scrolling thread). - // So we only set these when we require an adjustment of the scroll position. - // See issue #2 for more information. - if (scrollPositionChangeReason === SCROLL_POSITION_CHANGE_REASONS.REQUESTED) { - if (scrollLeft >= 0 && (scrollLeft !== prevState.scrollLeft && scrollLeft !== this._scrollingContainer.scrollLeft || columnOrRowCountJustIncreasedFromZero)) { - this._scrollingContainer.scrollLeft = scrollLeft; - } +var _FlexTable2 = require('./FlexTable'); - // @TRICKY :autoHeight property instructs Grid to leave :scrollTop management to an external HOC (eg WindowScroller). - // In this case we should avoid checking scrollingContainer.scrollTop since it forces layout/flow. - if (!autoHeight && scrollTop >= 0 && (scrollTop !== prevState.scrollTop && scrollTop !== this._scrollingContainer.scrollTop || columnOrRowCountJustIncreasedFromZero)) { - this._scrollingContainer.scrollTop = scrollTop; - } - } +var _FlexTable3 = _interopRequireDefault(_FlexTable2); - // Update scroll offsets if the current :scrollToColumn or :scrollToRow values requires it - // @TODO Do we also need this check or can the one in componentWillUpdate() suffice? - (0, _updateScrollIndexHelper2.default)({ - cellSizeAndPositionManager: this._columnSizeAndPositionManager, - previousCellsCount: prevProps.columnCount, - previousCellSize: prevProps.columnWidth, - previousScrollToAlignment: prevProps.scrollToAlignment, - previousScrollToIndex: prevProps.scrollToColumn, - previousSize: prevProps.width, - scrollOffset: scrollLeft, - scrollToAlignment: scrollToAlignment, - scrollToIndex: scrollToColumn, - size: width, - updateScrollIndexCallback: function updateScrollIndexCallback(scrollToColumn) { - return _this2._updateScrollLeftForScrollToColumn(_extends({}, _this2.props, { scrollToColumn: scrollToColumn })); - } - }); - (0, _updateScrollIndexHelper2.default)({ - cellSizeAndPositionManager: this._rowSizeAndPositionManager, - previousCellsCount: prevProps.rowCount, - previousCellSize: prevProps.rowHeight, - previousScrollToAlignment: prevProps.scrollToAlignment, - previousScrollToIndex: prevProps.scrollToRow, - previousSize: prevProps.height, - scrollOffset: scrollTop, - scrollToAlignment: scrollToAlignment, - scrollToIndex: scrollToRow, - size: height, - updateScrollIndexCallback: function updateScrollIndexCallback(scrollToRow) { - return _this2._updateScrollTopForScrollToRow(_extends({}, _this2.props, { scrollToRow: scrollToRow })); - } - }); +var _defaultCellDataGetter2 = require('./defaultCellDataGetter'); - // Update onRowsRendered callback if start/stop indices have changed - this._invokeOnGridRenderedHelper(); - } - }, { - key: 'componentWillMount', - value: function componentWillMount() { - // If this component is being rendered server-side, getScrollbarSize() will return undefined. - // We handle this case in componentDidMount() - this._scrollbarSize = (0, _scrollbarSize2.default)(); - if (this._scrollbarSize === undefined) { - this._scrollbarSizeMeasured = false; - this._scrollbarSize = 0; - } else { - this._scrollbarSizeMeasured = true; - } +var _defaultCellDataGetter3 = _interopRequireDefault(_defaultCellDataGetter2); - this._calculateChildrenToRender(); - } - }, { - key: 'componentWillUnmount', - value: function componentWillUnmount() { - if (this._disablePointerEventsTimeoutId) { - clearTimeout(this._disablePointerEventsTimeoutId); - } +var _defaultCellRenderer2 = require('./defaultCellRenderer'); - if (this._setNextStateAnimationFrameId) { - _raf2.default.cancel(this._setNextStateAnimationFrameId); - } - } +var _defaultCellRenderer3 = _interopRequireDefault(_defaultCellRenderer2); + +var _defaultHeaderRenderer2 = require('./defaultHeaderRenderer'); - /** - * @private - * This method updates scrollLeft/scrollTop in state for the following conditions: - * 1) Empty content (0 rows or columns) - * 2) New scroll props overriding the current state - * 3) Cells-count or cells-size has changed, making previous scroll offsets invalid - */ +var _defaultHeaderRenderer3 = _interopRequireDefault(_defaultHeaderRenderer2); - }, { - key: 'componentWillUpdate', - value: function componentWillUpdate(nextProps, nextState) { - var _this3 = this; +var _defaultRowRenderer2 = require('./defaultRowRenderer'); - if (nextProps.columnCount === 0 && nextState.scrollLeft !== 0 || nextProps.rowCount === 0 && nextState.scrollTop !== 0) { - this._setScrollPosition({ - scrollLeft: 0, - scrollTop: 0 - }); - } else if (nextProps.scrollLeft !== this.props.scrollLeft || nextProps.scrollTop !== this.props.scrollTop) { - this._setScrollPosition({ - scrollLeft: nextProps.scrollLeft, - scrollTop: nextProps.scrollTop - }); - } +var _defaultRowRenderer3 = _interopRequireDefault(_defaultRowRenderer2); - this._columnWidthGetter = this._wrapSizeGetter(nextProps.columnWidth); - this._rowHeightGetter = this._wrapSizeGetter(nextProps.rowHeight); +var _FlexColumn2 = require('./FlexColumn'); - this._columnSizeAndPositionManager.configure({ - cellCount: nextProps.columnCount, - estimatedCellSize: this._getEstimatedColumnSize(nextProps) - }); - this._rowSizeAndPositionManager.configure({ - cellCount: nextProps.rowCount, - estimatedCellSize: this._getEstimatedRowSize(nextProps) - }); +var _FlexColumn3 = _interopRequireDefault(_FlexColumn2); - // Update scroll offsets if the size or number of cells have changed, invalidating the previous value - (0, _calculateSizeAndPositionDataAndUpdateScrollOffset2.default)({ - cellCount: this.props.columnCount, - cellSize: this.props.columnWidth, - computeMetadataCallback: function computeMetadataCallback() { - return _this3._columnSizeAndPositionManager.resetCell(0); - }, - computeMetadataCallbackProps: nextProps, - nextCellsCount: nextProps.columnCount, - nextCellSize: nextProps.columnWidth, - nextScrollToIndex: nextProps.scrollToColumn, - scrollToIndex: this.props.scrollToColumn, - updateScrollOffsetForScrollToIndex: function updateScrollOffsetForScrollToIndex() { - return _this3._updateScrollLeftForScrollToColumn(nextProps, nextState); - } - }); - (0, _calculateSizeAndPositionDataAndUpdateScrollOffset2.default)({ - cellCount: this.props.rowCount, - cellSize: this.props.rowHeight, - computeMetadataCallback: function computeMetadataCallback() { - return _this3._rowSizeAndPositionManager.resetCell(0); - }, - computeMetadataCallbackProps: nextProps, - nextCellsCount: nextProps.rowCount, - nextCellSize: nextProps.rowHeight, - nextScrollToIndex: nextProps.scrollToRow, - scrollToIndex: this.props.scrollToRow, - updateScrollOffsetForScrollToIndex: function updateScrollOffsetForScrollToIndex() { - return _this3._updateScrollTopForScrollToRow(nextProps, nextState); - } - }); +var _SortDirection2 = require('./SortDirection'); - this._calculateChildrenToRender(nextProps, nextState); - } - }, { - key: 'render', - value: function render() { - var _this4 = this; +var _SortDirection3 = _interopRequireDefault(_SortDirection2); - var _props4 = this.props; - var autoContainerWidth = _props4.autoContainerWidth; - var autoHeight = _props4.autoHeight; - var className = _props4.className; - var height = _props4.height; - var noContentRenderer = _props4.noContentRenderer; - var style = _props4.style; - var tabIndex = _props4.tabIndex; - var width = _props4.width; - var isScrolling = this.state.isScrolling; +var _SortIndicator2 = require('./SortIndicator'); +var _SortIndicator3 = _interopRequireDefault(_SortIndicator2); - var gridStyle = { - height: autoHeight ? 'auto' : height, - width: width - }; +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - var totalColumnsWidth = this._columnSizeAndPositionManager.getTotalSize(); - var totalRowsHeight = this._rowSizeAndPositionManager.getTotalSize(); +exports.default = _FlexTable3.default; +exports.defaultCellDataGetter = _defaultCellDataGetter3.default; +exports.defaultCellRenderer = _defaultCellRenderer3.default; +exports.defaultHeaderRenderer = _defaultHeaderRenderer3.default; +exports.defaultRowRenderer = _defaultRowRenderer3.default; +exports.FlexTable = _FlexTable3.default; +exports.FlexColumn = _FlexColumn3.default; +exports.SortDirection = _SortDirection3.default; +exports.SortIndicator = _SortIndicator3.default; +},{"./FlexColumn":49,"./FlexTable":50,"./SortDirection":51,"./SortIndicator":52,"./defaultCellDataGetter":53,"./defaultCellRenderer":54,"./defaultHeaderRenderer":55,"./defaultRowRenderer":56}],58:[function(require,module,exports){ +'use strict'; - // Force browser to hide scrollbars when we know they aren't necessary. - // Otherwise once scrollbars appear they may not disappear again. - // For more info see issue #116 - var verticalScrollBarSize = totalRowsHeight > height ? this._scrollbarSize : 0; - var horizontalScrollBarSize = totalColumnsWidth > width ? this._scrollbarSize : 0; +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.DEFAULT_SCROLLING_RESET_TIME_INTERVAL = undefined; - // Also explicitly init styles to 'auto' if scrollbars are required. - // This works around an obscure edge case where external CSS styles have not yet been loaded, - // But an initial scroll index of offset is set as an external prop. - // Without this style, Grid would render the correct range of cells but would NOT update its internal offset. - // This was originally reported via clauderic/react-infinite-calendar/issues/23 - gridStyle.overflowX = totalColumnsWidth + verticalScrollBarSize <= width ? 'hidden' : 'auto'; - gridStyle.overflowY = totalRowsHeight + horizontalScrollBarSize <= height ? 'hidden' : 'auto'; +var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; - var childrenToDisplay = this._childrenToDisplay; +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); - var showNoContentRenderer = childrenToDisplay.length === 0 && height > 0 && width > 0; +var _react = require('react'); - return _react2.default.createElement( - 'div', - { - ref: function ref(_ref2) { - _this4._scrollingContainer = _ref2; - }, - 'aria-label': this.props['aria-label'], - className: (0, _classnames2.default)('Grid', className), - onScroll: this._onScroll, - role: 'grid', - style: _extends({}, gridStyle, style), - tabIndex: tabIndex - }, - childrenToDisplay.length > 0 && _react2.default.createElement( - 'div', - { - className: 'Grid__innerScrollContainer', - style: { - width: autoContainerWidth ? 'auto' : totalColumnsWidth, - height: totalRowsHeight, - maxWidth: totalColumnsWidth, - maxHeight: totalRowsHeight, - pointerEvents: isScrolling ? 'none' : '' - } - }, - childrenToDisplay - ), - showNoContentRenderer && noContentRenderer() - ); - } - }, { - key: 'shouldComponentUpdate', - value: function shouldComponentUpdate(nextProps, nextState) { - return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState); - } +var _react2 = _interopRequireDefault(_react); - /* ---------------------------- Helper methods ---------------------------- */ +var _classnames = require('classnames'); - }, { - key: '_calculateChildrenToRender', - value: function _calculateChildrenToRender() { - var props = arguments.length <= 0 || arguments[0] === undefined ? this.props : arguments[0]; - var state = arguments.length <= 1 || arguments[1] === undefined ? this.state : arguments[1]; - var cellClassName = props.cellClassName; - var cellRenderer = props.cellRenderer; - var cellRangeRenderer = props.cellRangeRenderer; - var cellStyle = props.cellStyle; - var columnCount = props.columnCount; - var height = props.height; - var overscanColumnCount = props.overscanColumnCount; - var overscanRowCount = props.overscanRowCount; - var rowCount = props.rowCount; - var width = props.width; - var isScrolling = state.isScrolling; - var scrollDirectionHorizontal = state.scrollDirectionHorizontal; - var scrollDirectionVertical = state.scrollDirectionVertical; - var scrollLeft = state.scrollLeft; - var scrollTop = state.scrollTop; +var _classnames2 = _interopRequireDefault(_classnames); +var _calculateSizeAndPositionDataAndUpdateScrollOffset = require('./utils/calculateSizeAndPositionDataAndUpdateScrollOffset'); - this._childrenToDisplay = []; +var _calculateSizeAndPositionDataAndUpdateScrollOffset2 = _interopRequireDefault(_calculateSizeAndPositionDataAndUpdateScrollOffset); - // Render only enough columns and rows to cover the visible area of the grid. - if (height > 0 && width > 0) { - var visibleColumnIndices = this._columnSizeAndPositionManager.getVisibleCellRange({ - containerSize: width, - offset: scrollLeft - }); - var visibleRowIndices = this._rowSizeAndPositionManager.getVisibleCellRange({ - containerSize: height, - offset: scrollTop - }); +var _ScalingCellSizeAndPositionManager = require('./utils/ScalingCellSizeAndPositionManager'); - var horizontalOffsetAdjustment = this._columnSizeAndPositionManager.getOffsetAdjustment({ - containerSize: width, - offset: scrollLeft - }); - var verticalOffsetAdjustment = this._rowSizeAndPositionManager.getOffsetAdjustment({ - containerSize: height, - offset: scrollTop - }); +var _ScalingCellSizeAndPositionManager2 = _interopRequireDefault(_ScalingCellSizeAndPositionManager); - // Store for _invokeOnGridRenderedHelper() - this._renderedColumnStartIndex = visibleColumnIndices.start; - this._renderedColumnStopIndex = visibleColumnIndices.stop; - this._renderedRowStartIndex = visibleRowIndices.start; - this._renderedRowStopIndex = visibleRowIndices.stop; +var _createCallbackMemoizer = require('../utils/createCallbackMemoizer'); - var overscanColumnIndices = (0, _getOverscanIndices2.default)({ - cellCount: columnCount, - overscanCellsCount: overscanColumnCount, - scrollDirection: scrollDirectionHorizontal, - startIndex: this._renderedColumnStartIndex, - stopIndex: this._renderedColumnStopIndex - }); +var _createCallbackMemoizer2 = _interopRequireDefault(_createCallbackMemoizer); - var overscanRowIndices = (0, _getOverscanIndices2.default)({ - cellCount: rowCount, - overscanCellsCount: overscanRowCount, - scrollDirection: scrollDirectionVertical, - startIndex: this._renderedRowStartIndex, - stopIndex: this._renderedRowStopIndex - }); +var _getOverscanIndices = require('./utils/getOverscanIndices'); - // Store for _invokeOnGridRenderedHelper() - this._columnStartIndex = overscanColumnIndices.overscanStartIndex; - this._columnStopIndex = overscanColumnIndices.overscanStopIndex; - this._rowStartIndex = overscanRowIndices.overscanStartIndex; - this._rowStopIndex = overscanRowIndices.overscanStopIndex; +var _getOverscanIndices2 = _interopRequireDefault(_getOverscanIndices); - this._childrenToDisplay = cellRangeRenderer({ - cellCache: this._cellCache, - cellClassName: this._wrapCellClassNameGetter(cellClassName), - cellRenderer: cellRenderer, - cellStyle: this._wrapCellStyleGetter(cellStyle), - columnSizeAndPositionManager: this._columnSizeAndPositionManager, - columnStartIndex: this._columnStartIndex, - columnStopIndex: this._columnStopIndex, - horizontalOffsetAdjustment: horizontalOffsetAdjustment, - isScrolling: isScrolling, - rowSizeAndPositionManager: this._rowSizeAndPositionManager, - rowStartIndex: this._rowStartIndex, - rowStopIndex: this._rowStopIndex, - scrollLeft: scrollLeft, - scrollTop: scrollTop, - verticalOffsetAdjustment: verticalOffsetAdjustment - }); - } - } +var _scrollbarSize = require('dom-helpers/util/scrollbarSize'); - /** - * Sets an :isScrolling flag for a small window of time. - * This flag is used to disable pointer events on the scrollable portion of the Grid. - * This prevents jerky/stuttery mouse-wheel scrolling. - */ +var _scrollbarSize2 = _interopRequireDefault(_scrollbarSize); - }, { - key: '_enablePointerEventsAfterDelay', - value: function _enablePointerEventsAfterDelay() { - var scrollingResetTimeInterval = this.props.scrollingResetTimeInterval; +var _raf = require('raf'); +var _raf2 = _interopRequireDefault(_raf); - if (this._disablePointerEventsTimeoutId) { - clearTimeout(this._disablePointerEventsTimeoutId); - } +var _reactAddonsShallowCompare = require('react-addons-shallow-compare'); - this._disablePointerEventsTimeoutId = setTimeout(this._enablePointerEventsAfterDelayCallback, scrollingResetTimeInterval); - } - }, { - key: '_enablePointerEventsAfterDelayCallback', - value: function _enablePointerEventsAfterDelayCallback() { - this._disablePointerEventsTimeoutId = null; +var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); - // Throw away cell cache once scrolling is complete - this._cellCache = {}; +var _updateScrollIndexHelper = require('./utils/updateScrollIndexHelper'); - this.setState({ - isScrolling: false, - scrollDirectionHorizontal: _getOverscanIndices.SCROLL_DIRECTION_FIXED, - scrollDirectionVertical: _getOverscanIndices.SCROLL_DIRECTION_FIXED - }); - } - }, { - key: '_getEstimatedColumnSize', - value: function _getEstimatedColumnSize(props) { - return typeof props.columnWidth === 'number' ? props.columnWidth : props.estimatedColumnSize; - } - }, { - key: '_getEstimatedRowSize', - value: function _getEstimatedRowSize(props) { - return typeof props.rowHeight === 'number' ? props.rowHeight : props.estimatedRowSize; - } - }, { - key: '_invokeOnGridRenderedHelper', - value: function _invokeOnGridRenderedHelper() { - var onSectionRendered = this.props.onSectionRendered; +var _updateScrollIndexHelper2 = _interopRequireDefault(_updateScrollIndexHelper); +var _defaultCellRangeRenderer = require('./defaultCellRangeRenderer'); - this._onGridRenderedMemoizer({ - callback: onSectionRendered, - indices: { - columnOverscanStartIndex: this._columnStartIndex, - columnOverscanStopIndex: this._columnStopIndex, - columnStartIndex: this._renderedColumnStartIndex, - columnStopIndex: this._renderedColumnStopIndex, - rowOverscanStartIndex: this._rowStartIndex, - rowOverscanStopIndex: this._rowStopIndex, - rowStartIndex: this._renderedRowStartIndex, - rowStopIndex: this._renderedRowStopIndex - } - }); - } - }, { - key: '_invokeOnScrollMemoizer', - value: function _invokeOnScrollMemoizer(_ref3) { - var _this5 = this; +var _defaultCellRangeRenderer2 = _interopRequireDefault(_defaultCellRangeRenderer); - var scrollLeft = _ref3.scrollLeft; - var scrollTop = _ref3.scrollTop; - var totalColumnsWidth = _ref3.totalColumnsWidth; - var totalRowsHeight = _ref3.totalRowsHeight; +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - this._onScrollMemoizer({ - callback: function callback(_ref4) { - var scrollLeft = _ref4.scrollLeft; - var scrollTop = _ref4.scrollTop; - var _props5 = _this5.props; - var height = _props5.height; - var onScroll = _props5.onScroll; - var width = _props5.width; +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } - onScroll({ - clientHeight: height, - clientWidth: width, - scrollHeight: totalRowsHeight, - scrollLeft: scrollLeft, - scrollTop: scrollTop, - scrollWidth: totalColumnsWidth - }); - }, - indices: { - scrollLeft: scrollLeft, - scrollTop: scrollTop - } - }); - } +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } - /** - * Updates the state during the next animation frame. - * Use this method to avoid multiple renders in a small span of time. - * This helps performance for bursty events (like onScroll). - */ +/** + * Specifies the number of miliseconds during which to disable pointer events while a scroll is in progress. + * This improves performance and makes scrolling smoother. + */ +var DEFAULT_SCROLLING_RESET_TIME_INTERVAL = exports.DEFAULT_SCROLLING_RESET_TIME_INTERVAL = 150; - }, { - key: '_setNextState', - value: function _setNextState(state) { - this._nextState = state; +/** + * Controls whether the Grid updates the DOM element's scrollLeft/scrollTop based on the current state or just observes it. + * This prevents Grid from interrupting mouse-wheel animations (see issue #2). + */ +var SCROLL_POSITION_CHANGE_REASONS = { + OBSERVED: 'observed', + REQUESTED: 'requested' +}; - if (!this._setNextStateAnimationFrameId) { - this._setNextStateAnimationFrameId = (0, _raf2.default)(this._setNextStateCallback); - } - } - }, { - key: '_setNextStateCallback', - value: function _setNextStateCallback() { - var state = this._nextState; +/** + * Renders tabular data with virtualization along the vertical and horizontal axes. + * Row heights and column widths must be known ahead of time and specified as properties. + */ - this._setNextStateAnimationFrameId = null; - this._nextState = null; +var Grid = function (_Component) { + _inherits(Grid, _Component); - this.setState(state); - } - }, { - key: '_setScrollPosition', - value: function _setScrollPosition(_ref5) { - var scrollLeft = _ref5.scrollLeft; - var scrollTop = _ref5.scrollTop; + function Grid(props, context) { + _classCallCheck(this, Grid); - var newState = { - scrollPositionChangeReason: SCROLL_POSITION_CHANGE_REASONS.REQUESTED - }; + var _this = _possibleConstructorReturn(this, (Grid.__proto__ || Object.getPrototypeOf(Grid)).call(this, props, context)); - if (scrollLeft >= 0) { - newState.scrollLeft = scrollLeft; - } + _this.state = { + isScrolling: false, + scrollDirectionHorizontal: _getOverscanIndices.SCROLL_DIRECTION_FIXED, + scrollDirectionVertical: _getOverscanIndices.SCROLL_DIRECTION_FIXED, + scrollLeft: 0, + scrollTop: 0 + }; - if (scrollTop >= 0) { - newState.scrollTop = scrollTop; - } + // Invokes onSectionRendered callback only when start/stop row or column indices change + _this._onGridRenderedMemoizer = (0, _createCallbackMemoizer2.default)(); + _this._onScrollMemoizer = (0, _createCallbackMemoizer2.default)(false); - if (scrollLeft >= 0 && scrollLeft !== this.state.scrollLeft || scrollTop >= 0 && scrollTop !== this.state.scrollTop) { - this.setState(newState); - } - } - }, { - key: '_wrapCellClassNameGetter', - value: function _wrapCellClassNameGetter(className) { - return this._wrapPropertyGetter(className); - } - }, { - key: '_wrapCellStyleGetter', - value: function _wrapCellStyleGetter(style) { - return this._wrapPropertyGetter(style); - } - }, { - key: '_wrapPropertyGetter', - value: function _wrapPropertyGetter(value) { - return value instanceof Function ? value : function () { - return value; - }; - } - }, { - key: '_wrapSizeGetter', - value: function _wrapSizeGetter(size) { - return this._wrapPropertyGetter(size); + // Bind functions to instance so they don't lose context when passed around + _this._enablePointerEventsAfterDelayCallback = _this._enablePointerEventsAfterDelayCallback.bind(_this); + _this._invokeOnGridRenderedHelper = _this._invokeOnGridRenderedHelper.bind(_this); + _this._onScroll = _this._onScroll.bind(_this); + _this._setNextStateCallback = _this._setNextStateCallback.bind(_this); + _this._updateScrollLeftForScrollToColumn = _this._updateScrollLeftForScrollToColumn.bind(_this); + _this._updateScrollTopForScrollToRow = _this._updateScrollTopForScrollToRow.bind(_this); + + _this._columnWidthGetter = _this._wrapSizeGetter(props.columnWidth); + _this._rowHeightGetter = _this._wrapSizeGetter(props.rowHeight); + + _this._columnSizeAndPositionManager = new _ScalingCellSizeAndPositionManager2.default({ + cellCount: props.columnCount, + cellSizeGetter: function cellSizeGetter(index) { + return _this._columnWidthGetter(index); + }, + estimatedCellSize: _this._getEstimatedColumnSize(props) + }); + _this._rowSizeAndPositionManager = new _ScalingCellSizeAndPositionManager2.default({ + cellCount: props.rowCount, + cellSizeGetter: function cellSizeGetter(index) { + return _this._rowHeightGetter(index); + }, + estimatedCellSize: _this._getEstimatedRowSize(props) + }); + + // See defaultCellRangeRenderer() for more information on the usage of this cache + _this._cellCache = {}; + return _this; + } + + /** + * Pre-measure all columns and rows in a Grid. + * Typically cells are only measured as needed and estimated sizes are used for cells that have not yet been measured. + * This method ensures that the next call to getTotalSize() returns an exact size (as opposed to just an estimated one). + */ + + + _createClass(Grid, [{ + key: 'measureAllCells', + value: function measureAllCells() { + var _props = this.props; + var columnCount = _props.columnCount; + var rowCount = _props.rowCount; + + + this._columnSizeAndPositionManager.getSizeAndPositionOfCell(columnCount - 1); + this._rowSizeAndPositionManager.getSizeAndPositionOfCell(rowCount - 1); } - }, { - key: '_updateScrollLeftForScrollToColumn', - value: function _updateScrollLeftForScrollToColumn() { - var props = arguments.length <= 0 || arguments[0] === undefined ? this.props : arguments[0]; - var state = arguments.length <= 1 || arguments[1] === undefined ? this.state : arguments[1]; - var columnCount = props.columnCount; - var scrollToAlignment = props.scrollToAlignment; - var scrollToColumn = props.scrollToColumn; - var width = props.width; - var scrollLeft = state.scrollLeft; + /** + * Forced recompute of row heights and column widths. + * This function should be called if dynamic column or row sizes have changed but nothing else has. + * Since Grid only receives :columnCount and :rowCount it has no way of detecting when the underlying data changes. + */ + + }, { + key: 'recomputeGridSize', + value: function recomputeGridSize() { + var _ref = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; + + var _ref$columnIndex = _ref.columnIndex; + var columnIndex = _ref$columnIndex === undefined ? 0 : _ref$columnIndex; + var _ref$rowIndex = _ref.rowIndex; + var rowIndex = _ref$rowIndex === undefined ? 0 : _ref$rowIndex; - if (scrollToColumn >= 0 && columnCount > 0) { - var targetIndex = Math.max(0, Math.min(columnCount - 1, scrollToColumn)); + this._columnSizeAndPositionManager.resetCell(columnIndex); + this._rowSizeAndPositionManager.resetCell(rowIndex); - var calculatedScrollLeft = this._columnSizeAndPositionManager.getUpdatedOffsetForIndex({ - align: scrollToAlignment, - containerSize: width, - currentOffset: scrollLeft, - targetIndex: targetIndex - }); + // Clear cell cache in case we are scrolling; + // Invalid row heights likely mean invalid cached content as well. + this._cellCache = {}; - if (scrollLeft !== calculatedScrollLeft) { - this._setScrollPosition({ - scrollLeft: calculatedScrollLeft - }); - } - } + this.forceUpdate(); } }, { - key: '_updateScrollTopForScrollToRow', - value: function _updateScrollTopForScrollToRow() { - var props = arguments.length <= 0 || arguments[0] === undefined ? this.props : arguments[0]; - var state = arguments.length <= 1 || arguments[1] === undefined ? this.state : arguments[1]; - var height = props.height; - var rowCount = props.rowCount; - var scrollToAlignment = props.scrollToAlignment; - var scrollToRow = props.scrollToRow; - var scrollTop = state.scrollTop; + key: 'componentDidMount', + value: function componentDidMount() { + var _props2 = this.props; + var scrollLeft = _props2.scrollLeft; + var scrollToColumn = _props2.scrollToColumn; + var scrollTop = _props2.scrollTop; + var scrollToRow = _props2.scrollToRow; + // If this component was first rendered server-side, scrollbar size will be undefined. + // In that event we need to remeasure. - if (scrollToRow >= 0 && rowCount > 0) { - var targetIndex = Math.max(0, Math.min(rowCount - 1, scrollToRow)); + if (!this._scrollbarSizeMeasured) { + this._scrollbarSize = (0, _scrollbarSize2.default)(); + this._scrollbarSizeMeasured = true; + this.setState({}); + } - var calculatedScrollTop = this._rowSizeAndPositionManager.getUpdatedOffsetForIndex({ - align: scrollToAlignment, - containerSize: height, - currentOffset: scrollTop, - targetIndex: targetIndex - }); + if (scrollLeft >= 0 || scrollTop >= 0) { + this._setScrollPosition({ scrollLeft: scrollLeft, scrollTop: scrollTop }); + } - if (scrollTop !== calculatedScrollTop) { - this._setScrollPosition({ - scrollTop: calculatedScrollTop - }); - } + if (scrollToColumn >= 0 || scrollToRow >= 0) { + this._updateScrollLeftForScrollToColumn(); + this._updateScrollTopForScrollToRow(); } + + // Update onRowsRendered callback + this._invokeOnGridRenderedHelper(); + + // Initialize onScroll callback + this._invokeOnScrollMemoizer({ + scrollLeft: scrollLeft || 0, + scrollTop: scrollTop || 0, + totalColumnsWidth: this._columnSizeAndPositionManager.getTotalSize(), + totalRowsHeight: this._rowSizeAndPositionManager.getTotalSize() + }); } - }, { - key: '_onScroll', - value: function _onScroll(event) { - // In certain edge-cases React dispatches an onScroll event with an invalid target.scrollLeft / target.scrollTop. - // This invalid event can be detected by comparing event.target to this component's scrollable DOM element. - // See issue #404 for more information. - if (event.target !== this._scrollingContainer) { - return; - } - // Prevent pointer events from interrupting a smooth scroll - this._enablePointerEventsAfterDelay(); + /** + * @private + * This method updates scrollLeft/scrollTop in state for the following conditions: + * 1) New scroll-to-cell props have been set + */ - // When this component is shrunk drastically, React dispatches a series of back-to-back scroll events, - // Gradually converging on a scrollTop that is within the bounds of the new, smaller height. - // This causes a series of rapid renders that is slow for long lists. - // We can avoid that by doing some simple bounds checking to ensure that scrollTop never exceeds the total height. - var _props6 = this.props; - var height = _props6.height; - var width = _props6.width; + }, { + key: 'componentDidUpdate', + value: function componentDidUpdate(prevProps, prevState) { + var _this2 = this; - var scrollbarSize = this._scrollbarSize; - var totalRowsHeight = this._rowSizeAndPositionManager.getTotalSize(); - var totalColumnsWidth = this._columnSizeAndPositionManager.getTotalSize(); - var scrollLeft = Math.min(Math.max(0, totalColumnsWidth - width + scrollbarSize), event.target.scrollLeft); - var scrollTop = Math.min(Math.max(0, totalRowsHeight - height + scrollbarSize), event.target.scrollTop); + var _props3 = this.props; + var autoHeight = _props3.autoHeight; + var columnCount = _props3.columnCount; + var height = _props3.height; + var rowCount = _props3.rowCount; + var scrollToAlignment = _props3.scrollToAlignment; + var scrollToColumn = _props3.scrollToColumn; + var scrollToRow = _props3.scrollToRow; + var width = _props3.width; + var _state = this.state; + var scrollLeft = _state.scrollLeft; + var scrollPositionChangeReason = _state.scrollPositionChangeReason; + var scrollTop = _state.scrollTop; - // Certain devices (like Apple touchpad) rapid-fire duplicate events. - // Don't force a re-render if this is the case. - // The mouse may move faster then the animation frame does. - // Use requestAnimationFrame to avoid over-updating. - if (this.state.scrollLeft !== scrollLeft || this.state.scrollTop !== scrollTop) { - // Browsers with cancelable scroll events (eg. Firefox) interrupt scrolling animations if scrollTop/scrollLeft is set. - // Other browsers (eg. Safari) don't scroll as well without the help under certain conditions (DOM or style changes during scrolling). - // All things considered, this seems to be the best current work around that I'm aware of. - // For more information see https://github.com/bvaughn/react-virtualized/pull/124 - var scrollPositionChangeReason = event.cancelable ? SCROLL_POSITION_CHANGE_REASONS.OBSERVED : SCROLL_POSITION_CHANGE_REASONS.REQUESTED; + // Handle edge case where column or row count has only just increased over 0. + // In this case we may have to restore a previously-specified scroll offset. + // For more info see bvaughn/react-virtualized/issues/218 - // Track scrolling direction so we can more efficiently overscan rows to reduce empty space around the edges while scrolling. - var scrollDirectionVertical = scrollTop > this.state.scrollTop ? _getOverscanIndices.SCROLL_DIRECTION_FORWARD : _getOverscanIndices.SCROLL_DIRECTION_BACKWARD; - var scrollDirectionHorizontal = scrollLeft > this.state.scrollLeft ? _getOverscanIndices.SCROLL_DIRECTION_FORWARD : _getOverscanIndices.SCROLL_DIRECTION_BACKWARD; + var columnOrRowCountJustIncreasedFromZero = columnCount > 0 && prevProps.columnCount === 0 || rowCount > 0 && prevProps.rowCount === 0; - if (!this.state.isScrolling) { - this.setState({ - isScrolling: true - }); + // Make sure requested changes to :scrollLeft or :scrollTop get applied. + // Assigning to scrollLeft/scrollTop tells the browser to interrupt any running scroll animations, + // And to discard any pending async changes to the scroll position that may have happened in the meantime (e.g. on a separate scrolling thread). + // So we only set these when we require an adjustment of the scroll position. + // See issue #2 for more information. + if (scrollPositionChangeReason === SCROLL_POSITION_CHANGE_REASONS.REQUESTED) { + if (scrollLeft >= 0 && (scrollLeft !== prevState.scrollLeft && scrollLeft !== this._scrollingContainer.scrollLeft || columnOrRowCountJustIncreasedFromZero)) { + this._scrollingContainer.scrollLeft = scrollLeft; } - this._setNextState({ - isScrolling: true, - scrollDirectionHorizontal: scrollDirectionHorizontal, - scrollDirectionVertical: scrollDirectionVertical, - scrollLeft: scrollLeft, - scrollPositionChangeReason: scrollPositionChangeReason, - scrollTop: scrollTop - }); + // @TRICKY :autoHeight property instructs Grid to leave :scrollTop management to an external HOC (eg WindowScroller). + // In this case we should avoid checking scrollingContainer.scrollTop since it forces layout/flow. + if (!autoHeight && scrollTop >= 0 && (scrollTop !== prevState.scrollTop && scrollTop !== this._scrollingContainer.scrollTop || columnOrRowCountJustIncreasedFromZero)) { + this._scrollingContainer.scrollTop = scrollTop; + } } - this._invokeOnScrollMemoizer({ scrollLeft: scrollLeft, scrollTop: scrollTop, totalColumnsWidth: totalColumnsWidth, totalRowsHeight: totalRowsHeight }); - } - }]); + // Update scroll offsets if the current :scrollToColumn or :scrollToRow values requires it + // @TODO Do we also need this check or can the one in componentWillUpdate() suffice? + (0, _updateScrollIndexHelper2.default)({ + cellSizeAndPositionManager: this._columnSizeAndPositionManager, + previousCellsCount: prevProps.columnCount, + previousCellSize: prevProps.columnWidth, + previousScrollToAlignment: prevProps.scrollToAlignment, + previousScrollToIndex: prevProps.scrollToColumn, + previousSize: prevProps.width, + scrollOffset: scrollLeft, + scrollToAlignment: scrollToAlignment, + scrollToIndex: scrollToColumn, + size: width, + updateScrollIndexCallback: function updateScrollIndexCallback(scrollToColumn) { + return _this2._updateScrollLeftForScrollToColumn(_extends({}, _this2.props, { scrollToColumn: scrollToColumn })); + } + }); + (0, _updateScrollIndexHelper2.default)({ + cellSizeAndPositionManager: this._rowSizeAndPositionManager, + previousCellsCount: prevProps.rowCount, + previousCellSize: prevProps.rowHeight, + previousScrollToAlignment: prevProps.scrollToAlignment, + previousScrollToIndex: prevProps.scrollToRow, + previousSize: prevProps.height, + scrollOffset: scrollTop, + scrollToAlignment: scrollToAlignment, + scrollToIndex: scrollToRow, + size: height, + updateScrollIndexCallback: function updateScrollIndexCallback(scrollToRow) { + return _this2._updateScrollTopForScrollToRow(_extends({}, _this2.props, { scrollToRow: scrollToRow })); + } + }); - return Grid; -}(_react.Component); + // Update onRowsRendered callback if start/stop indices have changed + this._invokeOnGridRenderedHelper(); + } + }, { + key: 'componentWillMount', + value: function componentWillMount() { + // If this component is being rendered server-side, getScrollbarSize() will return undefined. + // We handle this case in componentDidMount() + this._scrollbarSize = (0, _scrollbarSize2.default)(); + if (this._scrollbarSize === undefined) { + this._scrollbarSizeMeasured = false; + this._scrollbarSize = 0; + } else { + this._scrollbarSizeMeasured = true; + } -Grid.propTypes = { - 'aria-label': _react.PropTypes.string, + this._calculateChildrenToRender(); + } + }, { + key: 'componentWillUnmount', + value: function componentWillUnmount() { + if (this._disablePointerEventsTimeoutId) { + clearTimeout(this._disablePointerEventsTimeoutId); + } - /** - * Set the width of the inner scrollable container to 'auto'. - * This is useful for single-column Grids to ensure that the column doesn't extend below a vertical scrollbar. - */ - autoContainerWidth: _react.PropTypes.bool, + if (this._setNextStateAnimationFrameId) { + _raf2.default.cancel(this._setNextStateAnimationFrameId); + } + } - /** - * Removes fixed height from the scrollingContainer so that the total height - * of rows can stretch the window. Intended for use with WindowScroller - */ - autoHeight: _react.PropTypes.bool, + /** + * @private + * This method updates scrollLeft/scrollTop in state for the following conditions: + * 1) Empty content (0 rows or columns) + * 2) New scroll props overriding the current state + * 3) Cells-count or cells-size has changed, making previous scroll offsets invalid + */ - /** Optional custom CSS class for individual cells */ - cellClassName: _react.PropTypes.oneOfType([_react.PropTypes.string, _react.PropTypes.func]), + }, { + key: 'componentWillUpdate', + value: function componentWillUpdate(nextProps, nextState) { + var _this3 = this; - /** Optional custom styles for individual cells */ - cellStyle: _react.PropTypes.oneOfType([_react.PropTypes.object, _react.PropTypes.func]), + if (nextProps.columnCount === 0 && nextState.scrollLeft !== 0 || nextProps.rowCount === 0 && nextState.scrollTop !== 0) { + this._setScrollPosition({ + scrollLeft: 0, + scrollTop: 0 + }); + } else if (nextProps.scrollLeft !== this.props.scrollLeft || nextProps.scrollTop !== this.props.scrollTop) { + this._setScrollPosition({ + scrollLeft: nextProps.scrollLeft, + scrollTop: nextProps.scrollTop + }); + } - /** - * Responsible for rendering a cell given an row and column index. - * Should implement the following interface: ({ columnIndex: number, rowIndex: number }): PropTypes.node - */ - cellRenderer: _react.PropTypes.func.isRequired, + this._columnWidthGetter = this._wrapSizeGetter(nextProps.columnWidth); + this._rowHeightGetter = this._wrapSizeGetter(nextProps.rowHeight); - /** - * Responsible for rendering a group of cells given their index ranges. - * Should implement the following interface: ({ - * cellCache: Map, - * cellRenderer: Function, - * columnSizeAndPositionManager: CellSizeAndPositionManager, - * columnStartIndex: number, - * columnStopIndex: number, - * isScrolling: boolean, - * rowSizeAndPositionManager: CellSizeAndPositionManager, - * rowStartIndex: number, - * rowStopIndex: number, - * scrollLeft: number, - * scrollTop: number - * }): Array - */ - cellRangeRenderer: _react.PropTypes.func.isRequired, + this._columnSizeAndPositionManager.configure({ + cellCount: nextProps.columnCount, + estimatedCellSize: this._getEstimatedColumnSize(nextProps) + }); + this._rowSizeAndPositionManager.configure({ + cellCount: nextProps.rowCount, + estimatedCellSize: this._getEstimatedRowSize(nextProps) + }); - /** - * Optional custom CSS class name to attach to root Grid element. - */ - className: _react.PropTypes.string, + // Update scroll offsets if the size or number of cells have changed, invalidating the previous value + (0, _calculateSizeAndPositionDataAndUpdateScrollOffset2.default)({ + cellCount: this.props.columnCount, + cellSize: this.props.columnWidth, + computeMetadataCallback: function computeMetadataCallback() { + return _this3._columnSizeAndPositionManager.resetCell(0); + }, + computeMetadataCallbackProps: nextProps, + nextCellsCount: nextProps.columnCount, + nextCellSize: nextProps.columnWidth, + nextScrollToIndex: nextProps.scrollToColumn, + scrollToIndex: this.props.scrollToColumn, + updateScrollOffsetForScrollToIndex: function updateScrollOffsetForScrollToIndex() { + return _this3._updateScrollLeftForScrollToColumn(nextProps, nextState); + } + }); + (0, _calculateSizeAndPositionDataAndUpdateScrollOffset2.default)({ + cellCount: this.props.rowCount, + cellSize: this.props.rowHeight, + computeMetadataCallback: function computeMetadataCallback() { + return _this3._rowSizeAndPositionManager.resetCell(0); + }, + computeMetadataCallbackProps: nextProps, + nextCellsCount: nextProps.rowCount, + nextCellSize: nextProps.rowHeight, + nextScrollToIndex: nextProps.scrollToRow, + scrollToIndex: this.props.scrollToRow, + updateScrollOffsetForScrollToIndex: function updateScrollOffsetForScrollToIndex() { + return _this3._updateScrollTopForScrollToRow(nextProps, nextState); + } + }); - /** - * Number of columns in grid. - */ - columnCount: _react.PropTypes.number.isRequired, + this._calculateChildrenToRender(nextProps, nextState); + } + }, { + key: 'render', + value: function render() { + var _this4 = this; - /** - * Either a fixed column width (number) or a function that returns the width of a column given its index. - * Should implement the following interface: (index: number): number - */ - columnWidth: _react.PropTypes.oneOfType([_react.PropTypes.number, _react.PropTypes.func]).isRequired, + var _props4 = this.props; + var autoContainerWidth = _props4.autoContainerWidth; + var autoHeight = _props4.autoHeight; + var className = _props4.className; + var height = _props4.height; + var noContentRenderer = _props4.noContentRenderer; + var style = _props4.style; + var tabIndex = _props4.tabIndex; + var width = _props4.width; + var isScrolling = this.state.isScrolling; - /** - * Used to estimate the total width of a Grid before all of its columns have actually been measured. - * The estimated total width is adjusted as columns are rendered. - */ - estimatedColumnSize: _react.PropTypes.number.isRequired, - /** - * Used to estimate the total height of a Grid before all of its rows have actually been measured. - * The estimated total height is adjusted as rows are rendered. - */ - estimatedRowSize: _react.PropTypes.number.isRequired, + var gridStyle = { + height: autoHeight ? 'auto' : height, + width: width + }; - /** - * Height of Grid; this property determines the number of visible (vs virtualized) rows. - */ - height: _react.PropTypes.number.isRequired, + var totalColumnsWidth = this._columnSizeAndPositionManager.getTotalSize(); + var totalRowsHeight = this._rowSizeAndPositionManager.getTotalSize(); - /** - * Optional renderer to be used in place of rows when either :rowCount or :columnCount is 0. - */ - noContentRenderer: _react.PropTypes.func.isRequired, + // Force browser to hide scrollbars when we know they aren't necessary. + // Otherwise once scrollbars appear they may not disappear again. + // For more info see issue #116 + var verticalScrollBarSize = totalRowsHeight > height ? this._scrollbarSize : 0; + var horizontalScrollBarSize = totalColumnsWidth > width ? this._scrollbarSize : 0; - /** - * Callback invoked whenever the scroll offset changes within the inner scrollable region. - * This callback can be used to sync scrolling between lists, tables, or grids. - * ({ clientHeight, clientWidth, scrollHeight, scrollLeft, scrollTop, scrollWidth }): void - */ - onScroll: _react.PropTypes.func.isRequired, + // Also explicitly init styles to 'auto' if scrollbars are required. + // This works around an obscure edge case where external CSS styles have not yet been loaded, + // But an initial scroll index of offset is set as an external prop. + // Without this style, Grid would render the correct range of cells but would NOT update its internal offset. + // This was originally reported via clauderic/react-infinite-calendar/issues/23 + gridStyle.overflowX = totalColumnsWidth + verticalScrollBarSize <= width ? 'hidden' : 'auto'; + gridStyle.overflowY = totalRowsHeight + horizontalScrollBarSize <= height ? 'hidden' : 'auto'; - /** - * Callback invoked with information about the section of the Grid that was just rendered. - * ({ columnStartIndex, columnStopIndex, rowStartIndex, rowStopIndex }): void - */ - onSectionRendered: _react.PropTypes.func.isRequired, + var childrenToDisplay = this._childrenToDisplay; - /** - * Number of columns to render before/after the visible section of the grid. - * These columns can help for smoother scrolling on touch devices or browsers that send scroll events infrequently. - */ - overscanColumnCount: _react.PropTypes.number.isRequired, + var showNoContentRenderer = childrenToDisplay.length === 0 && height > 0 && width > 0; - /** - * Number of rows to render above/below the visible section of the grid. - * These rows can help for smoother scrolling on touch devices or browsers that send scroll events infrequently. - */ - overscanRowCount: _react.PropTypes.number.isRequired, + return _react2.default.createElement( + 'div', + { + ref: function ref(_ref2) { + _this4._scrollingContainer = _ref2; + }, + 'aria-label': this.props['aria-label'], + className: (0, _classnames2.default)('Grid', className), + onScroll: this._onScroll, + role: 'grid', + style: _extends({}, gridStyle, style), + tabIndex: tabIndex + }, + childrenToDisplay.length > 0 && _react2.default.createElement( + 'div', + { + className: 'Grid__innerScrollContainer', + style: { + width: autoContainerWidth ? 'auto' : totalColumnsWidth, + height: totalRowsHeight, + maxWidth: totalColumnsWidth, + maxHeight: totalRowsHeight, + pointerEvents: isScrolling ? 'none' : '' + } + }, + childrenToDisplay + ), + showNoContentRenderer && noContentRenderer() + ); + } + }, { + key: 'shouldComponentUpdate', + value: function shouldComponentUpdate(nextProps, nextState) { + return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState); + } - /** - * Either a fixed row height (number) or a function that returns the height of a row given its index. - * Should implement the following interface: ({ index: number }): number - */ - rowHeight: _react.PropTypes.oneOfType([_react.PropTypes.number, _react.PropTypes.func]).isRequired, + /* ---------------------------- Helper methods ---------------------------- */ - /** - * Number of rows in grid. - */ - rowCount: _react.PropTypes.number.isRequired, + }, { + key: '_calculateChildrenToRender', + value: function _calculateChildrenToRender() { + var props = arguments.length <= 0 || arguments[0] === undefined ? this.props : arguments[0]; + var state = arguments.length <= 1 || arguments[1] === undefined ? this.state : arguments[1]; + var cellClassName = props.cellClassName; + var cellRenderer = props.cellRenderer; + var cellRangeRenderer = props.cellRangeRenderer; + var cellStyle = props.cellStyle; + var columnCount = props.columnCount; + var height = props.height; + var overscanColumnCount = props.overscanColumnCount; + var overscanRowCount = props.overscanRowCount; + var rowCount = props.rowCount; + var width = props.width; + var isScrolling = state.isScrolling; + var scrollDirectionHorizontal = state.scrollDirectionHorizontal; + var scrollDirectionVertical = state.scrollDirectionVertical; + var scrollLeft = state.scrollLeft; + var scrollTop = state.scrollTop; - /** Wait this amount of time after the last scroll event before resetting Grid `pointer-events`. */ - scrollingResetTimeInterval: _react.PropTypes.number, - /** Horizontal offset. */ - scrollLeft: _react.PropTypes.number, + this._childrenToDisplay = []; - /** - * Controls scroll-to-cell behavior of the Grid. - * The default ("auto") scrolls the least amount possible to ensure that the specified cell is fully visible. - * Use "start" to align cells to the top/left of the Grid and "end" to align bottom/right. - */ - scrollToAlignment: _react.PropTypes.oneOf(['auto', 'end', 'start', 'center']).isRequired, + // Render only enough columns and rows to cover the visible area of the grid. + if (height > 0 && width > 0) { + var visibleColumnIndices = this._columnSizeAndPositionManager.getVisibleCellRange({ + containerSize: width, + offset: scrollLeft + }); + var visibleRowIndices = this._rowSizeAndPositionManager.getVisibleCellRange({ + containerSize: height, + offset: scrollTop + }); - /** - * Column index to ensure visible (by forcefully scrolling if necessary) - */ - scrollToColumn: _react.PropTypes.number, + var horizontalOffsetAdjustment = this._columnSizeAndPositionManager.getOffsetAdjustment({ + containerSize: width, + offset: scrollLeft + }); + var verticalOffsetAdjustment = this._rowSizeAndPositionManager.getOffsetAdjustment({ + containerSize: height, + offset: scrollTop + }); - /** Vertical offset. */ - scrollTop: _react.PropTypes.number, + // Store for _invokeOnGridRenderedHelper() + this._renderedColumnStartIndex = visibleColumnIndices.start; + this._renderedColumnStopIndex = visibleColumnIndices.stop; + this._renderedRowStartIndex = visibleRowIndices.start; + this._renderedRowStopIndex = visibleRowIndices.stop; - /** - * Row index to ensure visible (by forcefully scrolling if necessary) - */ - scrollToRow: _react.PropTypes.number, + var overscanColumnIndices = (0, _getOverscanIndices2.default)({ + cellCount: columnCount, + overscanCellsCount: overscanColumnCount, + scrollDirection: scrollDirectionHorizontal, + startIndex: this._renderedColumnStartIndex, + stopIndex: this._renderedColumnStopIndex + }); - /** Optional inline style */ - style: _react.PropTypes.object, + var overscanRowIndices = (0, _getOverscanIndices2.default)({ + cellCount: rowCount, + overscanCellsCount: overscanRowCount, + scrollDirection: scrollDirectionVertical, + startIndex: this._renderedRowStartIndex, + stopIndex: this._renderedRowStopIndex + }); - /** Tab index for focus */ - tabIndex: _react.PropTypes.number, + // Store for _invokeOnGridRenderedHelper() + this._columnStartIndex = overscanColumnIndices.overscanStartIndex; + this._columnStopIndex = overscanColumnIndices.overscanStopIndex; + this._rowStartIndex = overscanRowIndices.overscanStartIndex; + this._rowStopIndex = overscanRowIndices.overscanStopIndex; - /** - * Width of Grid; this property determines the number of visible (vs virtualized) columns. - */ - width: _react.PropTypes.number.isRequired -}; -Grid.defaultProps = { - 'aria-label': 'grid', - cellStyle: {}, - cellRangeRenderer: _defaultCellRangeRenderer2.default, - estimatedColumnSize: 100, - estimatedRowSize: 30, - noContentRenderer: function noContentRenderer() { - return null; - }, - onScroll: function onScroll() { - return null; - }, - onSectionRendered: function onSectionRendered() { - return null; - }, - overscanColumnCount: 0, - overscanRowCount: 10, - scrollingResetTimeInterval: DEFAULT_SCROLLING_RESET_TIME_INTERVAL, - scrollToAlignment: 'auto', - style: {}, - tabIndex: 0 -}; -exports.default = Grid; -},{"../utils/createCallbackMemoizer":78,"./defaultCellRangeRenderer":61,"./utils/ScalingCellSizeAndPositionManager":64,"./utils/calculateSizeAndPositionDataAndUpdateScrollOffset":65,"./utils/getOverscanIndices":66,"./utils/updateScrollIndexHelper":67,"classnames":undefined,"dom-helpers/util/scrollbarSize":19,"raf":29,"react":undefined,"react-addons-shallow-compare":30}],61:[function(require,module,exports){ -'use strict'; + this._childrenToDisplay = cellRangeRenderer({ + cellCache: this._cellCache, + cellClassName: this._wrapCellClassNameGetter(cellClassName), + cellRenderer: cellRenderer, + cellStyle: this._wrapCellStyleGetter(cellStyle), + columnSizeAndPositionManager: this._columnSizeAndPositionManager, + columnStartIndex: this._columnStartIndex, + columnStopIndex: this._columnStopIndex, + horizontalOffsetAdjustment: horizontalOffsetAdjustment, + isScrolling: isScrolling, + rowSizeAndPositionManager: this._rowSizeAndPositionManager, + rowStartIndex: this._rowStartIndex, + rowStopIndex: this._rowStopIndex, + scrollLeft: scrollLeft, + scrollTop: scrollTop, + verticalOffsetAdjustment: verticalOffsetAdjustment + }); + } + } -Object.defineProperty(exports, "__esModule", { - value: true -}); + /** + * Sets an :isScrolling flag for a small window of time. + * This flag is used to disable pointer events on the scrollable portion of the Grid. + * This prevents jerky/stuttery mouse-wheel scrolling. + */ -var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; + }, { + key: '_enablePointerEventsAfterDelay', + value: function _enablePointerEventsAfterDelay() { + var scrollingResetTimeInterval = this.props.scrollingResetTimeInterval; -exports.default = defaultCellRangeRenderer; -var _react = require('react'); + if (this._disablePointerEventsTimeoutId) { + clearTimeout(this._disablePointerEventsTimeoutId); + } -var _react2 = _interopRequireDefault(_react); + this._disablePointerEventsTimeoutId = setTimeout(this._enablePointerEventsAfterDelayCallback, scrollingResetTimeInterval); + } + }, { + key: '_enablePointerEventsAfterDelayCallback', + value: function _enablePointerEventsAfterDelayCallback() { + this._disablePointerEventsTimeoutId = null; -var _classnames = require('classnames'); + // Throw away cell cache once scrolling is complete + this._cellCache = {}; -var _classnames2 = _interopRequireDefault(_classnames); + this.setState({ + isScrolling: false, + scrollDirectionHorizontal: _getOverscanIndices.SCROLL_DIRECTION_FIXED, + scrollDirectionVertical: _getOverscanIndices.SCROLL_DIRECTION_FIXED + }); + } + }, { + key: '_getEstimatedColumnSize', + value: function _getEstimatedColumnSize(props) { + return typeof props.columnWidth === 'number' ? props.columnWidth : props.estimatedColumnSize; + } + }, { + key: '_getEstimatedRowSize', + value: function _getEstimatedRowSize(props) { + return typeof props.rowHeight === 'number' ? props.rowHeight : props.estimatedRowSize; + } + }, { + key: '_invokeOnGridRenderedHelper', + value: function _invokeOnGridRenderedHelper() { + var onSectionRendered = this.props.onSectionRendered; -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } -/** - * Default implementation of cellRangeRenderer used by Grid. - * This renderer supports cell-caching while the user is scrolling. - */ -function defaultCellRangeRenderer(_ref) { - var cellCache = _ref.cellCache; - var cellClassName = _ref.cellClassName; - var cellRenderer = _ref.cellRenderer; - var cellStyle = _ref.cellStyle; - var columnSizeAndPositionManager = _ref.columnSizeAndPositionManager; - var columnStartIndex = _ref.columnStartIndex; - var columnStopIndex = _ref.columnStopIndex; - var horizontalOffsetAdjustment = _ref.horizontalOffsetAdjustment; - var isScrolling = _ref.isScrolling; - var rowSizeAndPositionManager = _ref.rowSizeAndPositionManager; - var rowStartIndex = _ref.rowStartIndex; - var rowStopIndex = _ref.rowStopIndex; - var scrollLeft = _ref.scrollLeft; - var scrollTop = _ref.scrollTop; - var verticalOffsetAdjustment = _ref.verticalOffsetAdjustment; + this._onGridRenderedMemoizer({ + callback: onSectionRendered, + indices: { + columnOverscanStartIndex: this._columnStartIndex, + columnOverscanStopIndex: this._columnStopIndex, + columnStartIndex: this._renderedColumnStartIndex, + columnStopIndex: this._renderedColumnStopIndex, + rowOverscanStartIndex: this._rowStartIndex, + rowOverscanStopIndex: this._rowStopIndex, + rowStartIndex: this._renderedRowStartIndex, + rowStopIndex: this._renderedRowStopIndex + } + }); + } + }, { + key: '_invokeOnScrollMemoizer', + value: function _invokeOnScrollMemoizer(_ref3) { + var _this5 = this; - var renderedCells = []; + var scrollLeft = _ref3.scrollLeft; + var scrollTop = _ref3.scrollTop; + var totalColumnsWidth = _ref3.totalColumnsWidth; + var totalRowsHeight = _ref3.totalRowsHeight; - for (var rowIndex = rowStartIndex; rowIndex <= rowStopIndex; rowIndex++) { - var rowDatum = rowSizeAndPositionManager.getSizeAndPositionOfCell(rowIndex); + this._onScrollMemoizer({ + callback: function callback(_ref4) { + var scrollLeft = _ref4.scrollLeft; + var scrollTop = _ref4.scrollTop; + var _props5 = _this5.props; + var height = _props5.height; + var onScroll = _props5.onScroll; + var width = _props5.width; - for (var columnIndex = columnStartIndex; columnIndex <= columnStopIndex; columnIndex++) { - var columnDatum = columnSizeAndPositionManager.getSizeAndPositionOfCell(columnIndex); - var key = rowIndex + '-' + columnIndex; - var cellStyleObject = cellStyle({ rowIndex: rowIndex, columnIndex: columnIndex }); - var renderedCell = void 0; - // Avoid re-creating cells while scrolling. - // This can lead to the same cell being created many times and can cause performance issues for "heavy" cells. - // If a scroll is in progress- cache and reuse cells. - // This cache will be thrown away once scrolling complets. - if (isScrolling) { - if (!cellCache[key]) { - cellCache[key] = cellRenderer({ - columnIndex: columnIndex, - isScrolling: isScrolling, - rowIndex: rowIndex + onScroll({ + clientHeight: height, + clientWidth: width, + scrollHeight: totalRowsHeight, + scrollLeft: scrollLeft, + scrollTop: scrollTop, + scrollWidth: totalColumnsWidth }); + }, + indices: { + scrollLeft: scrollLeft, + scrollTop: scrollTop } - renderedCell = cellCache[key]; - // If the user is no longer scrolling, don't cache cells. - // This makes dynamic cell content difficult for users and would also lead to a heavier memory footprint. - } else { - renderedCell = cellRenderer({ - columnIndex: columnIndex, - isScrolling: isScrolling, - rowIndex: rowIndex - }); + }); + } + + /** + * Updates the state during the next animation frame. + * Use this method to avoid multiple renders in a small span of time. + * This helps performance for bursty events (like onScroll). + */ + + }, { + key: '_setNextState', + value: function _setNextState(state) { + this._nextState = state; + + if (!this._setNextStateAnimationFrameId) { + this._setNextStateAnimationFrameId = (0, _raf2.default)(this._setNextStateCallback); } + } + }, { + key: '_setNextStateCallback', + value: function _setNextStateCallback() { + var state = this._nextState; + + this._setNextStateAnimationFrameId = null; + this._nextState = null; + + this.setState(state); + } + }, { + key: '_setScrollPosition', + value: function _setScrollPosition(_ref5) { + var scrollLeft = _ref5.scrollLeft; + var scrollTop = _ref5.scrollTop; - if (renderedCell == null || renderedCell === false) { - continue; - } + var newState = { + scrollPositionChangeReason: SCROLL_POSITION_CHANGE_REASONS.REQUESTED + }; - var className = cellClassName({ columnIndex: columnIndex, rowIndex: rowIndex }); + if (scrollLeft >= 0) { + newState.scrollLeft = scrollLeft; + } - var child = _react2.default.createElement( - 'div', - { - key: key, - className: (0, _classnames2.default)('Grid__cell', className), - style: _extends({ - height: rowDatum.size, - left: columnDatum.offset + horizontalOffsetAdjustment, - top: rowDatum.offset + verticalOffsetAdjustment, - width: columnDatum.size - }, cellStyleObject) - }, - renderedCell - ); + if (scrollTop >= 0) { + newState.scrollTop = scrollTop; + } - renderedCells.push(child); + if (scrollLeft >= 0 && scrollLeft !== this.state.scrollLeft || scrollTop >= 0 && scrollTop !== this.state.scrollTop) { + this.setState(newState); + } } - } - - return renderedCells; -} -},{"classnames":undefined,"react":undefined}],62:[function(require,module,exports){ -'use strict'; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.defaultCellRangeRenderer = exports.Grid = exports.default = undefined; + }, { + key: '_wrapCellClassNameGetter', + value: function _wrapCellClassNameGetter(className) { + return this._wrapPropertyGetter(className); + } + }, { + key: '_wrapCellStyleGetter', + value: function _wrapCellStyleGetter(style) { + return this._wrapPropertyGetter(style); + } + }, { + key: '_wrapPropertyGetter', + value: function _wrapPropertyGetter(value) { + return value instanceof Function ? value : function () { + return value; + }; + } + }, { + key: '_wrapSizeGetter', + value: function _wrapSizeGetter(size) { + return this._wrapPropertyGetter(size); + } + }, { + key: '_updateScrollLeftForScrollToColumn', + value: function _updateScrollLeftForScrollToColumn() { + var props = arguments.length <= 0 || arguments[0] === undefined ? this.props : arguments[0]; + var state = arguments.length <= 1 || arguments[1] === undefined ? this.state : arguments[1]; + var columnCount = props.columnCount; + var scrollToAlignment = props.scrollToAlignment; + var scrollToColumn = props.scrollToColumn; + var width = props.width; + var scrollLeft = state.scrollLeft; -var _Grid2 = require('./Grid'); -var _Grid3 = _interopRequireDefault(_Grid2); + if (scrollToColumn >= 0 && columnCount > 0) { + var targetIndex = Math.max(0, Math.min(columnCount - 1, scrollToColumn)); -var _defaultCellRangeRenderer2 = require('./defaultCellRangeRenderer'); + var calculatedScrollLeft = this._columnSizeAndPositionManager.getUpdatedOffsetForIndex({ + align: scrollToAlignment, + containerSize: width, + currentOffset: scrollLeft, + targetIndex: targetIndex + }); -var _defaultCellRangeRenderer3 = _interopRequireDefault(_defaultCellRangeRenderer2); + if (scrollLeft !== calculatedScrollLeft) { + this._setScrollPosition({ + scrollLeft: calculatedScrollLeft + }); + } + } + } + }, { + key: '_updateScrollTopForScrollToRow', + value: function _updateScrollTopForScrollToRow() { + var props = arguments.length <= 0 || arguments[0] === undefined ? this.props : arguments[0]; + var state = arguments.length <= 1 || arguments[1] === undefined ? this.state : arguments[1]; + var height = props.height; + var rowCount = props.rowCount; + var scrollToAlignment = props.scrollToAlignment; + var scrollToRow = props.scrollToRow; + var scrollTop = state.scrollTop; -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } -exports.default = _Grid3.default; -exports.Grid = _Grid3.default; -exports.defaultCellRangeRenderer = _defaultCellRangeRenderer3.default; -},{"./Grid":60,"./defaultCellRangeRenderer":61}],63:[function(require,module,exports){ -'use strict'; + if (scrollToRow >= 0 && rowCount > 0) { + var targetIndex = Math.max(0, Math.min(rowCount - 1, scrollToRow)); -Object.defineProperty(exports, "__esModule", { - value: true -}); + var calculatedScrollTop = this._rowSizeAndPositionManager.getUpdatedOffsetForIndex({ + align: scrollToAlignment, + containerSize: height, + currentOffset: scrollTop, + targetIndex: targetIndex + }); -var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + if (scrollTop !== calculatedScrollTop) { + this._setScrollPosition({ + scrollTop: calculatedScrollTop + }); + } + } + } + }, { + key: '_onScroll', + value: function _onScroll(event) { + // In certain edge-cases React dispatches an onScroll event with an invalid target.scrollLeft / target.scrollTop. + // This invalid event can be detected by comparing event.target to this component's scrollable DOM element. + // See issue #404 for more information. + if (event.target !== this._scrollingContainer) { + return; + } -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + // Prevent pointer events from interrupting a smooth scroll + this._enablePointerEventsAfterDelay(); -/** - * Just-in-time calculates and caches size and position information for a collection of cells. - */ -var CellSizeAndPositionManager = function () { - function CellSizeAndPositionManager(_ref) { - var cellCount = _ref.cellCount; - var cellSizeGetter = _ref.cellSizeGetter; - var estimatedCellSize = _ref.estimatedCellSize; + // When this component is shrunk drastically, React dispatches a series of back-to-back scroll events, + // Gradually converging on a scrollTop that is within the bounds of the new, smaller height. + // This causes a series of rapid renders that is slow for long lists. + // We can avoid that by doing some simple bounds checking to ensure that scrollTop never exceeds the total height. + var _props6 = this.props; + var height = _props6.height; + var width = _props6.width; - _classCallCheck(this, CellSizeAndPositionManager); + var scrollbarSize = this._scrollbarSize; + var totalRowsHeight = this._rowSizeAndPositionManager.getTotalSize(); + var totalColumnsWidth = this._columnSizeAndPositionManager.getTotalSize(); + var scrollLeft = Math.min(Math.max(0, totalColumnsWidth - width + scrollbarSize), event.target.scrollLeft); + var scrollTop = Math.min(Math.max(0, totalRowsHeight - height + scrollbarSize), event.target.scrollTop); - this._cellSizeGetter = cellSizeGetter; - this._cellCount = cellCount; - this._estimatedCellSize = estimatedCellSize; + // Certain devices (like Apple touchpad) rapid-fire duplicate events. + // Don't force a re-render if this is the case. + // The mouse may move faster then the animation frame does. + // Use requestAnimationFrame to avoid over-updating. + if (this.state.scrollLeft !== scrollLeft || this.state.scrollTop !== scrollTop) { + // Browsers with cancelable scroll events (eg. Firefox) interrupt scrolling animations if scrollTop/scrollLeft is set. + // Other browsers (eg. Safari) don't scroll as well without the help under certain conditions (DOM or style changes during scrolling). + // All things considered, this seems to be the best current work around that I'm aware of. + // For more information see https://github.com/bvaughn/react-virtualized/pull/124 + var scrollPositionChangeReason = event.cancelable ? SCROLL_POSITION_CHANGE_REASONS.OBSERVED : SCROLL_POSITION_CHANGE_REASONS.REQUESTED; - // Cache of size and position data for cells, mapped by cell index. - // Note that invalid values may exist in this map so only rely on cells up to this._lastMeasuredIndex - this._cellSizeAndPositionData = {}; + // Track scrolling direction so we can more efficiently overscan rows to reduce empty space around the edges while scrolling. + var scrollDirectionVertical = scrollTop > this.state.scrollTop ? _getOverscanIndices.SCROLL_DIRECTION_FORWARD : _getOverscanIndices.SCROLL_DIRECTION_BACKWARD; + var scrollDirectionHorizontal = scrollLeft > this.state.scrollLeft ? _getOverscanIndices.SCROLL_DIRECTION_FORWARD : _getOverscanIndices.SCROLL_DIRECTION_BACKWARD; - // Measurements for cells up to this index can be trusted; cells afterward should be estimated. - this._lastMeasuredIndex = -1; - } + if (!this.state.isScrolling) { + this.setState({ + isScrolling: true + }); + } - _createClass(CellSizeAndPositionManager, [{ - key: 'configure', - value: function configure(_ref2) { - var cellCount = _ref2.cellCount; - var estimatedCellSize = _ref2.estimatedCellSize; + this._setNextState({ + isScrolling: true, + scrollDirectionHorizontal: scrollDirectionHorizontal, + scrollDirectionVertical: scrollDirectionVertical, + scrollLeft: scrollLeft, + scrollPositionChangeReason: scrollPositionChangeReason, + scrollTop: scrollTop + }); + } - this._cellCount = cellCount; - this._estimatedCellSize = estimatedCellSize; - } - }, { - key: 'getCellCount', - value: function getCellCount() { - return this._cellCount; - } - }, { - key: 'getEstimatedCellSize', - value: function getEstimatedCellSize() { - return this._estimatedCellSize; - } - }, { - key: 'getLastMeasuredIndex', - value: function getLastMeasuredIndex() { - return this._lastMeasuredIndex; + this._invokeOnScrollMemoizer({ scrollLeft: scrollLeft, scrollTop: scrollTop, totalColumnsWidth: totalColumnsWidth, totalRowsHeight: totalRowsHeight }); } + }]); - /** - * This method returns the size and position for the cell at the specified index. - * It just-in-time calculates (or used cached values) for cells leading up to the index. - */ + return Grid; +}(_react.Component); - }, { - key: 'getSizeAndPositionOfCell', - value: function getSizeAndPositionOfCell(index) { - if (index < 0 || index >= this._cellCount) { - throw Error('Requested index ' + index + ' is outside of range 0..' + this._cellCount); - } +Grid.propTypes = { + 'aria-label': _react.PropTypes.string, - if (index > this._lastMeasuredIndex) { - var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell(); - var _offset = lastMeasuredCellSizeAndPosition.offset + lastMeasuredCellSizeAndPosition.size; + /** + * Set the width of the inner scrollable container to 'auto'. + * This is useful for single-column Grids to ensure that the column doesn't extend below a vertical scrollbar. + */ + autoContainerWidth: _react.PropTypes.bool, - for (var i = this._lastMeasuredIndex + 1; i <= index; i++) { - var _size = this._cellSizeGetter({ index: i }); + /** + * Removes fixed height from the scrollingContainer so that the total height + * of rows can stretch the window. Intended for use with WindowScroller + */ + autoHeight: _react.PropTypes.bool, - if (_size == null || isNaN(_size)) { - throw Error('Invalid size returned for cell ' + i + ' of value ' + _size); - } + /** Optional custom CSS class for individual cells */ + cellClassName: _react.PropTypes.oneOfType([_react.PropTypes.string, _react.PropTypes.func]), - this._cellSizeAndPositionData[i] = { - offset: _offset, - size: _size - }; + /** Optional custom styles for individual cells */ + cellStyle: _react.PropTypes.oneOfType([_react.PropTypes.object, _react.PropTypes.func]), - _offset += _size; - } + /** + * Responsible for rendering a cell given an row and column index. + * Should implement the following interface: ({ columnIndex: number, rowIndex: number }): PropTypes.node + */ + cellRenderer: _react.PropTypes.func.isRequired, - this._lastMeasuredIndex = index; - } + /** + * Responsible for rendering a group of cells given their index ranges. + * Should implement the following interface: ({ + * cellCache: Map, + * cellRenderer: Function, + * columnSizeAndPositionManager: CellSizeAndPositionManager, + * columnStartIndex: number, + * columnStopIndex: number, + * isScrolling: boolean, + * rowSizeAndPositionManager: CellSizeAndPositionManager, + * rowStartIndex: number, + * rowStopIndex: number, + * scrollLeft: number, + * scrollTop: number + * }): Array + */ + cellRangeRenderer: _react.PropTypes.func.isRequired, - return this._cellSizeAndPositionData[index]; - } - }, { - key: 'getSizeAndPositionOfLastMeasuredCell', - value: function getSizeAndPositionOfLastMeasuredCell() { - return this._lastMeasuredIndex >= 0 ? this._cellSizeAndPositionData[this._lastMeasuredIndex] : { - offset: 0, - size: 0 - }; - } + /** + * Optional custom CSS class name to attach to root Grid element. + */ + className: _react.PropTypes.string, - /** - * Total size of all cells being measured. - * This value will be completedly estimated initially. - * As cells as measured the estimate will be updated. - */ + /** + * Number of columns in grid. + */ + columnCount: _react.PropTypes.number.isRequired, - }, { - key: 'getTotalSize', - value: function getTotalSize() { - var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell(); + /** + * Either a fixed column width (number) or a function that returns the width of a column given its index. + * Should implement the following interface: (index: number): number + */ + columnWidth: _react.PropTypes.oneOfType([_react.PropTypes.number, _react.PropTypes.func]).isRequired, - return lastMeasuredCellSizeAndPosition.offset + lastMeasuredCellSizeAndPosition.size + (this._cellCount - this._lastMeasuredIndex - 1) * this._estimatedCellSize; - } + /** + * Used to estimate the total width of a Grid before all of its columns have actually been measured. + * The estimated total width is adjusted as columns are rendered. + */ + estimatedColumnSize: _react.PropTypes.number.isRequired, - /** - * Determines a new offset that ensures a certain cell is visible, given the current offset. - * If the cell is already visible then the current offset will be returned. - * If the current offset is too great or small, it will be adjusted just enough to ensure the specified index is visible. - * - * @param align Desired alignment within container; one of "auto" (default), "start", or "end" - * @param containerSize Size (width or height) of the container viewport - * @param currentOffset Container's current (x or y) offset - * @param totalSize Total size (width or height) of all cells - * @return Offset to use to ensure the specified cell is visible - */ + /** + * Used to estimate the total height of a Grid before all of its rows have actually been measured. + * The estimated total height is adjusted as rows are rendered. + */ + estimatedRowSize: _react.PropTypes.number.isRequired, - }, { - key: 'getUpdatedOffsetForIndex', - value: function getUpdatedOffsetForIndex(_ref3) { - var _ref3$align = _ref3.align; - var align = _ref3$align === undefined ? 'auto' : _ref3$align; - var containerSize = _ref3.containerSize; - var currentOffset = _ref3.currentOffset; - var targetIndex = _ref3.targetIndex; + /** + * Height of Grid; this property determines the number of visible (vs virtualized) rows. + */ + height: _react.PropTypes.number.isRequired, - var datum = this.getSizeAndPositionOfCell(targetIndex); - var maxOffset = datum.offset; - var minOffset = maxOffset - containerSize + datum.size; + /** + * Optional renderer to be used in place of rows when either :rowCount or :columnCount is 0. + */ + noContentRenderer: _react.PropTypes.func.isRequired, - var idealOffset = void 0; + /** + * Callback invoked whenever the scroll offset changes within the inner scrollable region. + * This callback can be used to sync scrolling between lists, tables, or grids. + * ({ clientHeight, clientWidth, scrollHeight, scrollLeft, scrollTop, scrollWidth }): void + */ + onScroll: _react.PropTypes.func.isRequired, - switch (align) { - case 'start': - idealOffset = maxOffset; - break; - case 'end': - idealOffset = minOffset; - break; - case 'center': - idealOffset = maxOffset - (containerSize - datum.size) / 2; - break; - default: - idealOffset = Math.max(minOffset, Math.min(maxOffset, currentOffset)); - break; - } + /** + * Callback invoked with information about the section of the Grid that was just rendered. + * ({ columnStartIndex, columnStopIndex, rowStartIndex, rowStopIndex }): void + */ + onSectionRendered: _react.PropTypes.func.isRequired, - var totalSize = this.getTotalSize(); + /** + * Number of columns to render before/after the visible section of the grid. + * These columns can help for smoother scrolling on touch devices or browsers that send scroll events infrequently. + */ + overscanColumnCount: _react.PropTypes.number.isRequired, - return Math.max(0, Math.min(totalSize - containerSize, idealOffset)); - } - }, { - key: 'getVisibleCellRange', - value: function getVisibleCellRange(_ref4) { - var containerSize = _ref4.containerSize; - var offset = _ref4.offset; + /** + * Number of rows to render above/below the visible section of the grid. + * These rows can help for smoother scrolling on touch devices or browsers that send scroll events infrequently. + */ + overscanRowCount: _react.PropTypes.number.isRequired, - var totalSize = this.getTotalSize(); + /** + * Either a fixed row height (number) or a function that returns the height of a row given its index. + * Should implement the following interface: ({ index: number }): number + */ + rowHeight: _react.PropTypes.oneOfType([_react.PropTypes.number, _react.PropTypes.func]).isRequired, - if (totalSize === 0) { - return {}; - } + /** + * Number of rows in grid. + */ + rowCount: _react.PropTypes.number.isRequired, - var maxOffset = offset + containerSize; - var start = this._findNearestCell(offset); + /** Wait this amount of time after the last scroll event before resetting Grid `pointer-events`. */ + scrollingResetTimeInterval: _react.PropTypes.number, - var datum = this.getSizeAndPositionOfCell(start); - offset = datum.offset + datum.size; + /** Horizontal offset. */ + scrollLeft: _react.PropTypes.number, - var stop = start; + /** + * Controls scroll-to-cell behavior of the Grid. + * The default ("auto") scrolls the least amount possible to ensure that the specified cell is fully visible. + * Use "start" to align cells to the top/left of the Grid and "end" to align bottom/right. + */ + scrollToAlignment: _react.PropTypes.oneOf(['auto', 'end', 'start', 'center']).isRequired, - while (offset < maxOffset && stop < this._cellCount - 1) { - stop++; + /** + * Column index to ensure visible (by forcefully scrolling if necessary) + */ + scrollToColumn: _react.PropTypes.number, - offset += this.getSizeAndPositionOfCell(stop).size; - } + /** Vertical offset. */ + scrollTop: _react.PropTypes.number, - return { - start: start, - stop: stop - }; - } + /** + * Row index to ensure visible (by forcefully scrolling if necessary) + */ + scrollToRow: _react.PropTypes.number, - /** - * Clear all cached values for cells after the specified index. - * This method should be called for any cell that has changed its size. - * It will not immediately perform any calculations; they'll be performed the next time getSizeAndPositionOfCell() is called. - */ + /** Optional inline style */ + style: _react.PropTypes.object, - }, { - key: 'resetCell', - value: function resetCell(index) { - this._lastMeasuredIndex = Math.min(this._lastMeasuredIndex, index - 1); - } - }, { - key: '_binarySearch', - value: function _binarySearch(_ref5) { - var high = _ref5.high; - var low = _ref5.low; - var offset = _ref5.offset; + /** Tab index for focus */ + tabIndex: _react.PropTypes.number, - var middle = void 0; - var currentOffset = void 0; + /** + * Width of Grid; this property determines the number of visible (vs virtualized) columns. + */ + width: _react.PropTypes.number.isRequired +}; +Grid.defaultProps = { + 'aria-label': 'grid', + cellStyle: {}, + cellRangeRenderer: _defaultCellRangeRenderer2.default, + estimatedColumnSize: 100, + estimatedRowSize: 30, + noContentRenderer: function noContentRenderer() { + return null; + }, + onScroll: function onScroll() { + return null; + }, + onSectionRendered: function onSectionRendered() { + return null; + }, + overscanColumnCount: 0, + overscanRowCount: 10, + scrollingResetTimeInterval: DEFAULT_SCROLLING_RESET_TIME_INTERVAL, + scrollToAlignment: 'auto', + style: {}, + tabIndex: 0 +}; +exports.default = Grid; +},{"../utils/createCallbackMemoizer":76,"./defaultCellRangeRenderer":59,"./utils/ScalingCellSizeAndPositionManager":62,"./utils/calculateSizeAndPositionDataAndUpdateScrollOffset":63,"./utils/getOverscanIndices":64,"./utils/updateScrollIndexHelper":65,"classnames":undefined,"dom-helpers/util/scrollbarSize":80,"raf":81,"react":undefined,"react-addons-shallow-compare":18}],59:[function(require,module,exports){ +'use strict'; - while (low <= high) { - middle = low + Math.floor((high - low) / 2); - currentOffset = this.getSizeAndPositionOfCell(middle).offset; +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; - if (currentOffset === offset) { - return middle; - } else if (currentOffset < offset) { - low = middle + 1; - } else if (currentOffset > offset) { - high = middle - 1; - } - } +exports.default = defaultCellRangeRenderer; - if (low > 0) { - return low - 1; - } - } - }, { - key: '_exponentialSearch', - value: function _exponentialSearch(_ref6) { - var index = _ref6.index; - var offset = _ref6.offset; +var _react = require('react'); - var interval = 1; +var _react2 = _interopRequireDefault(_react); - while (index < this._cellCount && this.getSizeAndPositionOfCell(index).offset < offset) { - index += interval; - interval *= 2; - } +var _classnames = require('classnames'); - return this._binarySearch({ - high: Math.min(index, this._cellCount - 1), - low: Math.floor(index / 2), - offset: offset - }); - } +var _classnames2 = _interopRequireDefault(_classnames); - /** - * Searches for the cell (index) nearest the specified offset. - * - * If no exact match is found the next lowest cell index will be returned. - * This allows partially visible cells (with offsets just before/above the fold) to be visible. - */ +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - }, { - key: '_findNearestCell', - value: function _findNearestCell(offset) { - if (isNaN(offset)) { - throw Error('Invalid offset ' + offset + ' specified'); - } +/** + * Default implementation of cellRangeRenderer used by Grid. + * This renderer supports cell-caching while the user is scrolling. + */ +function defaultCellRangeRenderer(_ref) { + var cellCache = _ref.cellCache; + var cellClassName = _ref.cellClassName; + var cellRenderer = _ref.cellRenderer; + var cellStyle = _ref.cellStyle; + var columnSizeAndPositionManager = _ref.columnSizeAndPositionManager; + var columnStartIndex = _ref.columnStartIndex; + var columnStopIndex = _ref.columnStopIndex; + var horizontalOffsetAdjustment = _ref.horizontalOffsetAdjustment; + var isScrolling = _ref.isScrolling; + var rowSizeAndPositionManager = _ref.rowSizeAndPositionManager; + var rowStartIndex = _ref.rowStartIndex; + var rowStopIndex = _ref.rowStopIndex; + var scrollLeft = _ref.scrollLeft; + var scrollTop = _ref.scrollTop; + var verticalOffsetAdjustment = _ref.verticalOffsetAdjustment; - // Our search algorithms find the nearest match at or below the specified offset. - // So make sure the offset is at least 0 or no match will be found. - offset = Math.max(0, offset); + var renderedCells = []; - var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell(); - var lastMeasuredIndex = Math.max(0, this._lastMeasuredIndex); + for (var rowIndex = rowStartIndex; rowIndex <= rowStopIndex; rowIndex++) { + var rowDatum = rowSizeAndPositionManager.getSizeAndPositionOfCell(rowIndex); - if (lastMeasuredCellSizeAndPosition.offset >= offset) { - // If we've already measured cells within this range just use a binary search as it's faster. - return this._binarySearch({ - high: lastMeasuredIndex, - low: 0, - offset: offset - }); + for (var columnIndex = columnStartIndex; columnIndex <= columnStopIndex; columnIndex++) { + var columnDatum = columnSizeAndPositionManager.getSizeAndPositionOfCell(columnIndex); + var key = rowIndex + '-' + columnIndex; + var cellStyleObject = cellStyle({ rowIndex: rowIndex, columnIndex: columnIndex }); + var renderedCell = void 0; + + // Avoid re-creating cells while scrolling. + // This can lead to the same cell being created many times and can cause performance issues for "heavy" cells. + // If a scroll is in progress- cache and reuse cells. + // This cache will be thrown away once scrolling complets. + if (isScrolling) { + if (!cellCache[key]) { + cellCache[key] = cellRenderer({ + columnIndex: columnIndex, + isScrolling: isScrolling, + rowIndex: rowIndex + }); + } + renderedCell = cellCache[key]; + // If the user is no longer scrolling, don't cache cells. + // This makes dynamic cell content difficult for users and would also lead to a heavier memory footprint. } else { - // If we haven't yet measured this high, fallback to an exponential search with an inner binary search. - // The exponential search avoids pre-computing sizes for the full set of cells as a binary search would. - // The overall complexity for this approach is O(log n). - return this._exponentialSearch({ - index: lastMeasuredIndex, - offset: offset + renderedCell = cellRenderer({ + columnIndex: columnIndex, + isScrolling: isScrolling, + rowIndex: rowIndex }); } - } - }]); - return CellSizeAndPositionManager; -}(); + if (renderedCell == null || renderedCell === false) { + continue; + } -exports.default = CellSizeAndPositionManager; -},{}],64:[function(require,module,exports){ + var className = cellClassName({ columnIndex: columnIndex, rowIndex: rowIndex }); + + var child = _react2.default.createElement( + 'div', + { + key: key, + className: (0, _classnames2.default)('Grid__cell', className), + style: _extends({ + height: rowDatum.size, + left: columnDatum.offset + horizontalOffsetAdjustment, + top: rowDatum.offset + verticalOffsetAdjustment, + width: columnDatum.size + }, cellStyleObject) + }, + renderedCell + ); + + renderedCells.push(child); + } + } + + return renderedCells; +} +},{"classnames":undefined,"react":undefined}],60:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); -exports.DEFAULT_MAX_SCROLL_SIZE = undefined; +exports.defaultCellRangeRenderer = exports.Grid = exports.default = undefined; -var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); +var _Grid2 = require('./Grid'); -var _CellSizeAndPositionManager = require('./CellSizeAndPositionManager'); +var _Grid3 = _interopRequireDefault(_Grid2); -var _CellSizeAndPositionManager2 = _interopRequireDefault(_CellSizeAndPositionManager); +var _defaultCellRangeRenderer2 = require('./defaultCellRangeRenderer'); + +var _defaultCellRangeRenderer3 = _interopRequireDefault(_defaultCellRangeRenderer2); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } -function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } +exports.default = _Grid3.default; +exports.Grid = _Grid3.default; +exports.defaultCellRangeRenderer = _defaultCellRangeRenderer3.default; +},{"./Grid":58,"./defaultCellRangeRenderer":59}],61:[function(require,module,exports){ +'use strict'; -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } +Object.defineProperty(exports, "__esModule", { + value: true +}); -/** - * Browsers have scroll offset limitations (eg Chrome stops scrolling at ~33.5M pixels where as Edge tops out at ~1.5M pixels). - * After a certain position, the browser won't allow the user to scroll further (even via JavaScript scroll offset adjustments). - * This util picks a lower ceiling for max size and artificially adjusts positions within to make it transparent for users. - */ -var DEFAULT_MAX_SCROLL_SIZE = exports.DEFAULT_MAX_SCROLL_SIZE = 1500000; +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } /** - * Extends CellSizeAndPositionManager and adds scaling behavior for lists that are too large to fit within a browser's native limits. + * Just-in-time calculates and caches size and position information for a collection of cells. */ +var CellSizeAndPositionManager = function () { + function CellSizeAndPositionManager(_ref) { + var cellCount = _ref.cellCount; + var cellSizeGetter = _ref.cellSizeGetter; + var estimatedCellSize = _ref.estimatedCellSize; -var ScalingCellSizeAndPositionManager = function () { - function ScalingCellSizeAndPositionManager(_ref) { - var _ref$maxScrollSize = _ref.maxScrollSize; - var maxScrollSize = _ref$maxScrollSize === undefined ? DEFAULT_MAX_SCROLL_SIZE : _ref$maxScrollSize; + _classCallCheck(this, CellSizeAndPositionManager); - var params = _objectWithoutProperties(_ref, ['maxScrollSize']); + this._cellSizeGetter = cellSizeGetter; + this._cellCount = cellCount; + this._estimatedCellSize = estimatedCellSize; - _classCallCheck(this, ScalingCellSizeAndPositionManager); + // Cache of size and position data for cells, mapped by cell index. + // Note that invalid values may exist in this map so only rely on cells up to this._lastMeasuredIndex + this._cellSizeAndPositionData = {}; - // Favor composition over inheritance to simplify IE10 support - this._cellSizeAndPositionManager = new _CellSizeAndPositionManager2.default(params); - this._maxScrollSize = maxScrollSize; + // Measurements for cells up to this index can be trusted; cells afterward should be estimated. + this._lastMeasuredIndex = -1; } - _createClass(ScalingCellSizeAndPositionManager, [{ + _createClass(CellSizeAndPositionManager, [{ key: 'configure', - value: function configure(params) { - this._cellSizeAndPositionManager.configure(params); + value: function configure(_ref2) { + var cellCount = _ref2.cellCount; + var estimatedCellSize = _ref2.estimatedCellSize; + + this._cellCount = cellCount; + this._estimatedCellSize = estimatedCellSize; } }, { key: 'getCellCount', value: function getCellCount() { - return this._cellSizeAndPositionManager.getCellCount(); + return this._cellCount; } }, { key: 'getEstimatedCellSize', value: function getEstimatedCellSize() { - return this._cellSizeAndPositionManager.getEstimatedCellSize(); + return this._estimatedCellSize; } }, { key: 'getLastMeasuredIndex', value: function getLastMeasuredIndex() { - return this._cellSizeAndPositionManager.getLastMeasuredIndex(); + return this._lastMeasuredIndex; } /** - * Number of pixels a cell at the given position (offset) should be shifted in order to fit within the scaled container. - * The offset passed to this function is scalled (safe) as well. + * This method returns the size and position for the cell at the specified index. + * It just-in-time calculates (or used cached values) for cells leading up to the index. */ - }, { - key: 'getOffsetAdjustment', - value: function getOffsetAdjustment(_ref2) { - var containerSize = _ref2.containerSize; - var offset = _ref2.offset; - - var totalSize = this._cellSizeAndPositionManager.getTotalSize(); - var safeTotalSize = this.getTotalSize(); - var offsetPercentage = this._getOffsetPercentage({ - containerSize: containerSize, - offset: offset, - totalSize: safeTotalSize - }); - - return Math.round(offsetPercentage * (safeTotalSize - totalSize)); - } }, { key: 'getSizeAndPositionOfCell', value: function getSizeAndPositionOfCell(index) { - return this._cellSizeAndPositionManager.getSizeAndPositionOfCell(index); + if (index < 0 || index >= this._cellCount) { + throw Error('Requested index ' + index + ' is outside of range 0..' + this._cellCount); + } + + if (index > this._lastMeasuredIndex) { + var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell(); + var _offset = lastMeasuredCellSizeAndPosition.offset + lastMeasuredCellSizeAndPosition.size; + + for (var i = this._lastMeasuredIndex + 1; i <= index; i++) { + var _size = this._cellSizeGetter({ index: i }); + + if (_size == null || isNaN(_size)) { + throw Error('Invalid size returned for cell ' + i + ' of value ' + _size); + } + + this._cellSizeAndPositionData[i] = { + offset: _offset, + size: _size + }; + + _offset += _size; + } + + this._lastMeasuredIndex = index; + } + + return this._cellSizeAndPositionData[index]; } }, { key: 'getSizeAndPositionOfLastMeasuredCell', value: function getSizeAndPositionOfLastMeasuredCell() { - return this._cellSizeAndPositionManager.getSizeAndPositionOfLastMeasuredCell(); + return this._lastMeasuredIndex >= 0 ? this._cellSizeAndPositionData[this._lastMeasuredIndex] : { + offset: 0, + size: 0 + }; } - /** See CellSizeAndPositionManager#getTotalSize */ + /** + * Total size of all cells being measured. + * This value will be completedly estimated initially. + * As cells as measured the estimate will be updated. + */ }, { key: 'getTotalSize', value: function getTotalSize() { - return Math.min(this._maxScrollSize, this._cellSizeAndPositionManager.getTotalSize()); + var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell(); + + return lastMeasuredCellSizeAndPosition.offset + lastMeasuredCellSizeAndPosition.size + (this._cellCount - this._lastMeasuredIndex - 1) * this._estimatedCellSize; } - /** See CellSizeAndPositionManager#getUpdatedOffsetForIndex */ + /** + * Determines a new offset that ensures a certain cell is visible, given the current offset. + * If the cell is already visible then the current offset will be returned. + * If the current offset is too great or small, it will be adjusted just enough to ensure the specified index is visible. + * + * @param align Desired alignment within container; one of "auto" (default), "start", or "end" + * @param containerSize Size (width or height) of the container viewport + * @param currentOffset Container's current (x or y) offset + * @param totalSize Total size (width or height) of all cells + * @return Offset to use to ensure the specified cell is visible + */ }, { key: 'getUpdatedOffsetForIndex', @@ -7799,701 +7891,553 @@ var ScalingCellSizeAndPositionManager = function () { var containerSize = _ref3.containerSize; var currentOffset = _ref3.currentOffset; var targetIndex = _ref3.targetIndex; - var totalSize = _ref3.totalSize; - currentOffset = this._safeOffsetToOffset({ - containerSize: containerSize, - offset: currentOffset - }); + var datum = this.getSizeAndPositionOfCell(targetIndex); + var maxOffset = datum.offset; + var minOffset = maxOffset - containerSize + datum.size; - var offset = this._cellSizeAndPositionManager.getUpdatedOffsetForIndex({ - align: align, - containerSize: containerSize, - currentOffset: currentOffset, - targetIndex: targetIndex, - totalSize: totalSize - }); + var idealOffset = void 0; - return this._offsetToSafeOffset({ - containerSize: containerSize, - offset: offset - }); - } + switch (align) { + case 'start': + idealOffset = maxOffset; + break; + case 'end': + idealOffset = minOffset; + break; + case 'center': + idealOffset = maxOffset - (containerSize - datum.size) / 2; + break; + default: + idealOffset = Math.max(minOffset, Math.min(maxOffset, currentOffset)); + break; + } - /** See CellSizeAndPositionManager#getVisibleCellRange */ + var totalSize = this.getTotalSize(); + return Math.max(0, Math.min(totalSize - containerSize, idealOffset)); + } }, { key: 'getVisibleCellRange', value: function getVisibleCellRange(_ref4) { var containerSize = _ref4.containerSize; var offset = _ref4.offset; - offset = this._safeOffsetToOffset({ - containerSize: containerSize, - offset: offset - }); + var totalSize = this.getTotalSize(); - return this._cellSizeAndPositionManager.getVisibleCellRange({ - containerSize: containerSize, - offset: offset - }); + if (totalSize === 0) { + return {}; + } + + var maxOffset = offset + containerSize; + var start = this._findNearestCell(offset); + + var datum = this.getSizeAndPositionOfCell(start); + offset = datum.offset + datum.size; + + var stop = start; + + while (offset < maxOffset && stop < this._cellCount - 1) { + stop++; + + offset += this.getSizeAndPositionOfCell(stop).size; + } + + return { + start: start, + stop: stop + }; } + + /** + * Clear all cached values for cells after the specified index. + * This method should be called for any cell that has changed its size. + * It will not immediately perform any calculations; they'll be performed the next time getSizeAndPositionOfCell() is called. + */ + }, { key: 'resetCell', value: function resetCell(index) { - this._cellSizeAndPositionManager.resetCell(index); + this._lastMeasuredIndex = Math.min(this._lastMeasuredIndex, index - 1); } }, { - key: '_getOffsetPercentage', - value: function _getOffsetPercentage(_ref5) { - var containerSize = _ref5.containerSize; + key: '_binarySearch', + value: function _binarySearch(_ref5) { + var high = _ref5.high; + var low = _ref5.low; var offset = _ref5.offset; - var totalSize = _ref5.totalSize; - return totalSize <= containerSize ? 0 : offset / (totalSize - containerSize); - } - }, { - key: '_offsetToSafeOffset', - value: function _offsetToSafeOffset(_ref6) { - var containerSize = _ref6.containerSize; - var offset = _ref6.offset; + var middle = void 0; + var currentOffset = void 0; - var totalSize = this._cellSizeAndPositionManager.getTotalSize(); - var safeTotalSize = this.getTotalSize(); + while (low <= high) { + middle = low + Math.floor((high - low) / 2); + currentOffset = this.getSizeAndPositionOfCell(middle).offset; - if (totalSize === safeTotalSize) { - return offset; - } else { - var offsetPercentage = this._getOffsetPercentage({ - containerSize: containerSize, - offset: offset, - totalSize: totalSize - }); + if (currentOffset === offset) { + return middle; + } else if (currentOffset < offset) { + low = middle + 1; + } else if (currentOffset > offset) { + high = middle - 1; + } + } - return Math.round(offsetPercentage * (safeTotalSize - containerSize)); + if (low > 0) { + return low - 1; } } }, { - key: '_safeOffsetToOffset', - value: function _safeOffsetToOffset(_ref7) { - var containerSize = _ref7.containerSize; - var offset = _ref7.offset; - - var totalSize = this._cellSizeAndPositionManager.getTotalSize(); - var safeTotalSize = this.getTotalSize(); + key: '_exponentialSearch', + value: function _exponentialSearch(_ref6) { + var index = _ref6.index; + var offset = _ref6.offset; - if (totalSize === safeTotalSize) { - return offset; - } else { - var offsetPercentage = this._getOffsetPercentage({ - containerSize: containerSize, - offset: offset, - totalSize: safeTotalSize - }); + var interval = 1; - return Math.round(offsetPercentage * (totalSize - containerSize)); + while (index < this._cellCount && this.getSizeAndPositionOfCell(index).offset < offset) { + index += interval; + interval *= 2; } - } - }]); - - return ScalingCellSizeAndPositionManager; -}(); - -exports.default = ScalingCellSizeAndPositionManager; -},{"./CellSizeAndPositionManager":63}],65:[function(require,module,exports){ -'use strict'; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = calculateSizeAndPositionDataAndUpdateScrollOffset; -/** - * Helper method that determines when to recalculate row or column metadata. - * - * @param cellCount Number of rows or columns in the current axis - * @param cellsSize Width or height of cells for the current axis - * @param computeMetadataCallback Method to invoke if cell metadata should be recalculated - * @param computeMetadataCallbackProps Parameters to pass to :computeMetadataCallback - * @param nextCellsCount Newly updated number of rows or columns in the current axis - * @param nextCellsSize Newly updated width or height of cells for the current axis - * @param nextScrollToIndex Newly updated scroll-to-index - * @param scrollToIndex Scroll-to-index - * @param updateScrollOffsetForScrollToIndex Callback to invoke if the scroll position should be recalculated - */ -function calculateSizeAndPositionDataAndUpdateScrollOffset(_ref) { - var cellCount = _ref.cellCount; - var cellSize = _ref.cellSize; - var computeMetadataCallback = _ref.computeMetadataCallback; - var computeMetadataCallbackProps = _ref.computeMetadataCallbackProps; - var nextCellsCount = _ref.nextCellsCount; - var nextCellSize = _ref.nextCellSize; - var nextScrollToIndex = _ref.nextScrollToIndex; - var scrollToIndex = _ref.scrollToIndex; - var updateScrollOffsetForScrollToIndex = _ref.updateScrollOffsetForScrollToIndex; - - // Don't compare cell sizes if they are functions because inline functions would cause infinite loops. - // In that event users should use the manual recompute methods to inform of changes. - if (cellCount !== nextCellsCount || (typeof cellSize === 'number' || typeof nextCellSize === 'number') && cellSize !== nextCellSize) { - computeMetadataCallback(computeMetadataCallbackProps); - - // Updated cell metadata may have hidden the previous scrolled-to item. - // In this case we should also update the scrollTop to ensure it stays visible. - if (scrollToIndex >= 0 && scrollToIndex === nextScrollToIndex) { - updateScrollOffsetForScrollToIndex(); - } - } -} -},{}],66:[function(require,module,exports){ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = getOverscanIndices; -var SCROLL_DIRECTION_BACKWARD = exports.SCROLL_DIRECTION_BACKWARD = -1; -var SCROLL_DIRECTION_FIXED = exports.SCROLL_DIRECTION_FIXED = 0; -var SCROLL_DIRECTION_FORWARD = exports.SCROLL_DIRECTION_FORWARD = 1; -/** - * Calculates the number of cells to overscan before and after a specified range. - * This function ensures that overscanning doesn't exceed the available cells. - * - * @param cellCount Number of rows or columns in the current axis - * @param scrollDirection One of SCROLL_DIRECTION_BACKWARD - * @param overscanCellsCount Maximum number of cells to over-render in either direction - * @param startIndex Begin of range of visible cells - * @param stopIndex End of range of visible cells - */ -function getOverscanIndices(_ref) { - var cellCount = _ref.cellCount; - var overscanCellsCount = _ref.overscanCellsCount; - var scrollDirection = _ref.scrollDirection; - var startIndex = _ref.startIndex; - var stopIndex = _ref.stopIndex; + return this._binarySearch({ + high: Math.min(index, this._cellCount - 1), + low: Math.floor(index / 2), + offset: offset + }); + } - var overscanStartIndex = void 0; - var overscanStopIndex = void 0; + /** + * Searches for the cell (index) nearest the specified offset. + * + * If no exact match is found the next lowest cell index will be returned. + * This allows partially visible cells (with offsets just before/above the fold) to be visible. + */ - if (scrollDirection === SCROLL_DIRECTION_FORWARD) { - overscanStartIndex = startIndex; - overscanStopIndex = stopIndex + overscanCellsCount * 2; - } else if (scrollDirection === SCROLL_DIRECTION_BACKWARD) { - overscanStartIndex = startIndex - overscanCellsCount * 2; - overscanStopIndex = stopIndex; - } else { - overscanStartIndex = startIndex - overscanCellsCount; - overscanStopIndex = stopIndex + overscanCellsCount; - } + }, { + key: '_findNearestCell', + value: function _findNearestCell(offset) { + if (isNaN(offset)) { + throw Error('Invalid offset ' + offset + ' specified'); + } - return { - overscanStartIndex: Math.max(0, overscanStartIndex), - overscanStopIndex: Math.min(cellCount - 1, overscanStopIndex) - }; -} -},{}],67:[function(require,module,exports){ -'use strict'; + // Our search algorithms find the nearest match at or below the specified offset. + // So make sure the offset is at least 0 or no match will be found. + offset = Math.max(0, offset); -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = updateScrollIndexHelper; -/** - * Helper function that determines when to update scroll offsets to ensure that a scroll-to-index remains visible. - * This function also ensures that the scroll ofset isn't past the last column/row of cells. - * - * @param cellsSize Width or height of cells for the current axis - * @param cellSizeAndPositionManager Manages size and position metadata of cells - * @param previousCellsCount Previous number of rows or columns - * @param previousCellsSize Previous width or height of cells - * @param previousScrollToIndex Previous scroll-to-index - * @param previousSize Previous width or height of the virtualized container - * @param scrollOffset Current scrollLeft or scrollTop - * @param scrollToIndex Scroll-to-index - * @param size Width or height of the virtualized container - * @param updateScrollIndexCallback Callback to invoke with an scroll-to-index value - */ -function updateScrollIndexHelper(_ref) { - var cellSize = _ref.cellSize; - var cellSizeAndPositionManager = _ref.cellSizeAndPositionManager; - var previousCellsCount = _ref.previousCellsCount; - var previousCellSize = _ref.previousCellSize; - var previousScrollToAlignment = _ref.previousScrollToAlignment; - var previousScrollToIndex = _ref.previousScrollToIndex; - var previousSize = _ref.previousSize; - var scrollOffset = _ref.scrollOffset; - var scrollToAlignment = _ref.scrollToAlignment; - var scrollToIndex = _ref.scrollToIndex; - var size = _ref.size; - var updateScrollIndexCallback = _ref.updateScrollIndexCallback; + var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell(); + var lastMeasuredIndex = Math.max(0, this._lastMeasuredIndex); - var cellCount = cellSizeAndPositionManager.getCellCount(); - var hasScrollToIndex = scrollToIndex >= 0 && scrollToIndex < cellCount; - var sizeHasChanged = size !== previousSize || !previousCellSize || typeof cellSize === 'number' && cellSize !== previousCellSize; + if (lastMeasuredCellSizeAndPosition.offset >= offset) { + // If we've already measured cells within this range just use a binary search as it's faster. + return this._binarySearch({ + high: lastMeasuredIndex, + low: 0, + offset: offset + }); + } else { + // If we haven't yet measured this high, fallback to an exponential search with an inner binary search. + // The exponential search avoids pre-computing sizes for the full set of cells as a binary search would. + // The overall complexity for this approach is O(log n). + return this._exponentialSearch({ + index: lastMeasuredIndex, + offset: offset + }); + } + } + }]); - // If we have a new scroll target OR if height/row-height has changed, - // We should ensure that the scroll target is visible. - if (hasScrollToIndex && (sizeHasChanged || scrollToAlignment !== previousScrollToAlignment || scrollToIndex !== previousScrollToIndex)) { - updateScrollIndexCallback(scrollToIndex); + return CellSizeAndPositionManager; +}(); - // If we don't have a selected item but list size or number of children have decreased, - // Make sure we aren't scrolled too far past the current content. - } else if (!hasScrollToIndex && cellCount > 0 && (size < previousSize || cellCount < previousCellsCount)) { - // We need to ensure that the current scroll offset is still within the collection's range. - // To do this, we don't need to measure everything; CellMeasurer would perform poorly. - // Just check to make sure we're still okay. - // Only adjust the scroll position if we've scrolled below the last set of rows. - if (scrollOffset > cellSizeAndPositionManager.getTotalSize() - size) { - updateScrollIndexCallback(cellCount - 1); - } - } -} -},{}],68:[function(require,module,exports){ +exports.default = CellSizeAndPositionManager; +},{}],62:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); +exports.DEFAULT_MAX_SCROLL_SIZE = undefined; var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); -exports.isRangeVisible = isRangeVisible; -exports.scanForUnloadedRanges = scanForUnloadedRanges; -exports.forceUpdateReactVirtualizedComponent = forceUpdateReactVirtualizedComponent; - -var _react = require('react'); - -var _reactAddonsShallowCompare = require('react-addons-shallow-compare'); - -var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); - -var _createCallbackMemoizer = require('../utils/createCallbackMemoizer'); +var _CellSizeAndPositionManager = require('./CellSizeAndPositionManager'); -var _createCallbackMemoizer2 = _interopRequireDefault(_createCallbackMemoizer); +var _CellSizeAndPositionManager2 = _interopRequireDefault(_CellSizeAndPositionManager); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } +function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } -function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } +/** + * Browsers have scroll offset limitations (eg Chrome stops scrolling at ~33.5M pixels where as Edge tops out at ~1.5M pixels). + * After a certain position, the browser won't allow the user to scroll further (even via JavaScript scroll offset adjustments). + * This util picks a lower ceiling for max size and artificially adjusts positions within to make it transparent for users. + */ +var DEFAULT_MAX_SCROLL_SIZE = exports.DEFAULT_MAX_SCROLL_SIZE = 1500000; /** - * Higher-order component that manages lazy-loading for "infinite" data. - * This component decorates a virtual component and just-in-time prefetches rows as a user scrolls. - * It is intended as a convenience component; fork it if you'd like finer-grained control over data-loading. + * Extends CellSizeAndPositionManager and adds scaling behavior for lists that are too large to fit within a browser's native limits. */ -var InfiniteLoader = function (_Component) { - _inherits(InfiniteLoader, _Component); - function InfiniteLoader(props, context) { - _classCallCheck(this, InfiniteLoader); +var ScalingCellSizeAndPositionManager = function () { + function ScalingCellSizeAndPositionManager(_ref) { + var _ref$maxScrollSize = _ref.maxScrollSize; + var maxScrollSize = _ref$maxScrollSize === undefined ? DEFAULT_MAX_SCROLL_SIZE : _ref$maxScrollSize; - var _this = _possibleConstructorReturn(this, (InfiniteLoader.__proto__ || Object.getPrototypeOf(InfiniteLoader)).call(this, props, context)); + var params = _objectWithoutProperties(_ref, ['maxScrollSize']); - _this._loadMoreRowsMemoizer = (0, _createCallbackMemoizer2.default)(); + _classCallCheck(this, ScalingCellSizeAndPositionManager); - _this._onRowsRendered = _this._onRowsRendered.bind(_this); - _this._registerChild = _this._registerChild.bind(_this); - return _this; + // Favor composition over inheritance to simplify IE10 support + this._cellSizeAndPositionManager = new _CellSizeAndPositionManager2.default(params); + this._maxScrollSize = maxScrollSize; } - _createClass(InfiniteLoader, [{ - key: 'render', - value: function render() { - var children = this.props.children; - - - return children({ - onRowsRendered: this._onRowsRendered, - registerChild: this._registerChild - }); + _createClass(ScalingCellSizeAndPositionManager, [{ + key: 'configure', + value: function configure(params) { + this._cellSizeAndPositionManager.configure(params); } }, { - key: 'shouldComponentUpdate', - value: function shouldComponentUpdate(nextProps, nextState) { - return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState); + key: 'getCellCount', + value: function getCellCount() { + return this._cellSizeAndPositionManager.getCellCount(); } }, { - key: '_loadUnloadedRanges', - value: function _loadUnloadedRanges(unloadedRanges) { - var _this2 = this; - - var loadMoreRows = this.props.loadMoreRows; - - - unloadedRanges.forEach(function (unloadedRange) { - var promise = loadMoreRows(unloadedRange); - if (promise) { - promise.then(function () { - // Refresh the visible rows if any of them have just been loaded. - // Otherwise they will remain in their unloaded visual state. - if (isRangeVisible({ - lastRenderedStartIndex: _this2._lastRenderedStartIndex, - lastRenderedStopIndex: _this2._lastRenderedStopIndex, - startIndex: unloadedRange.startIndex, - stopIndex: unloadedRange.stopIndex - })) { - if (_this2._registeredChild) { - forceUpdateReactVirtualizedComponent(_this2._registeredChild); - } - } - }); - } - }); + key: 'getEstimatedCellSize', + value: function getEstimatedCellSize() { + return this._cellSizeAndPositionManager.getEstimatedCellSize(); } }, { - key: '_onRowsRendered', - value: function _onRowsRendered(_ref) { - var _this3 = this; - - var startIndex = _ref.startIndex; - var stopIndex = _ref.stopIndex; - var _props = this.props; - var isRowLoaded = _props.isRowLoaded; - var minimumBatchSize = _props.minimumBatchSize; - var rowCount = _props.rowCount; - var threshold = _props.threshold; + key: 'getLastMeasuredIndex', + value: function getLastMeasuredIndex() { + return this._cellSizeAndPositionManager.getLastMeasuredIndex(); + } + /** + * Number of pixels a cell at the given position (offset) should be shifted in order to fit within the scaled container. + * The offset passed to this function is scalled (safe) as well. + */ - this._lastRenderedStartIndex = startIndex; - this._lastRenderedStopIndex = stopIndex; + }, { + key: 'getOffsetAdjustment', + value: function getOffsetAdjustment(_ref2) { + var containerSize = _ref2.containerSize; + var offset = _ref2.offset; - var unloadedRanges = scanForUnloadedRanges({ - isRowLoaded: isRowLoaded, - minimumBatchSize: minimumBatchSize, - rowCount: rowCount, - startIndex: Math.max(0, startIndex - threshold), - stopIndex: Math.min(rowCount - 1, stopIndex + threshold) + var totalSize = this._cellSizeAndPositionManager.getTotalSize(); + var safeTotalSize = this.getTotalSize(); + var offsetPercentage = this._getOffsetPercentage({ + containerSize: containerSize, + offset: offset, + totalSize: safeTotalSize }); - // For memoize comparison - var squashedUnloadedRanges = unloadedRanges.reduce(function (reduced, unloadedRange) { - return reduced.concat([unloadedRange.startIndex, unloadedRange.stopIndex]); - }, []); - - this._loadMoreRowsMemoizer({ - callback: function callback() { - _this3._loadUnloadedRanges(unloadedRanges); - }, - indices: { squashedUnloadedRanges: squashedUnloadedRanges } - }); + return Math.round(offsetPercentage * (safeTotalSize - totalSize)); + } + }, { + key: 'getSizeAndPositionOfCell', + value: function getSizeAndPositionOfCell(index) { + return this._cellSizeAndPositionManager.getSizeAndPositionOfCell(index); } }, { - key: '_registerChild', - value: function _registerChild(registeredChild) { - this._registeredChild = registeredChild; + key: 'getSizeAndPositionOfLastMeasuredCell', + value: function getSizeAndPositionOfLastMeasuredCell() { + return this._cellSizeAndPositionManager.getSizeAndPositionOfLastMeasuredCell(); } - }]); - - return InfiniteLoader; -}(_react.Component); - -/** - * Determines if the specified start/stop range is visible based on the most recently rendered range. - */ - - -InfiniteLoader.propTypes = { - /** - * Function respondible for rendering a virtualized component. - * This function should implement the following signature: - * ({ onRowsRendered, registerChild }) => PropTypes.element - * - * The specified :onRowsRendered function should be passed through to the child's :onRowsRendered property. - * The :registerChild callback should be set as the virtualized component's :ref. - */ - children: _react.PropTypes.func.isRequired, - /** - * Function responsible for tracking the loaded state of each row. - * It should implement the following signature: ({ index: number }): boolean - */ - isRowLoaded: _react.PropTypes.func.isRequired, + /** See CellSizeAndPositionManager#getTotalSize */ - /** - * Callback to be invoked when more rows must be loaded. - * It should implement the following signature: ({ startIndex, stopIndex }): Promise - * The returned Promise should be resolved once row data has finished loading. - * It will be used to determine when to refresh the list with the newly-loaded data. - * This callback may be called multiple times in reaction to a single scroll event. - */ - loadMoreRows: _react.PropTypes.func.isRequired, + }, { + key: 'getTotalSize', + value: function getTotalSize() { + return Math.min(this._maxScrollSize, this._cellSizeAndPositionManager.getTotalSize()); + } - /** - * Minimum number of rows to be loaded at a time. - * This property can be used to batch requests to reduce HTTP requests. - */ - minimumBatchSize: _react.PropTypes.number.isRequired, + /** See CellSizeAndPositionManager#getUpdatedOffsetForIndex */ - /** - * Number of rows in list; can be arbitrary high number if actual number is unknown. - */ - rowCount: _react.PropTypes.number.isRequired, + }, { + key: 'getUpdatedOffsetForIndex', + value: function getUpdatedOffsetForIndex(_ref3) { + var _ref3$align = _ref3.align; + var align = _ref3$align === undefined ? 'auto' : _ref3$align; + var containerSize = _ref3.containerSize; + var currentOffset = _ref3.currentOffset; + var targetIndex = _ref3.targetIndex; + var totalSize = _ref3.totalSize; - /** - * Threshold at which to pre-fetch data. - * A threshold X means that data will start loading when a user scrolls within X rows. - * This value defaults to 15. - */ - threshold: _react.PropTypes.number.isRequired -}; -InfiniteLoader.defaultProps = { - minimumBatchSize: 10, - rowCount: 0, - threshold: 15 -}; -exports.default = InfiniteLoader; -function isRangeVisible(_ref2) { - var lastRenderedStartIndex = _ref2.lastRenderedStartIndex; - var lastRenderedStopIndex = _ref2.lastRenderedStopIndex; - var startIndex = _ref2.startIndex; - var stopIndex = _ref2.stopIndex; + currentOffset = this._safeOffsetToOffset({ + containerSize: containerSize, + offset: currentOffset + }); - return !(startIndex > lastRenderedStopIndex || stopIndex < lastRenderedStartIndex); -} + var offset = this._cellSizeAndPositionManager.getUpdatedOffsetForIndex({ + align: align, + containerSize: containerSize, + currentOffset: currentOffset, + targetIndex: targetIndex, + totalSize: totalSize + }); -/** - * Returns all of the ranges within a larger range that contain unloaded rows. - */ -function scanForUnloadedRanges(_ref3) { - var isRowLoaded = _ref3.isRowLoaded; - var minimumBatchSize = _ref3.minimumBatchSize; - var rowCount = _ref3.rowCount; - var startIndex = _ref3.startIndex; - var stopIndex = _ref3.stopIndex; + return this._offsetToSafeOffset({ + containerSize: containerSize, + offset: offset + }); + } - var unloadedRanges = []; + /** See CellSizeAndPositionManager#getVisibleCellRange */ - var rangeStartIndex = null; - var rangeStopIndex = null; + }, { + key: 'getVisibleCellRange', + value: function getVisibleCellRange(_ref4) { + var containerSize = _ref4.containerSize; + var offset = _ref4.offset; - for (var index = startIndex; index <= stopIndex; index++) { - var loaded = isRowLoaded({ index: index }); + offset = this._safeOffsetToOffset({ + containerSize: containerSize, + offset: offset + }); - if (!loaded) { - rangeStopIndex = index; - if (rangeStartIndex === null) { - rangeStartIndex = index; - } - } else if (rangeStopIndex !== null) { - unloadedRanges.push({ - startIndex: rangeStartIndex, - stopIndex: rangeStopIndex + return this._cellSizeAndPositionManager.getVisibleCellRange({ + containerSize: containerSize, + offset: offset }); + } + }, { + key: 'resetCell', + value: function resetCell(index) { + this._cellSizeAndPositionManager.resetCell(index); + } + }, { + key: '_getOffsetPercentage', + value: function _getOffsetPercentage(_ref5) { + var containerSize = _ref5.containerSize; + var offset = _ref5.offset; + var totalSize = _ref5.totalSize; - rangeStartIndex = rangeStopIndex = null; + return totalSize <= containerSize ? 0 : offset / (totalSize - containerSize); } - } + }, { + key: '_offsetToSafeOffset', + value: function _offsetToSafeOffset(_ref6) { + var containerSize = _ref6.containerSize; + var offset = _ref6.offset; - // If :rangeStopIndex is not null it means we haven't ran out of unloaded rows. - // Scan forward to try filling our :minimumBatchSize. - if (rangeStopIndex !== null) { - var potentialStopIndex = Math.min(Math.max(rangeStopIndex, rangeStartIndex + minimumBatchSize - 1), rowCount - 1); + var totalSize = this._cellSizeAndPositionManager.getTotalSize(); + var safeTotalSize = this.getTotalSize(); - for (var _index = rangeStopIndex + 1; _index <= potentialStopIndex; _index++) { - if (!isRowLoaded({ index: _index })) { - rangeStopIndex = _index; + if (totalSize === safeTotalSize) { + return offset; } else { - break; + var offsetPercentage = this._getOffsetPercentage({ + containerSize: containerSize, + offset: offset, + totalSize: totalSize + }); + + return Math.round(offsetPercentage * (safeTotalSize - containerSize)); } } + }, { + key: '_safeOffsetToOffset', + value: function _safeOffsetToOffset(_ref7) { + var containerSize = _ref7.containerSize; + var offset = _ref7.offset; - unloadedRanges.push({ - startIndex: rangeStartIndex, - stopIndex: rangeStopIndex - }); - } - - // Check to see if our first range ended prematurely. - // In this case we should scan backwards to try filling our :minimumBatchSize. - if (unloadedRanges.length) { - var firstUnloadedRange = unloadedRanges[0]; - - while (firstUnloadedRange.stopIndex - firstUnloadedRange.startIndex + 1 < minimumBatchSize && firstUnloadedRange.startIndex > 0) { - var _index2 = firstUnloadedRange.startIndex - 1; + var totalSize = this._cellSizeAndPositionManager.getTotalSize(); + var safeTotalSize = this.getTotalSize(); - if (!isRowLoaded({ index: _index2 })) { - firstUnloadedRange.startIndex = _index2; + if (totalSize === safeTotalSize) { + return offset; } else { - break; + var offsetPercentage = this._getOffsetPercentage({ + containerSize: containerSize, + offset: offset, + totalSize: safeTotalSize + }); + + return Math.round(offsetPercentage * (totalSize - containerSize)); } } - } + }]); - return unloadedRanges; -} + return ScalingCellSizeAndPositionManager; +}(); -/** - * Since RV components use shallowCompare we need to force a render (even though props haven't changed). - * However InfiniteLoader may wrap a Grid or it may wrap a FlexTable or VirtualScroll. - * In the first case the built-in React forceUpdate() method is sufficient to force a re-render, - * But in the latter cases we need to use the RV-specific forceUpdateGrid() method. - * Else the inner Grid will not be re-rendered and visuals may be stale. - */ -function forceUpdateReactVirtualizedComponent(component) { - typeof component.forceUpdateGrid === 'function' ? component.forceUpdateGrid() : component.forceUpdate(); -} -},{"../utils/createCallbackMemoizer":78,"react":undefined,"react-addons-shallow-compare":30}],69:[function(require,module,exports){ +exports.default = ScalingCellSizeAndPositionManager; +},{"./CellSizeAndPositionManager":61}],63:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); -exports.InfiniteLoader = exports.default = undefined; - -var _InfiniteLoader2 = require('./InfiniteLoader'); - -var _InfiniteLoader3 = _interopRequireDefault(_InfiniteLoader2); +exports.default = calculateSizeAndPositionDataAndUpdateScrollOffset; +/** + * Helper method that determines when to recalculate row or column metadata. + * + * @param cellCount Number of rows or columns in the current axis + * @param cellsSize Width or height of cells for the current axis + * @param computeMetadataCallback Method to invoke if cell metadata should be recalculated + * @param computeMetadataCallbackProps Parameters to pass to :computeMetadataCallback + * @param nextCellsCount Newly updated number of rows or columns in the current axis + * @param nextCellsSize Newly updated width or height of cells for the current axis + * @param nextScrollToIndex Newly updated scroll-to-index + * @param scrollToIndex Scroll-to-index + * @param updateScrollOffsetForScrollToIndex Callback to invoke if the scroll position should be recalculated + */ +function calculateSizeAndPositionDataAndUpdateScrollOffset(_ref) { + var cellCount = _ref.cellCount; + var cellSize = _ref.cellSize; + var computeMetadataCallback = _ref.computeMetadataCallback; + var computeMetadataCallbackProps = _ref.computeMetadataCallbackProps; + var nextCellsCount = _ref.nextCellsCount; + var nextCellSize = _ref.nextCellSize; + var nextScrollToIndex = _ref.nextScrollToIndex; + var scrollToIndex = _ref.scrollToIndex; + var updateScrollOffsetForScrollToIndex = _ref.updateScrollOffsetForScrollToIndex; -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + // Don't compare cell sizes if they are functions because inline functions would cause infinite loops. + // In that event users should use the manual recompute methods to inform of changes. + if (cellCount !== nextCellsCount || (typeof cellSize === 'number' || typeof nextCellSize === 'number') && cellSize !== nextCellSize) { + computeMetadataCallback(computeMetadataCallbackProps); -exports.default = _InfiniteLoader3.default; -exports.InfiniteLoader = _InfiniteLoader3.default; -},{"./InfiniteLoader":68}],70:[function(require,module,exports){ -'use strict'; + // Updated cell metadata may have hidden the previous scrolled-to item. + // In this case we should also update the scrollTop to ensure it stays visible. + if (scrollToIndex >= 0 && scrollToIndex === nextScrollToIndex) { + updateScrollOffsetForScrollToIndex(); + } + } +} +},{}],64:[function(require,module,exports){ +"use strict"; Object.defineProperty(exports, "__esModule", { value: true }); - -var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); - -var _react = require('react'); - -var _reactAddonsShallowCompare = require('react-addons-shallow-compare'); - -var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } +exports.default = getOverscanIndices; +var SCROLL_DIRECTION_BACKWARD = exports.SCROLL_DIRECTION_BACKWARD = -1; +var SCROLL_DIRECTION_FIXED = exports.SCROLL_DIRECTION_FIXED = 0; +var SCROLL_DIRECTION_FORWARD = exports.SCROLL_DIRECTION_FORWARD = 1; /** - * HOC that simplifies the process of synchronizing scrolling between two or more virtualized components. + * Calculates the number of cells to overscan before and after a specified range. + * This function ensures that overscanning doesn't exceed the available cells. + * + * @param cellCount Number of rows or columns in the current axis + * @param scrollDirection One of SCROLL_DIRECTION_BACKWARD + * @param overscanCellsCount Maximum number of cells to over-render in either direction + * @param startIndex Begin of range of visible cells + * @param stopIndex End of range of visible cells */ -var ScrollSync = function (_Component) { - _inherits(ScrollSync, _Component); - - function ScrollSync(props, context) { - _classCallCheck(this, ScrollSync); - - var _this = _possibleConstructorReturn(this, (ScrollSync.__proto__ || Object.getPrototypeOf(ScrollSync)).call(this, props, context)); +function getOverscanIndices(_ref) { + var cellCount = _ref.cellCount; + var overscanCellsCount = _ref.overscanCellsCount; + var scrollDirection = _ref.scrollDirection; + var startIndex = _ref.startIndex; + var stopIndex = _ref.stopIndex; - _this.state = { - clientHeight: 0, - clientWidth: 0, - scrollHeight: 0, - scrollLeft: 0, - scrollTop: 0, - scrollWidth: 0 - }; + var overscanStartIndex = void 0; + var overscanStopIndex = void 0; - _this._onScroll = _this._onScroll.bind(_this); - return _this; + if (scrollDirection === SCROLL_DIRECTION_FORWARD) { + overscanStartIndex = startIndex; + overscanStopIndex = stopIndex + overscanCellsCount * 2; + } else if (scrollDirection === SCROLL_DIRECTION_BACKWARD) { + overscanStartIndex = startIndex - overscanCellsCount * 2; + overscanStopIndex = stopIndex; + } else { + overscanStartIndex = startIndex - overscanCellsCount; + overscanStopIndex = stopIndex + overscanCellsCount; } - _createClass(ScrollSync, [{ - key: 'render', - value: function render() { - var children = this.props.children; - var _state = this.state; - var clientHeight = _state.clientHeight; - var clientWidth = _state.clientWidth; - var scrollHeight = _state.scrollHeight; - var scrollLeft = _state.scrollLeft; - var scrollTop = _state.scrollTop; - var scrollWidth = _state.scrollWidth; - - - return children({ - clientHeight: clientHeight, - clientWidth: clientWidth, - onScroll: this._onScroll, - scrollHeight: scrollHeight, - scrollLeft: scrollLeft, - scrollTop: scrollTop, - scrollWidth: scrollWidth - }); - } - }, { - key: 'shouldComponentUpdate', - value: function shouldComponentUpdate(nextProps, nextState) { - return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState); - } - }, { - key: '_onScroll', - value: function _onScroll(_ref) { - var clientHeight = _ref.clientHeight; - var clientWidth = _ref.clientWidth; - var scrollHeight = _ref.scrollHeight; - var scrollLeft = _ref.scrollLeft; - var scrollTop = _ref.scrollTop; - var scrollWidth = _ref.scrollWidth; - - this.setState({ clientHeight: clientHeight, clientWidth: clientWidth, scrollHeight: scrollHeight, scrollLeft: scrollLeft, scrollTop: scrollTop, scrollWidth: scrollWidth }); - } - }]); - - return ScrollSync; -}(_react.Component); - -ScrollSync.propTypes = { - /** - * Function respondible for rendering 2 or more virtualized components. - * This function should implement the following signature: - * ({ onScroll, scrollLeft, scrollTop }) => PropTypes.element - */ - children: _react.PropTypes.func.isRequired -}; -exports.default = ScrollSync; -},{"react":undefined,"react-addons-shallow-compare":30}],71:[function(require,module,exports){ + return { + overscanStartIndex: Math.max(0, overscanStartIndex), + overscanStopIndex: Math.min(cellCount - 1, overscanStopIndex) + }; +} +},{}],65:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); -exports.ScrollSync = exports.default = undefined; - -var _ScrollSync2 = require('./ScrollSync'); +exports.default = updateScrollIndexHelper; +/** + * Helper function that determines when to update scroll offsets to ensure that a scroll-to-index remains visible. + * This function also ensures that the scroll ofset isn't past the last column/row of cells. + * + * @param cellsSize Width or height of cells for the current axis + * @param cellSizeAndPositionManager Manages size and position metadata of cells + * @param previousCellsCount Previous number of rows or columns + * @param previousCellsSize Previous width or height of cells + * @param previousScrollToIndex Previous scroll-to-index + * @param previousSize Previous width or height of the virtualized container + * @param scrollOffset Current scrollLeft or scrollTop + * @param scrollToIndex Scroll-to-index + * @param size Width or height of the virtualized container + * @param updateScrollIndexCallback Callback to invoke with an scroll-to-index value + */ +function updateScrollIndexHelper(_ref) { + var cellSize = _ref.cellSize; + var cellSizeAndPositionManager = _ref.cellSizeAndPositionManager; + var previousCellsCount = _ref.previousCellsCount; + var previousCellSize = _ref.previousCellSize; + var previousScrollToAlignment = _ref.previousScrollToAlignment; + var previousScrollToIndex = _ref.previousScrollToIndex; + var previousSize = _ref.previousSize; + var scrollOffset = _ref.scrollOffset; + var scrollToAlignment = _ref.scrollToAlignment; + var scrollToIndex = _ref.scrollToIndex; + var size = _ref.size; + var updateScrollIndexCallback = _ref.updateScrollIndexCallback; -var _ScrollSync3 = _interopRequireDefault(_ScrollSync2); + var cellCount = cellSizeAndPositionManager.getCellCount(); + var hasScrollToIndex = scrollToIndex >= 0 && scrollToIndex < cellCount; + var sizeHasChanged = size !== previousSize || !previousCellSize || typeof cellSize === 'number' && cellSize !== previousCellSize; -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + // If we have a new scroll target OR if height/row-height has changed, + // We should ensure that the scroll target is visible. + if (hasScrollToIndex && (sizeHasChanged || scrollToAlignment !== previousScrollToAlignment || scrollToIndex !== previousScrollToIndex)) { + updateScrollIndexCallback(scrollToIndex); -exports.default = _ScrollSync3.default; -exports.ScrollSync = _ScrollSync3.default; -},{"./ScrollSync":70}],72:[function(require,module,exports){ + // If we don't have a selected item but list size or number of children have decreased, + // Make sure we aren't scrolled too far past the current content. + } else if (!hasScrollToIndex && cellCount > 0 && (size < previousSize || cellCount < previousCellsCount)) { + // We need to ensure that the current scroll offset is still within the collection's range. + // To do this, we don't need to measure everything; CellMeasurer would perform poorly. + // Just check to make sure we're still okay. + // Only adjust the scroll position if we've scrolled below the last set of rows. + if (scrollOffset > cellSizeAndPositionManager.getTotalSize() - size) { + updateScrollIndexCallback(cellCount - 1); + } + } +} +},{}],66:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); -var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; - var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); -var _Grid = require('../Grid'); - -var _Grid2 = _interopRequireDefault(_Grid); +exports.isRangeVisible = isRangeVisible; +exports.scanForUnloadedRanges = scanForUnloadedRanges; +exports.forceUpdateReactVirtualizedComponent = forceUpdateReactVirtualizedComponent; var _react = require('react'); -var _react2 = _interopRequireDefault(_react); - -var _classnames = require('classnames'); - -var _classnames2 = _interopRequireDefault(_classnames); - var _reactAddonsShallowCompare = require('react-addons-shallow-compare'); var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); +var _createCallbackMemoizer = require('../utils/createCallbackMemoizer'); + +var _createCallbackMemoizer2 = _interopRequireDefault(_createCallbackMemoizer); + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } @@ -8503,85 +8447,35 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** - * It is inefficient to create and manage a large list of DOM elements within a scrolling container - * if only a few of those elements are visible. The primary purpose of this component is to improve - * performance by only rendering the DOM nodes that a user is able to see based on their current - * scroll position. - * - * This component renders a virtualized list of elements with either fixed or dynamic heights. + * Higher-order component that manages lazy-loading for "infinite" data. + * This component decorates a virtual component and just-in-time prefetches rows as a user scrolls. + * It is intended as a convenience component; fork it if you'd like finer-grained control over data-loading. */ -var VirtualScroll = function (_Component) { - _inherits(VirtualScroll, _Component); - - function VirtualScroll(props, context) { - _classCallCheck(this, VirtualScroll); - - var _this = _possibleConstructorReturn(this, (VirtualScroll.__proto__ || Object.getPrototypeOf(VirtualScroll)).call(this, props, context)); - - _this._cellRenderer = _this._cellRenderer.bind(_this); - _this._createRowClassNameGetter = _this._createRowClassNameGetter.bind(_this); - _this._createRowStyleGetter = _this._createRowStyleGetter.bind(_this); - _this._onScroll = _this._onScroll.bind(_this); - _this._onSectionRendered = _this._onSectionRendered.bind(_this); - return _this; - } - - _createClass(VirtualScroll, [{ - key: 'forceUpdateGrid', - value: function forceUpdateGrid() { - this.Grid.forceUpdate(); - } +var InfiniteLoader = function (_Component) { + _inherits(InfiniteLoader, _Component); - /** See Grid#measureAllCells */ + function InfiniteLoader(props, context) { + _classCallCheck(this, InfiniteLoader); - }, { - key: 'measureAllRows', - value: function measureAllRows() { - this.Grid.measureAllCells(); - } + var _this = _possibleConstructorReturn(this, (InfiniteLoader.__proto__ || Object.getPrototypeOf(InfiniteLoader)).call(this, props, context)); - /** See Grid#recomputeGridSize */ + _this._loadMoreRowsMemoizer = (0, _createCallbackMemoizer2.default)(); - }, { - key: 'recomputeRowHeights', - value: function recomputeRowHeights() { - var index = arguments.length <= 0 || arguments[0] === undefined ? 0 : arguments[0]; + _this._onRowsRendered = _this._onRowsRendered.bind(_this); + _this._registerChild = _this._registerChild.bind(_this); + return _this; + } - this.Grid.recomputeGridSize({ - rowIndex: index - }); - this.forceUpdateGrid(); - } - }, { + _createClass(InfiniteLoader, [{ key: 'render', value: function render() { - var _this2 = this; - - var _props = this.props; - var className = _props.className; - var noRowsRenderer = _props.noRowsRenderer; - var scrollToIndex = _props.scrollToIndex; - var width = _props.width; - + var children = this.props.children; - var classNames = (0, _classnames2.default)('VirtualScroll', className); - return _react2.default.createElement(_Grid2.default, _extends({}, this.props, { - autoContainerWidth: true, - cellRenderer: this._cellRenderer, - cellClassName: this._createRowClassNameGetter(), - cellStyle: this._createRowStyleGetter(), - className: classNames, - columnWidth: width, - columnCount: 1, - noContentRenderer: noRowsRenderer, - onScroll: this._onScroll, - onSectionRendered: this._onSectionRendered, - ref: function ref(_ref) { - _this2.Grid = _ref; - }, - scrollToRow: scrollToIndex - })); + return children({ + onRowsRendered: this._onRowsRendered, + registerChild: this._registerChild + }); } }, { key: 'shouldComponentUpdate', @@ -8589,195 +8483,242 @@ var VirtualScroll = function (_Component) { return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState); } }, { - key: '_cellRenderer', - value: function _cellRenderer(_ref2) { - var columnIndex = _ref2.columnIndex; - var isScrolling = _ref2.isScrolling; - var rowIndex = _ref2.rowIndex; - var rowRenderer = this.props.rowRenderer; + key: '_loadUnloadedRanges', + value: function _loadUnloadedRanges(unloadedRanges) { + var _this2 = this; + + var loadMoreRows = this.props.loadMoreRows; - return rowRenderer({ - index: rowIndex, - isScrolling: isScrolling + unloadedRanges.forEach(function (unloadedRange) { + var promise = loadMoreRows(unloadedRange); + if (promise) { + promise.then(function () { + // Refresh the visible rows if any of them have just been loaded. + // Otherwise they will remain in their unloaded visual state. + if (isRangeVisible({ + lastRenderedStartIndex: _this2._lastRenderedStartIndex, + lastRenderedStopIndex: _this2._lastRenderedStopIndex, + startIndex: unloadedRange.startIndex, + stopIndex: unloadedRange.stopIndex + })) { + if (_this2._registeredChild) { + forceUpdateReactVirtualizedComponent(_this2._registeredChild); + } + } + }); + } }); } }, { - key: '_createRowClassNameGetter', - value: function _createRowClassNameGetter() { - var rowClassName = this.props.rowClassName; - + key: '_onRowsRendered', + value: function _onRowsRendered(_ref) { + var _this3 = this; - return rowClassName instanceof Function ? function (_ref3) { - var rowIndex = _ref3.rowIndex; - return rowClassName({ index: rowIndex }); - } : function () { - return rowClassName; - }; - } - }, { - key: '_createRowStyleGetter', - value: function _createRowStyleGetter() { - var rowStyle = this.props.rowStyle; + var startIndex = _ref.startIndex; + var stopIndex = _ref.stopIndex; + var _props = this.props; + var isRowLoaded = _props.isRowLoaded; + var minimumBatchSize = _props.minimumBatchSize; + var rowCount = _props.rowCount; + var threshold = _props.threshold; - var wrapped = rowStyle instanceof Function ? rowStyle : function () { - return rowStyle; - }; + this._lastRenderedStartIndex = startIndex; + this._lastRenderedStopIndex = stopIndex; - // Default width to 100% to prevent list rows from flowing under the vertical scrollbar - return function (_ref4) { - var rowIndex = _ref4.rowIndex; - return _extends({ - width: '100%' - }, wrapped({ index: rowIndex })); - }; - } - }, { - key: '_onScroll', - value: function _onScroll(_ref5) { - var clientHeight = _ref5.clientHeight; - var scrollHeight = _ref5.scrollHeight; - var scrollTop = _ref5.scrollTop; - var onScroll = this.props.onScroll; + var unloadedRanges = scanForUnloadedRanges({ + isRowLoaded: isRowLoaded, + minimumBatchSize: minimumBatchSize, + rowCount: rowCount, + startIndex: Math.max(0, startIndex - threshold), + stopIndex: Math.min(rowCount - 1, stopIndex + threshold) + }); + // For memoize comparison + var squashedUnloadedRanges = unloadedRanges.reduce(function (reduced, unloadedRange) { + return reduced.concat([unloadedRange.startIndex, unloadedRange.stopIndex]); + }, []); - onScroll({ clientHeight: clientHeight, scrollHeight: scrollHeight, scrollTop: scrollTop }); + this._loadMoreRowsMemoizer({ + callback: function callback() { + _this3._loadUnloadedRanges(unloadedRanges); + }, + indices: { squashedUnloadedRanges: squashedUnloadedRanges } + }); } }, { - key: '_onSectionRendered', - value: function _onSectionRendered(_ref6) { - var rowOverscanStartIndex = _ref6.rowOverscanStartIndex; - var rowOverscanStopIndex = _ref6.rowOverscanStopIndex; - var rowStartIndex = _ref6.rowStartIndex; - var rowStopIndex = _ref6.rowStopIndex; - var onRowsRendered = this.props.onRowsRendered; - - - onRowsRendered({ - overscanStartIndex: rowOverscanStartIndex, - overscanStopIndex: rowOverscanStopIndex, - startIndex: rowStartIndex, - stopIndex: rowStopIndex - }); + key: '_registerChild', + value: function _registerChild(registeredChild) { + this._registeredChild = registeredChild; } }]); - return VirtualScroll; + return InfiniteLoader; }(_react.Component); -VirtualScroll.propTypes = { - 'aria-label': _react.PropTypes.string, +/** + * Determines if the specified start/stop range is visible based on the most recently rendered range. + */ + +InfiniteLoader.propTypes = { /** - * Removes fixed height from the scrollingContainer so that the total height - * of rows can stretch the window. Intended for use with WindowScroller + * Function respondible for rendering a virtualized component. + * This function should implement the following signature: + * ({ onRowsRendered, registerChild }) => PropTypes.element + * + * The specified :onRowsRendered function should be passed through to the child's :onRowsRendered property. + * The :registerChild callback should be set as the virtualized component's :ref. */ - autoHeight: _react.PropTypes.bool, - - /** Optional CSS class name */ - className: _react.PropTypes.string, + children: _react.PropTypes.func.isRequired, /** - * Used to estimate the total height of a VirtualScroll before all of its rows have actually been measured. - * The estimated total height is adjusted as rows are rendered. + * Function responsible for tracking the loaded state of each row. + * It should implement the following signature: ({ index: number }): boolean */ - estimatedRowSize: _react.PropTypes.number.isRequired, - - /** Height constraint for list (determines how many actual rows are rendered) */ - height: _react.PropTypes.number.isRequired, - - /** Optional renderer to be used in place of rows when rowCount is 0 */ - noRowsRenderer: _react.PropTypes.func.isRequired, + isRowLoaded: _react.PropTypes.func.isRequired, /** - * Callback invoked with information about the slice of rows that were just rendered. - * ({ startIndex, stopIndex }): void + * Callback to be invoked when more rows must be loaded. + * It should implement the following signature: ({ startIndex, stopIndex }): Promise + * The returned Promise should be resolved once row data has finished loading. + * It will be used to determine when to refresh the list with the newly-loaded data. + * This callback may be called multiple times in reaction to a single scroll event. */ - onRowsRendered: _react.PropTypes.func.isRequired, + loadMoreRows: _react.PropTypes.func.isRequired, /** - * Number of rows to render above/below the visible bounds of the list. - * These rows can help for smoother scrolling on touch devices. + * Minimum number of rows to be loaded at a time. + * This property can be used to batch requests to reduce HTTP requests. */ - overscanRowCount: _react.PropTypes.number.isRequired, + minimumBatchSize: _react.PropTypes.number.isRequired, /** - * Callback invoked whenever the scroll offset changes within the inner scrollable region. - * This callback can be used to sync scrolling between lists, tables, or grids. - * ({ clientHeight, scrollHeight, scrollTop }): void + * Number of rows in list; can be arbitrary high number if actual number is unknown. */ - onScroll: _react.PropTypes.func.isRequired, + rowCount: _react.PropTypes.number.isRequired, /** - * Either a fixed row height (number) or a function that returns the height of a row given its index. - * ({ index: number }): number + * Threshold at which to pre-fetch data. + * A threshold X means that data will start loading when a user scrolls within X rows. + * This value defaults to 15. */ - rowHeight: _react.PropTypes.oneOfType([_react.PropTypes.number, _react.PropTypes.func]).isRequired, + threshold: _react.PropTypes.number.isRequired +}; +InfiniteLoader.defaultProps = { + minimumBatchSize: 10, + rowCount: 0, + threshold: 15 +}; +exports.default = InfiniteLoader; +function isRangeVisible(_ref2) { + var lastRenderedStartIndex = _ref2.lastRenderedStartIndex; + var lastRenderedStopIndex = _ref2.lastRenderedStopIndex; + var startIndex = _ref2.startIndex; + var stopIndex = _ref2.stopIndex; - /** Responsbile for rendering a row given an index; ({ index: number }): node */ - rowRenderer: _react.PropTypes.func.isRequired, + return !(startIndex > lastRenderedStopIndex || stopIndex < lastRenderedStartIndex); +} + +/** + * Returns all of the ranges within a larger range that contain unloaded rows. + */ +function scanForUnloadedRanges(_ref3) { + var isRowLoaded = _ref3.isRowLoaded; + var minimumBatchSize = _ref3.minimumBatchSize; + var rowCount = _ref3.rowCount; + var startIndex = _ref3.startIndex; + var stopIndex = _ref3.stopIndex; + + var unloadedRanges = []; + + var rangeStartIndex = null; + var rangeStopIndex = null; + + for (var index = startIndex; index <= stopIndex; index++) { + var loaded = isRowLoaded({ index: index }); + + if (!loaded) { + rangeStopIndex = index; + if (rangeStartIndex === null) { + rangeStartIndex = index; + } + } else if (rangeStopIndex !== null) { + unloadedRanges.push({ + startIndex: rangeStartIndex, + stopIndex: rangeStopIndex + }); - /** Optional custom CSS class for individual rows */ - rowClassName: _react.PropTypes.oneOfType([_react.PropTypes.string, _react.PropTypes.func]), + rangeStartIndex = rangeStopIndex = null; + } + } - /** Number of rows in list. */ - rowCount: _react.PropTypes.number.isRequired, + // If :rangeStopIndex is not null it means we haven't ran out of unloaded rows. + // Scan forward to try filling our :minimumBatchSize. + if (rangeStopIndex !== null) { + var potentialStopIndex = Math.min(Math.max(rangeStopIndex, rangeStartIndex + minimumBatchSize - 1), rowCount - 1); - /** Optional custom styles for individual cells */ - rowStyle: _react.PropTypes.oneOfType([_react.PropTypes.object, _react.PropTypes.func]), + for (var _index = rangeStopIndex + 1; _index <= potentialStopIndex; _index++) { + if (!isRowLoaded({ index: _index })) { + rangeStopIndex = _index; + } else { + break; + } + } - /** See Grid#scrollToAlignment */ - scrollToAlignment: _react.PropTypes.oneOf(['auto', 'end', 'start', 'center']).isRequired, + unloadedRanges.push({ + startIndex: rangeStartIndex, + stopIndex: rangeStopIndex + }); + } - /** Row index to ensure visible (by forcefully scrolling if necessary) */ - scrollToIndex: _react.PropTypes.number, + // Check to see if our first range ended prematurely. + // In this case we should scan backwards to try filling our :minimumBatchSize. + if (unloadedRanges.length) { + var firstUnloadedRange = unloadedRanges[0]; - /** Vertical offset. */ - scrollTop: _react.PropTypes.number, + while (firstUnloadedRange.stopIndex - firstUnloadedRange.startIndex + 1 < minimumBatchSize && firstUnloadedRange.startIndex > 0) { + var _index2 = firstUnloadedRange.startIndex - 1; - /** Optional inline style */ - style: _react.PropTypes.object, + if (!isRowLoaded({ index: _index2 })) { + firstUnloadedRange.startIndex = _index2; + } else { + break; + } + } + } - /** Tab index for focus */ - tabIndex: _react.PropTypes.number, + return unloadedRanges; +} - /** Width of list */ - width: _react.PropTypes.number.isRequired -}; -VirtualScroll.defaultProps = { - estimatedRowSize: 30, - noRowsRenderer: function noRowsRenderer() { - return null; - }, - onRowsRendered: function onRowsRendered() { - return null; - }, - onScroll: function onScroll() { - return null; - }, - overscanRowCount: 10, - scrollToAlignment: 'auto', - style: {} -}; -exports.default = VirtualScroll; -},{"../Grid":62,"classnames":undefined,"react":undefined,"react-addons-shallow-compare":30}],73:[function(require,module,exports){ +/** + * Since RV components use shallowCompare we need to force a render (even though props haven't changed). + * However InfiniteLoader may wrap a Grid or it may wrap a FlexTable or VirtualScroll. + * In the first case the built-in React forceUpdate() method is sufficient to force a re-render, + * But in the latter cases we need to use the RV-specific forceUpdateGrid() method. + * Else the inner Grid will not be re-rendered and visuals may be stale. + */ +function forceUpdateReactVirtualizedComponent(component) { + typeof component.forceUpdateGrid === 'function' ? component.forceUpdateGrid() : component.forceUpdate(); +} +},{"../utils/createCallbackMemoizer":76,"react":undefined,"react-addons-shallow-compare":18}],67:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); -exports.VirtualScroll = exports.default = undefined; +exports.InfiniteLoader = exports.default = undefined; -var _VirtualScroll2 = require('./VirtualScroll'); +var _InfiniteLoader2 = require('./InfiniteLoader'); -var _VirtualScroll3 = _interopRequireDefault(_VirtualScroll2); +var _InfiniteLoader3 = _interopRequireDefault(_InfiniteLoader2); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } -exports.default = _VirtualScroll3.default; -exports.VirtualScroll = _VirtualScroll3.default; -},{"./VirtualScroll":72}],74:[function(require,module,exports){ +exports.default = _InfiniteLoader3.default; +exports.InfiniteLoader = _InfiniteLoader3.default; +},{"./InfiniteLoader":66}],68:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { @@ -8788,22 +8729,10 @@ var _createClass = function () { function defineProperties(target, props) { for var _react = require('react'); -var _react2 = _interopRequireDefault(_react); - -var _reactDom = require('react-dom'); - -var _reactDom2 = _interopRequireDefault(_reactDom); - var _reactAddonsShallowCompare = require('react-addons-shallow-compare'); var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); -var _raf = require('raf'); - -var _raf2 = _interopRequireDefault(_raf); - -var _onScroll = require('./utils/onScroll'); - function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } @@ -8812,1161 +8741,1255 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -var WindowScroller = function (_Component) { - _inherits(WindowScroller, _Component); - - function WindowScroller(props) { - _classCallCheck(this, WindowScroller); +/** + * HOC that simplifies the process of synchronizing scrolling between two or more virtualized components. + */ +var ScrollSync = function (_Component) { + _inherits(ScrollSync, _Component); - var _this = _possibleConstructorReturn(this, (WindowScroller.__proto__ || Object.getPrototypeOf(WindowScroller)).call(this, props)); + function ScrollSync(props, context) { + _classCallCheck(this, ScrollSync); - var height = typeof window !== 'undefined' ? window.innerHeight : 0; + var _this = _possibleConstructorReturn(this, (ScrollSync.__proto__ || Object.getPrototypeOf(ScrollSync)).call(this, props, context)); _this.state = { - isScrolling: false, - height: height, - scrollTop: 0 + clientHeight: 0, + clientWidth: 0, + scrollHeight: 0, + scrollLeft: 0, + scrollTop: 0, + scrollWidth: 0 }; - _this._onScrollWindow = _this._onScrollWindow.bind(_this); - _this._onResizeWindow = _this._onResizeWindow.bind(_this); - _this._enablePointerEventsAfterDelayCallback = _this._enablePointerEventsAfterDelayCallback.bind(_this); + _this._onScroll = _this._onScroll.bind(_this); return _this; } - _createClass(WindowScroller, [{ - key: 'componentDidMount', - value: function componentDidMount() { - var height = this.state.height; - - // Subtract documentElement top to handle edge-case where a user is navigating back (history) from an already-scrolled bage. - // In this case the body's top position will be a negative number and this element's top will be increased (by that amount). - - this._positionFromTop = _reactDom2.default.findDOMNode(this).getBoundingClientRect().top - document.documentElement.getBoundingClientRect().top; - - if (height !== window.innerHeight) { - this.setState({ - height: window.innerHeight - }); - } - - (0, _onScroll.registerScrollListener)(this); - window.addEventListener('resize', this._onResizeWindow, false); - } - }, { - key: 'componentWillUnmount', - value: function componentWillUnmount() { - (0, _onScroll.unregisterScrollListener)(this); - - window.removeEventListener('resize', this._onResizeWindow, false); - } - - /** - * Updates the state during the next animation frame. - * Use this method to avoid multiple renders in a small span of time. - * This helps performance for bursty events (like onScroll). - */ - - }, { - key: '_setNextState', - value: function _setNextState(state) { - var _this2 = this; - - if (this._setNextStateAnimationFrameId) { - _raf2.default.cancel(this._setNextStateAnimationFrameId); - } - - this._setNextStateAnimationFrameId = (0, _raf2.default)(function () { - _this2._setNextStateAnimationFrameId = null; - _this2.setState(state); - }); - } - }, { + _createClass(ScrollSync, [{ key: 'render', value: function render() { var children = this.props.children; var _state = this.state; - var isScrolling = _state.isScrolling; + var clientHeight = _state.clientHeight; + var clientWidth = _state.clientWidth; + var scrollHeight = _state.scrollHeight; + var scrollLeft = _state.scrollLeft; var scrollTop = _state.scrollTop; - var height = _state.height; - - - return _react2.default.createElement( - 'div', - null, - children({ - height: height, - isScrolling: isScrolling, - scrollTop: scrollTop - }) - ); - } - }, { - key: 'shouldComponentUpdate', - value: function shouldComponentUpdate(nextProps, nextState) { - return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState); - } - }, { - key: '_enablePointerEventsAfterDelayCallback', - value: function _enablePointerEventsAfterDelayCallback() { - this.setState({ - isScrolling: false - }); - } - }, { - key: '_onResizeWindow', - value: function _onResizeWindow(event) { - var onResize = this.props.onResize; - - - var height = window.innerHeight || 0; - - this.setState({ height: height }); - - onResize({ height: height }); - } - }, { - key: '_onScrollWindow', - value: function _onScrollWindow(event) { - var onScroll = this.props.onScroll; - - // In IE10+ scrollY is undefined, so we replace that with the latter - - var scrollY = 'scrollY' in window ? window.scrollY : document.documentElement.scrollTop; - - var scrollTop = Math.max(0, scrollY - this._positionFromTop); + var scrollWidth = _state.scrollWidth; - var state = { - isScrolling: true, - scrollTop: scrollTop - }; - if (!this.state.isScrolling) { - this.setState(state); - } else { - this._setNextState(state); - } + return children({ + clientHeight: clientHeight, + clientWidth: clientWidth, + onScroll: this._onScroll, + scrollHeight: scrollHeight, + scrollLeft: scrollLeft, + scrollTop: scrollTop, + scrollWidth: scrollWidth + }); + } + }, { + key: 'shouldComponentUpdate', + value: function shouldComponentUpdate(nextProps, nextState) { + return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState); + } + }, { + key: '_onScroll', + value: function _onScroll(_ref) { + var clientHeight = _ref.clientHeight; + var clientWidth = _ref.clientWidth; + var scrollHeight = _ref.scrollHeight; + var scrollLeft = _ref.scrollLeft; + var scrollTop = _ref.scrollTop; + var scrollWidth = _ref.scrollWidth; - onScroll({ scrollTop: scrollTop }); + this.setState({ clientHeight: clientHeight, clientWidth: clientWidth, scrollHeight: scrollHeight, scrollLeft: scrollLeft, scrollTop: scrollTop, scrollWidth: scrollWidth }); } }]); - return WindowScroller; + return ScrollSync; }(_react.Component); -WindowScroller.propTypes = { +ScrollSync.propTypes = { /** - * Function respondible for rendering children. + * Function respondible for rendering 2 or more virtualized components. * This function should implement the following signature: - * ({ height, scrollTop }) => PropTypes.element + * ({ onScroll, scrollLeft, scrollTop }) => PropTypes.element */ - children: _react.PropTypes.func.isRequired, - - /** Callback to be invoked on-resize: ({ height }) */ - onResize: _react.PropTypes.func.isRequired, - - /** Callback to be invoked on-scroll: ({ scrollTop }) */ - onScroll: _react.PropTypes.func.isRequired -}; -WindowScroller.defaultProps = { - onResize: function onResize() {}, - onScroll: function onScroll() {} + children: _react.PropTypes.func.isRequired }; -exports.default = WindowScroller; -},{"./utils/onScroll":76,"raf":29,"react":undefined,"react-addons-shallow-compare":30,"react-dom":undefined}],75:[function(require,module,exports){ +exports.default = ScrollSync; +},{"react":undefined,"react-addons-shallow-compare":18}],69:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); -exports.IS_SCROLLING_TIMEOUT = exports.WindowScroller = exports.default = undefined; - -var _WindowScroller2 = require('./WindowScroller'); - -var _WindowScroller3 = _interopRequireDefault(_WindowScroller2); +exports.ScrollSync = exports.default = undefined; -var _onScroll = require('./utils/onScroll'); +var _ScrollSync2 = require('./ScrollSync'); -var _onScroll2 = _interopRequireDefault(_onScroll); +var _ScrollSync3 = _interopRequireDefault(_ScrollSync2); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } -exports.default = _WindowScroller3.default; -exports.WindowScroller = _WindowScroller3.default; -exports.IS_SCROLLING_TIMEOUT = _onScroll2.default; -},{"./WindowScroller":74,"./utils/onScroll":76}],76:[function(require,module,exports){ +exports.default = _ScrollSync3.default; +exports.ScrollSync = _ScrollSync3.default; +},{"./ScrollSync":68}],70:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); -exports.registerScrollListener = registerScrollListener; -exports.unregisterScrollListener = unregisterScrollListener; -var mountedInstances = []; -var originalBodyPointerEvents = null; -var disablePointerEventsTimeoutId = null; + +var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _Grid = require('../Grid'); + +var _Grid2 = _interopRequireDefault(_Grid); + +var _react = require('react'); + +var _react2 = _interopRequireDefault(_react); + +var _classnames = require('classnames'); + +var _classnames2 = _interopRequireDefault(_classnames); + +var _reactAddonsShallowCompare = require('react-addons-shallow-compare'); + +var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** - * Specifies the number of miliseconds during which to disable pointer events while a scroll is in progress. - * This improves performance and makes scrolling smoother. + * It is inefficient to create and manage a large list of DOM elements within a scrolling container + * if only a few of those elements are visible. The primary purpose of this component is to improve + * performance by only rendering the DOM nodes that a user is able to see based on their current + * scroll position. + * + * This component renders a virtualized list of elements with either fixed or dynamic heights. */ -var IS_SCROLLING_TIMEOUT = exports.IS_SCROLLING_TIMEOUT = 150; +var VirtualScroll = function (_Component) { + _inherits(VirtualScroll, _Component); -function enablePointerEventsIfDisabled() { - if (disablePointerEventsTimeoutId) { - disablePointerEventsTimeoutId = null; + function VirtualScroll(props, context) { + _classCallCheck(this, VirtualScroll); - document.body.style.pointerEvents = originalBodyPointerEvents; + var _this = _possibleConstructorReturn(this, (VirtualScroll.__proto__ || Object.getPrototypeOf(VirtualScroll)).call(this, props, context)); - originalBodyPointerEvents = null; + _this._cellRenderer = _this._cellRenderer.bind(_this); + _this._createRowClassNameGetter = _this._createRowClassNameGetter.bind(_this); + _this._createRowStyleGetter = _this._createRowStyleGetter.bind(_this); + _this._onScroll = _this._onScroll.bind(_this); + _this._onSectionRendered = _this._onSectionRendered.bind(_this); + return _this; } -} -function enablePointerEventsAfterDelayCallback() { - enablePointerEventsIfDisabled(); - mountedInstances.forEach(function (component) { - return component._enablePointerEventsAfterDelayCallback(); - }); -} + _createClass(VirtualScroll, [{ + key: 'forceUpdateGrid', + value: function forceUpdateGrid() { + this.Grid.forceUpdate(); + } -function enablePointerEventsAfterDelay() { - if (disablePointerEventsTimeoutId) { - clearTimeout(disablePointerEventsTimeoutId); - } + /** See Grid#measureAllCells */ - disablePointerEventsTimeoutId = setTimeout(enablePointerEventsAfterDelayCallback, IS_SCROLLING_TIMEOUT); -} + }, { + key: 'measureAllRows', + value: function measureAllRows() { + this.Grid.measureAllCells(); + } -function onScrollWindow(event) { - if (originalBodyPointerEvents == null) { - originalBodyPointerEvents = document.body.style.pointerEvents; + /** See Grid#recomputeGridSize */ - document.body.style.pointerEvents = 'none'; + }, { + key: 'recomputeRowHeights', + value: function recomputeRowHeights() { + var index = arguments.length <= 0 || arguments[0] === undefined ? 0 : arguments[0]; - enablePointerEventsAfterDelay(); - } - mountedInstances.forEach(function (component) { - return component._onScrollWindow(event); - }); -} + this.Grid.recomputeGridSize({ + rowIndex: index + }); + this.forceUpdateGrid(); + } + }, { + key: 'render', + value: function render() { + var _this2 = this; + + var _props = this.props; + var className = _props.className; + var noRowsRenderer = _props.noRowsRenderer; + var scrollToIndex = _props.scrollToIndex; + var width = _props.width; + + + var classNames = (0, _classnames2.default)('VirtualScroll', className); + + return _react2.default.createElement(_Grid2.default, _extends({}, this.props, { + autoContainerWidth: true, + cellRenderer: this._cellRenderer, + cellClassName: this._createRowClassNameGetter(), + cellStyle: this._createRowStyleGetter(), + className: classNames, + columnWidth: width, + columnCount: 1, + noContentRenderer: noRowsRenderer, + onScroll: this._onScroll, + onSectionRendered: this._onSectionRendered, + ref: function ref(_ref) { + _this2.Grid = _ref; + }, + scrollToRow: scrollToIndex + })); + } + }, { + key: 'shouldComponentUpdate', + value: function shouldComponentUpdate(nextProps, nextState) { + return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState); + } + }, { + key: '_cellRenderer', + value: function _cellRenderer(_ref2) { + var columnIndex = _ref2.columnIndex; + var isScrolling = _ref2.isScrolling; + var rowIndex = _ref2.rowIndex; + var rowRenderer = this.props.rowRenderer; + + + return rowRenderer({ + index: rowIndex, + isScrolling: isScrolling + }); + } + }, { + key: '_createRowClassNameGetter', + value: function _createRowClassNameGetter() { + var rowClassName = this.props.rowClassName; + + + return rowClassName instanceof Function ? function (_ref3) { + var rowIndex = _ref3.rowIndex; + return rowClassName({ index: rowIndex }); + } : function () { + return rowClassName; + }; + } + }, { + key: '_createRowStyleGetter', + value: function _createRowStyleGetter() { + var rowStyle = this.props.rowStyle; + + + var wrapped = rowStyle instanceof Function ? rowStyle : function () { + return rowStyle; + }; + + // Default width to 100% to prevent list rows from flowing under the vertical scrollbar + return function (_ref4) { + var rowIndex = _ref4.rowIndex; + return _extends({ + width: '100%' + }, wrapped({ index: rowIndex })); + }; + } + }, { + key: '_onScroll', + value: function _onScroll(_ref5) { + var clientHeight = _ref5.clientHeight; + var scrollHeight = _ref5.scrollHeight; + var scrollTop = _ref5.scrollTop; + var onScroll = this.props.onScroll; + + + onScroll({ clientHeight: clientHeight, scrollHeight: scrollHeight, scrollTop: scrollTop }); + } + }, { + key: '_onSectionRendered', + value: function _onSectionRendered(_ref6) { + var rowOverscanStartIndex = _ref6.rowOverscanStartIndex; + var rowOverscanStopIndex = _ref6.rowOverscanStopIndex; + var rowStartIndex = _ref6.rowStartIndex; + var rowStopIndex = _ref6.rowStopIndex; + var onRowsRendered = this.props.onRowsRendered; -function registerScrollListener(component) { - if (!mountedInstances.length) { - window.addEventListener('scroll', onScrollWindow); - } - mountedInstances.push(component); -} -function unregisterScrollListener(component) { - mountedInstances = mountedInstances.filter(function (c) { - return c !== component; - }); - if (!mountedInstances.length) { - window.removeEventListener('scroll', onScrollWindow); - if (disablePointerEventsTimeoutId) { - clearTimeout(disablePointerEventsTimeoutId); - enablePointerEventsIfDisabled(); + onRowsRendered({ + overscanStartIndex: rowOverscanStartIndex, + overscanStopIndex: rowOverscanStopIndex, + startIndex: rowStartIndex, + stopIndex: rowStopIndex + }); } - } -} -},{}],77:[function(require,module,exports){ -'use strict'; + }]); -Object.defineProperty(exports, "__esModule", { - value: true -}); + return VirtualScroll; +}(_react.Component); -var _ArrowKeyStepper = require('./ArrowKeyStepper'); +VirtualScroll.propTypes = { + 'aria-label': _react.PropTypes.string, -Object.defineProperty(exports, 'ArrowKeyStepper', { - enumerable: true, - get: function get() { - return _ArrowKeyStepper.ArrowKeyStepper; - } -}); + /** + * Removes fixed height from the scrollingContainer so that the total height + * of rows can stretch the window. Intended for use with WindowScroller + */ + autoHeight: _react.PropTypes.bool, -var _AutoSizer = require('./AutoSizer'); + /** Optional CSS class name */ + className: _react.PropTypes.string, -Object.defineProperty(exports, 'AutoSizer', { - enumerable: true, - get: function get() { - return _AutoSizer.AutoSizer; - } -}); + /** + * Used to estimate the total height of a VirtualScroll before all of its rows have actually been measured. + * The estimated total height is adjusted as rows are rendered. + */ + estimatedRowSize: _react.PropTypes.number.isRequired, -var _CellMeasurer = require('./CellMeasurer'); + /** Height constraint for list (determines how many actual rows are rendered) */ + height: _react.PropTypes.number.isRequired, -Object.defineProperty(exports, 'CellMeasurer', { - enumerable: true, - get: function get() { - return _CellMeasurer.CellMeasurer; - } -}); -Object.defineProperty(exports, 'defaultCellMeasurerCellSizeCache', { - enumerable: true, - get: function get() { - return _CellMeasurer.defaultCellSizeCache; - } -}); -Object.defineProperty(exports, 'uniformSizeCellMeasurerCellSizeCache', { - enumerable: true, - get: function get() { - return _CellMeasurer.defaultCellSizeCache; - } -}); + /** Optional renderer to be used in place of rows when rowCount is 0 */ + noRowsRenderer: _react.PropTypes.func.isRequired, -var _Collection = require('./Collection'); + /** + * Callback invoked with information about the slice of rows that were just rendered. + * ({ startIndex, stopIndex }): void + */ + onRowsRendered: _react.PropTypes.func.isRequired, -Object.defineProperty(exports, 'Collection', { - enumerable: true, - get: function get() { - return _Collection.Collection; - } -}); + /** + * Number of rows to render above/below the visible bounds of the list. + * These rows can help for smoother scrolling on touch devices. + */ + overscanRowCount: _react.PropTypes.number.isRequired, -var _ColumnSizer = require('./ColumnSizer'); + /** + * Callback invoked whenever the scroll offset changes within the inner scrollable region. + * This callback can be used to sync scrolling between lists, tables, or grids. + * ({ clientHeight, scrollHeight, scrollTop }): void + */ + onScroll: _react.PropTypes.func.isRequired, -Object.defineProperty(exports, 'ColumnSizer', { - enumerable: true, - get: function get() { - return _ColumnSizer.ColumnSizer; - } -}); + /** + * Either a fixed row height (number) or a function that returns the height of a row given its index. + * ({ index: number }): number + */ + rowHeight: _react.PropTypes.oneOfType([_react.PropTypes.number, _react.PropTypes.func]).isRequired, -var _FlexTable = require('./FlexTable'); + /** Responsbile for rendering a row given an index; ({ index: number }): node */ + rowRenderer: _react.PropTypes.func.isRequired, -Object.defineProperty(exports, 'defaultFlexTableCellDataGetter', { - enumerable: true, - get: function get() { - return _FlexTable.defaultCellDataGetter; - } -}); -Object.defineProperty(exports, 'defaultFlexTableCellRenderer', { - enumerable: true, - get: function get() { - return _FlexTable.defaultCellRenderer; - } -}); -Object.defineProperty(exports, 'defaultFlexTableHeaderRenderer', { - enumerable: true, - get: function get() { - return _FlexTable.defaultHeaderRenderer; - } -}); -Object.defineProperty(exports, 'defaultFlexTableRowRenderer', { - enumerable: true, - get: function get() { - return _FlexTable.defaultRowRenderer; - } -}); -Object.defineProperty(exports, 'FlexTable', { - enumerable: true, - get: function get() { - return _FlexTable.FlexTable; - } -}); -Object.defineProperty(exports, 'FlexColumn', { - enumerable: true, - get: function get() { - return _FlexTable.FlexColumn; - } -}); -Object.defineProperty(exports, 'SortDirection', { - enumerable: true, - get: function get() { - return _FlexTable.SortDirection; - } -}); -Object.defineProperty(exports, 'SortIndicator', { - enumerable: true, - get: function get() { - return _FlexTable.SortIndicator; - } -}); + /** Optional custom CSS class for individual rows */ + rowClassName: _react.PropTypes.oneOfType([_react.PropTypes.string, _react.PropTypes.func]), -var _Grid = require('./Grid'); + /** Number of rows in list. */ + rowCount: _react.PropTypes.number.isRequired, -Object.defineProperty(exports, 'defaultCellRangeRenderer', { - enumerable: true, - get: function get() { - return _Grid.defaultCellRangeRenderer; - } -}); -Object.defineProperty(exports, 'Grid', { - enumerable: true, - get: function get() { - return _Grid.Grid; - } -}); + /** Optional custom styles for individual cells */ + rowStyle: _react.PropTypes.oneOfType([_react.PropTypes.object, _react.PropTypes.func]), -var _InfiniteLoader = require('./InfiniteLoader'); + /** See Grid#scrollToAlignment */ + scrollToAlignment: _react.PropTypes.oneOf(['auto', 'end', 'start', 'center']).isRequired, -Object.defineProperty(exports, 'InfiniteLoader', { - enumerable: true, - get: function get() { - return _InfiniteLoader.InfiniteLoader; - } -}); + /** Row index to ensure visible (by forcefully scrolling if necessary) */ + scrollToIndex: _react.PropTypes.number, -var _ScrollSync = require('./ScrollSync'); + /** Vertical offset. */ + scrollTop: _react.PropTypes.number, -Object.defineProperty(exports, 'ScrollSync', { - enumerable: true, - get: function get() { - return _ScrollSync.ScrollSync; - } -}); + /** Optional inline style */ + style: _react.PropTypes.object, -var _VirtualScroll = require('./VirtualScroll'); + /** Tab index for focus */ + tabIndex: _react.PropTypes.number, -Object.defineProperty(exports, 'VirtualScroll', { - enumerable: true, - get: function get() { - return _VirtualScroll.VirtualScroll; - } + /** Width of list */ + width: _react.PropTypes.number.isRequired +}; +VirtualScroll.defaultProps = { + estimatedRowSize: 30, + noRowsRenderer: function noRowsRenderer() { + return null; + }, + onRowsRendered: function onRowsRendered() { + return null; + }, + onScroll: function onScroll() { + return null; + }, + overscanRowCount: 10, + scrollToAlignment: 'auto', + style: {} +}; +exports.default = VirtualScroll; +},{"../Grid":60,"classnames":undefined,"react":undefined,"react-addons-shallow-compare":18}],71:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true }); +exports.VirtualScroll = exports.default = undefined; -var _WindowScroller = require('./WindowScroller'); +var _VirtualScroll2 = require('./VirtualScroll'); -Object.defineProperty(exports, 'WindowScroller', { - enumerable: true, - get: function get() { - return _WindowScroller.WindowScroller; - } -}); -},{"./ArrowKeyStepper":37,"./AutoSizer":39,"./CellMeasurer":42,"./Collection":47,"./ColumnSizer":50,"./FlexTable":59,"./Grid":62,"./InfiniteLoader":69,"./ScrollSync":71,"./VirtualScroll":73,"./WindowScroller":75}],78:[function(require,module,exports){ +var _VirtualScroll3 = _interopRequireDefault(_VirtualScroll2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +exports.default = _VirtualScroll3.default; +exports.VirtualScroll = _VirtualScroll3.default; +},{"./VirtualScroll":70}],72:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); -exports.default = createCallbackMemoizer; -/** - * Helper utility that updates the specified callback whenever any of the specified indices have changed. - */ -function createCallbackMemoizer() { - var requireAllKeys = arguments.length <= 0 || arguments[0] === undefined ? true : arguments[0]; - var cachedIndices = {}; +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); - return function (_ref) { - var callback = _ref.callback; - var indices = _ref.indices; +var _react = require('react'); - var keys = Object.keys(indices); - var allInitialized = !requireAllKeys || keys.every(function (key) { - var value = indices[key]; - return Array.isArray(value) ? value.length > 0 : value >= 0; - }); - var indexChanged = keys.length !== Object.keys(cachedIndices).length || keys.some(function (key) { - var cachedValue = cachedIndices[key]; - var value = indices[key]; +var _react2 = _interopRequireDefault(_react); - return Array.isArray(value) ? cachedValue.join(',') !== value.join(',') : cachedValue !== value; - }); +var _reactDom = require('react-dom'); - cachedIndices = indices; +var _reactDom2 = _interopRequireDefault(_reactDom); - if (allInitialized && indexChanged) { - callback(indices); - } - }; -} -},{}],79:[function(require,module,exports){ -'use strict'; +var _reactAddonsShallowCompare = require('react-addons-shallow-compare'); -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = getUpdatedOffsetForIndex; -/** - * Determines a new offset that ensures a certain cell is visible, given the current offset. - * If the cell is already visible then the current offset will be returned. - * If the current offset is too great or small, it will be adjusted just enough to ensure the specified index is visible. - * - * @param align Desired alignment within container; one of "auto" (default), "start", or "end" - * @param cellOffset Offset (x or y) position for cell - * @param cellSize Size (width or height) of cell - * @param containerSize Total size (width or height) of the container - * @param currentOffset Container's current (x or y) offset - * @return Offset to use to ensure the specified cell is visible - */ -function getUpdatedOffsetForIndex(_ref) { - var _ref$align = _ref.align; - var align = _ref$align === undefined ? 'auto' : _ref$align; - var cellOffset = _ref.cellOffset; - var cellSize = _ref.cellSize; - var containerSize = _ref.containerSize; - var currentOffset = _ref.currentOffset; +var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare); - var maxOffset = cellOffset; - var minOffset = maxOffset - containerSize + cellSize; +var _raf = require('raf'); - switch (align) { - case 'start': - return maxOffset; - case 'end': - return minOffset; - case 'center': - return maxOffset - (containerSize - cellSize) / 2; - default: - return Math.max(minOffset, Math.min(maxOffset, currentOffset)); - } -} -},{}],80:[function(require,module,exports){ -'use strict'; +var _raf2 = _interopRequireDefault(_raf); -/** -* Detect Element Resize. -* Forked in order to guard against unsafe 'window' and 'document' references. -* -* https://github.com/sdecima/javascript-detect-element-resize -* Sebastian Decima -* -* version: 0.5.3 -**/ +var _onScroll = require('./utils/onScroll'); -// Check `document` and `window` in case of server-side rendering -var _window; -if (typeof window !== 'undefined') { - _window = window; -} else if (typeof self !== 'undefined') { - _window = self; -} else { - _window = undefined; -} +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } -var attachEvent = typeof document !== 'undefined' && document.attachEvent; -var stylesCreated = false; +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -if (!attachEvent) { - var requestFrame = function () { - var raf = _window.requestAnimationFrame || _window.mozRequestAnimationFrame || _window.webkitRequestAnimationFrame || function (fn) { - return _window.setTimeout(fn, 20); - }; - return function (fn) { - return raf(fn); - }; - }(); +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } - var cancelFrame = function () { - var cancel = _window.cancelAnimationFrame || _window.mozCancelAnimationFrame || _window.webkitCancelAnimationFrame || _window.clearTimeout; - return function (id) { - return cancel(id); +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var WindowScroller = function (_Component) { + _inherits(WindowScroller, _Component); + + function WindowScroller(props) { + _classCallCheck(this, WindowScroller); + + var _this = _possibleConstructorReturn(this, (WindowScroller.__proto__ || Object.getPrototypeOf(WindowScroller)).call(this, props)); + + var height = typeof window !== 'undefined' ? window.innerHeight : 0; + + _this.state = { + isScrolling: false, + height: height, + scrollTop: 0 }; - }(); - var resetTriggers = function resetTriggers(element) { - var triggers = element.__resizeTriggers__, - expand = triggers.firstElementChild, - contract = triggers.lastElementChild, - expandChild = expand.firstElementChild; - contract.scrollLeft = contract.scrollWidth; - contract.scrollTop = contract.scrollHeight; - expandChild.style.width = expand.offsetWidth + 1 + 'px'; - expandChild.style.height = expand.offsetHeight + 1 + 'px'; - expand.scrollLeft = expand.scrollWidth; - expand.scrollTop = expand.scrollHeight; - }; + _this._onScrollWindow = _this._onScrollWindow.bind(_this); + _this._onResizeWindow = _this._onResizeWindow.bind(_this); + _this._enablePointerEventsAfterDelayCallback = _this._enablePointerEventsAfterDelayCallback.bind(_this); + return _this; + } - var checkTriggers = function checkTriggers(element) { - return element.offsetWidth != element.__resizeLast__.width || element.offsetHeight != element.__resizeLast__.height; - }; + _createClass(WindowScroller, [{ + key: 'componentDidMount', + value: function componentDidMount() { + var height = this.state.height; - var scrollListener = function scrollListener(e) { - var element = this; - resetTriggers(this); - if (this.__resizeRAF__) cancelFrame(this.__resizeRAF__); - this.__resizeRAF__ = requestFrame(function () { - if (checkTriggers(element)) { - element.__resizeLast__.width = element.offsetWidth; - element.__resizeLast__.height = element.offsetHeight; - element.__resizeListeners__.forEach(function (fn) { - fn.call(element, e); + // Subtract documentElement top to handle edge-case where a user is navigating back (history) from an already-scrolled bage. + // In this case the body's top position will be a negative number and this element's top will be increased (by that amount). + + this._positionFromTop = _reactDom2.default.findDOMNode(this).getBoundingClientRect().top - document.documentElement.getBoundingClientRect().top; + + if (height !== window.innerHeight) { + this.setState({ + height: window.innerHeight }); } - }); - }; - /* Detect CSS Animations support to detect element display/re-attach */ - var animation = false, - animationstring = 'animation', - keyframeprefix = '', - animationstartevent = 'animationstart', - domPrefixes = 'Webkit Moz O ms'.split(' '), - startEvents = 'webkitAnimationStart animationstart oAnimationStart MSAnimationStart'.split(' '), - pfx = ''; - { - var elm = document.createElement('fakeelement'); - if (elm.style.animationName !== undefined) { - animation = true; + (0, _onScroll.registerScrollListener)(this); + window.addEventListener('resize', this._onResizeWindow, false); + } + }, { + key: 'componentWillUnmount', + value: function componentWillUnmount() { + (0, _onScroll.unregisterScrollListener)(this); + + window.removeEventListener('resize', this._onResizeWindow, false); + } + + /** + * Updates the state during the next animation frame. + * Use this method to avoid multiple renders in a small span of time. + * This helps performance for bursty events (like onScroll). + */ + + }, { + key: '_setNextState', + value: function _setNextState(state) { + var _this2 = this; + + if (this._setNextStateAnimationFrameId) { + _raf2.default.cancel(this._setNextStateAnimationFrameId); + } + + this._setNextStateAnimationFrameId = (0, _raf2.default)(function () { + _this2._setNextStateAnimationFrameId = null; + _this2.setState(state); + }); + } + }, { + key: 'render', + value: function render() { + var children = this.props.children; + var _state = this.state; + var isScrolling = _state.isScrolling; + var scrollTop = _state.scrollTop; + var height = _state.height; + + + return _react2.default.createElement( + 'div', + null, + children({ + height: height, + isScrolling: isScrolling, + scrollTop: scrollTop + }) + ); + } + }, { + key: 'shouldComponentUpdate', + value: function shouldComponentUpdate(nextProps, nextState) { + return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState); + } + }, { + key: '_enablePointerEventsAfterDelayCallback', + value: function _enablePointerEventsAfterDelayCallback() { + this.setState({ + isScrolling: false + }); + } + }, { + key: '_onResizeWindow', + value: function _onResizeWindow(event) { + var onResize = this.props.onResize; + + + var height = window.innerHeight || 0; + + this.setState({ height: height }); + + onResize({ height: height }); } + }, { + key: '_onScrollWindow', + value: function _onScrollWindow(event) { + var onScroll = this.props.onScroll; - if (animation === false) { - for (var i = 0; i < domPrefixes.length; i++) { - if (elm.style[domPrefixes[i] + 'AnimationName'] !== undefined) { - pfx = domPrefixes[i]; - animationstring = pfx + 'Animation'; - keyframeprefix = '-' + pfx.toLowerCase() + '-'; - animationstartevent = startEvents[i]; - animation = true; - break; - } + // In IE10+ scrollY is undefined, so we replace that with the latter + + var scrollY = 'scrollY' in window ? window.scrollY : document.documentElement.scrollTop; + + var scrollTop = Math.max(0, scrollY - this._positionFromTop); + + var state = { + isScrolling: true, + scrollTop: scrollTop + }; + + if (!this.state.isScrolling) { + this.setState(state); + } else { + this._setNextState(state); } + + onScroll({ scrollTop: scrollTop }); } - } + }]); - var animationName = 'resizeanim'; - var animationKeyframes = '@' + keyframeprefix + 'keyframes ' + animationName + ' { from { opacity: 0; } to { opacity: 0; } } '; - var animationStyle = keyframeprefix + 'animation: 1ms ' + animationName + '; '; -} + return WindowScroller; +}(_react.Component); -var createStyles = function createStyles() { - if (!stylesCreated) { - //opacity:0 works around a chrome bug https://code.google.com/p/chromium/issues/detail?id=286360 - var css = (animationKeyframes ? animationKeyframes : '') + '.resize-triggers { ' + (animationStyle ? animationStyle : '') + 'visibility: hidden; opacity: 0; } ' + '.resize-triggers, .resize-triggers > div, .contract-trigger:before { content: \" \"; display: block; position: absolute; top: 0; left: 0; height: 100%; width: 100%; overflow: hidden; } .resize-triggers > div { background: #eee; overflow: auto; } .contract-trigger:before { width: 200%; height: 200%; }', - head = document.head || document.getElementsByTagName('head')[0], - style = document.createElement('style'); +WindowScroller.propTypes = { + /** + * Function respondible for rendering children. + * This function should implement the following signature: + * ({ height, scrollTop }) => PropTypes.element + */ + children: _react.PropTypes.func.isRequired, - style.type = 'text/css'; - if (style.styleSheet) { - style.styleSheet.cssText = css; - } else { - style.appendChild(document.createTextNode(css)); - } + /** Callback to be invoked on-resize: ({ height }) */ + onResize: _react.PropTypes.func.isRequired, - head.appendChild(style); - stylesCreated = true; - } + /** Callback to be invoked on-scroll: ({ scrollTop }) */ + onScroll: _react.PropTypes.func.isRequired +}; +WindowScroller.defaultProps = { + onResize: function onResize() {}, + onScroll: function onScroll() {} }; +exports.default = WindowScroller; +},{"./utils/onScroll":74,"raf":81,"react":undefined,"react-addons-shallow-compare":18,"react-dom":undefined}],73:[function(require,module,exports){ +'use strict'; -var addResizeListener = function addResizeListener(element, fn) { - if (attachEvent) element.attachEvent('onresize', fn);else { - if (!element.__resizeTriggers__) { - if (getComputedStyle(element).position == 'static') element.style.position = 'relative'; - createStyles(); - element.__resizeLast__ = {}; - element.__resizeListeners__ = []; - (element.__resizeTriggers__ = document.createElement('div')).className = 'resize-triggers'; - element.__resizeTriggers__.innerHTML = '
' + '
'; - element.appendChild(element.__resizeTriggers__); - resetTriggers(element); - element.addEventListener('scroll', scrollListener, true); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.IS_SCROLLING_TIMEOUT = exports.WindowScroller = exports.default = undefined; - /* Listen for a css animation to detect element display/re-attach */ - animationstartevent && element.__resizeTriggers__.addEventListener(animationstartevent, function (e) { - if (e.animationName == animationName) resetTriggers(element); - }); - } - element.__resizeListeners__.push(fn); - } -}; +var _WindowScroller2 = require('./WindowScroller'); -var removeResizeListener = function removeResizeListener(element, fn) { - if (attachEvent) element.detachEvent('onresize', fn);else { - element.__resizeListeners__.splice(element.__resizeListeners__.indexOf(fn), 1); - if (!element.__resizeListeners__.length) { - element.removeEventListener('scroll', scrollListener, true); - element.__resizeTriggers__ = !element.removeChild(element.__resizeTriggers__); - } - } -}; +var _WindowScroller3 = _interopRequireDefault(_WindowScroller2); -module.exports = { - addResizeListener: addResizeListener, - removeResizeListener: removeResizeListener -}; -},{}],81:[function(require,module,exports){ -/** - * Copyright 2013-present, Facebook, Inc. - * All rights reserved. - * - * This source code is licensed under the BSD-style license found in the - * LICENSE file in the root directory of this source tree. An additional grant - * of patent rights can be found in the PATENTS file in the same directory. - * - */ +var _onScroll = require('./utils/onScroll'); + +var _onScroll2 = _interopRequireDefault(_onScroll); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } +exports.default = _WindowScroller3.default; +exports.WindowScroller = _WindowScroller3.default; +exports.IS_SCROLLING_TIMEOUT = _onScroll2.default; +},{"./WindowScroller":72,"./utils/onScroll":74}],74:[function(require,module,exports){ 'use strict'; -var shallowEqual = require('fbjs/lib/shallowEqual'); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.registerScrollListener = registerScrollListener; +exports.unregisterScrollListener = unregisterScrollListener; +var mountedInstances = []; +var originalBodyPointerEvents = null; +var disablePointerEventsTimeoutId = null; /** - * Does a shallow comparison for props and state. - * See ReactComponentWithPureRenderMixin - * See also https://facebook.github.io/react/docs/shallow-compare.html + * Specifies the number of miliseconds during which to disable pointer events while a scroll is in progress. + * This improves performance and makes scrolling smoother. */ -function shallowCompare(instance, nextProps, nextState) { - return !shallowEqual(instance.props, nextProps) || !shallowEqual(instance.state, nextState); -} +var IS_SCROLLING_TIMEOUT = exports.IS_SCROLLING_TIMEOUT = 150; -module.exports = shallowCompare; -},{"fbjs/lib/shallowEqual":20}],82:[function(require,module,exports){ -'use strict'; -module.exports = function (str) { - return encodeURIComponent(str).replace(/[!'()*]/g, function (c) { - return '%' + c.charCodeAt(0).toString(16).toUpperCase(); - }); -}; +function enablePointerEventsIfDisabled() { + if (disablePointerEventsTimeoutId) { + disablePointerEventsTimeoutId = null; -},{}],83:[function(require,module,exports){ -(function(self) { - 'use strict'; + document.body.style.pointerEvents = originalBodyPointerEvents; - if (self.fetch) { - return + originalBodyPointerEvents = null; } +} - var support = { - searchParams: 'URLSearchParams' in self, - iterable: 'Symbol' in self && 'iterator' in Symbol, - blob: 'FileReader' in self && 'Blob' in self && (function() { - try { - new Blob() - return true - } catch(e) { - return false - } - })(), - formData: 'FormData' in self, - arrayBuffer: 'ArrayBuffer' in self +function enablePointerEventsAfterDelayCallback() { + enablePointerEventsIfDisabled(); + mountedInstances.forEach(function (component) { + return component._enablePointerEventsAfterDelayCallback(); + }); +} + +function enablePointerEventsAfterDelay() { + if (disablePointerEventsTimeoutId) { + clearTimeout(disablePointerEventsTimeoutId); } - if (support.arrayBuffer) { - var viewClasses = [ - '[object Int8Array]', - '[object Uint8Array]', - '[object Uint8ClampedArray]', - '[object Int16Array]', - '[object Uint16Array]', - '[object Int32Array]', - '[object Uint32Array]', - '[object Float32Array]', - '[object Float64Array]' - ] + disablePointerEventsTimeoutId = setTimeout(enablePointerEventsAfterDelayCallback, IS_SCROLLING_TIMEOUT); +} - var isDataView = function(obj) { - return obj && DataView.prototype.isPrototypeOf(obj) - } +function onScrollWindow(event) { + if (originalBodyPointerEvents == null) { + originalBodyPointerEvents = document.body.style.pointerEvents; - var isArrayBufferView = ArrayBuffer.isView || function(obj) { - return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1 - } - } + document.body.style.pointerEvents = 'none'; - function normalizeName(name) { - if (typeof name !== 'string') { - name = String(name) - } - if (/[^a-z0-9\-#$%&'*+.\^_`|~]/i.test(name)) { - throw new TypeError('Invalid character in header field name') - } - return name.toLowerCase() + enablePointerEventsAfterDelay(); } + mountedInstances.forEach(function (component) { + return component._onScrollWindow(event); + }); +} - function normalizeValue(value) { - if (typeof value !== 'string') { - value = String(value) - } - return value +function registerScrollListener(component) { + if (!mountedInstances.length) { + window.addEventListener('scroll', onScrollWindow); } + mountedInstances.push(component); +} - // Build a destructive iterator for the value list - function iteratorFor(items) { - var iterator = { - next: function() { - var value = items.shift() - return {done: value === undefined, value: value} - } - } - - if (support.iterable) { - iterator[Symbol.iterator] = function() { - return iterator - } +function unregisterScrollListener(component) { + mountedInstances = mountedInstances.filter(function (c) { + return c !== component; + }); + if (!mountedInstances.length) { + window.removeEventListener('scroll', onScrollWindow); + if (disablePointerEventsTimeoutId) { + clearTimeout(disablePointerEventsTimeoutId); + enablePointerEventsIfDisabled(); } - - return iterator } +} +},{}],75:[function(require,module,exports){ +'use strict'; - function Headers(headers) { - this.map = {} +Object.defineProperty(exports, "__esModule", { + value: true +}); - if (headers instanceof Headers) { - headers.forEach(function(value, name) { - this.append(name, value) - }, this) +var _ArrowKeyStepper = require('./ArrowKeyStepper'); - } else if (headers) { - Object.getOwnPropertyNames(headers).forEach(function(name) { - this.append(name, headers[name]) - }, this) - } +Object.defineProperty(exports, 'ArrowKeyStepper', { + enumerable: true, + get: function get() { + return _ArrowKeyStepper.ArrowKeyStepper; } +}); - Headers.prototype.append = function(name, value) { - name = normalizeName(name) - value = normalizeValue(value) - var oldValue = this.map[name] - this.map[name] = oldValue ? oldValue+','+value : value - } +var _AutoSizer = require('./AutoSizer'); - Headers.prototype['delete'] = function(name) { - delete this.map[normalizeName(name)] +Object.defineProperty(exports, 'AutoSizer', { + enumerable: true, + get: function get() { + return _AutoSizer.AutoSizer; } +}); - Headers.prototype.get = function(name) { - name = normalizeName(name) - return this.has(name) ? this.map[name] : null - } +var _CellMeasurer = require('./CellMeasurer'); - Headers.prototype.has = function(name) { - return this.map.hasOwnProperty(normalizeName(name)) +Object.defineProperty(exports, 'CellMeasurer', { + enumerable: true, + get: function get() { + return _CellMeasurer.CellMeasurer; } - - Headers.prototype.set = function(name, value) { - this.map[normalizeName(name)] = normalizeValue(value) +}); +Object.defineProperty(exports, 'defaultCellMeasurerCellSizeCache', { + enumerable: true, + get: function get() { + return _CellMeasurer.defaultCellSizeCache; } - - Headers.prototype.forEach = function(callback, thisArg) { - for (var name in this.map) { - if (this.map.hasOwnProperty(name)) { - callback.call(thisArg, this.map[name], name, this) - } - } +}); +Object.defineProperty(exports, 'uniformSizeCellMeasurerCellSizeCache', { + enumerable: true, + get: function get() { + return _CellMeasurer.defaultCellSizeCache; } +}); - Headers.prototype.keys = function() { - var items = [] - this.forEach(function(value, name) { items.push(name) }) - return iteratorFor(items) - } +var _Collection = require('./Collection'); - Headers.prototype.values = function() { - var items = [] - this.forEach(function(value) { items.push(value) }) - return iteratorFor(items) +Object.defineProperty(exports, 'Collection', { + enumerable: true, + get: function get() { + return _Collection.Collection; } +}); - Headers.prototype.entries = function() { - var items = [] - this.forEach(function(value, name) { items.push([name, value]) }) - return iteratorFor(items) - } +var _ColumnSizer = require('./ColumnSizer'); - if (support.iterable) { - Headers.prototype[Symbol.iterator] = Headers.prototype.entries +Object.defineProperty(exports, 'ColumnSizer', { + enumerable: true, + get: function get() { + return _ColumnSizer.ColumnSizer; } +}); - function consumed(body) { - if (body.bodyUsed) { - return Promise.reject(new TypeError('Already read')) - } - body.bodyUsed = true - } +var _FlexTable = require('./FlexTable'); - function fileReaderReady(reader) { - return new Promise(function(resolve, reject) { - reader.onload = function() { - resolve(reader.result) - } - reader.onerror = function() { - reject(reader.error) - } - }) +Object.defineProperty(exports, 'defaultFlexTableCellDataGetter', { + enumerable: true, + get: function get() { + return _FlexTable.defaultCellDataGetter; + } +}); +Object.defineProperty(exports, 'defaultFlexTableCellRenderer', { + enumerable: true, + get: function get() { + return _FlexTable.defaultCellRenderer; + } +}); +Object.defineProperty(exports, 'defaultFlexTableHeaderRenderer', { + enumerable: true, + get: function get() { + return _FlexTable.defaultHeaderRenderer; + } +}); +Object.defineProperty(exports, 'defaultFlexTableRowRenderer', { + enumerable: true, + get: function get() { + return _FlexTable.defaultRowRenderer; + } +}); +Object.defineProperty(exports, 'FlexTable', { + enumerable: true, + get: function get() { + return _FlexTable.FlexTable; + } +}); +Object.defineProperty(exports, 'FlexColumn', { + enumerable: true, + get: function get() { + return _FlexTable.FlexColumn; + } +}); +Object.defineProperty(exports, 'SortDirection', { + enumerable: true, + get: function get() { + return _FlexTable.SortDirection; + } +}); +Object.defineProperty(exports, 'SortIndicator', { + enumerable: true, + get: function get() { + return _FlexTable.SortIndicator; } +}); - function readBlobAsArrayBuffer(blob) { - var reader = new FileReader() - var promise = fileReaderReady(reader) - reader.readAsArrayBuffer(blob) - return promise +var _Grid = require('./Grid'); + +Object.defineProperty(exports, 'defaultCellRangeRenderer', { + enumerable: true, + get: function get() { + return _Grid.defaultCellRangeRenderer; + } +}); +Object.defineProperty(exports, 'Grid', { + enumerable: true, + get: function get() { + return _Grid.Grid; } +}); - function readBlobAsText(blob) { - var reader = new FileReader() - var promise = fileReaderReady(reader) - reader.readAsText(blob) - return promise +var _InfiniteLoader = require('./InfiniteLoader'); + +Object.defineProperty(exports, 'InfiniteLoader', { + enumerable: true, + get: function get() { + return _InfiniteLoader.InfiniteLoader; } +}); - function readArrayBufferAsText(buf) { - var view = new Uint8Array(buf) - var chars = new Array(view.length) +var _ScrollSync = require('./ScrollSync'); - for (var i = 0; i < view.length; i++) { - chars[i] = String.fromCharCode(view[i]) - } - return chars.join('') +Object.defineProperty(exports, 'ScrollSync', { + enumerable: true, + get: function get() { + return _ScrollSync.ScrollSync; } +}); - function bufferClone(buf) { - if (buf.slice) { - return buf.slice(0) - } else { - var view = new Uint8Array(buf.byteLength) - view.set(new Uint8Array(buf)) - return view.buffer - } +var _VirtualScroll = require('./VirtualScroll'); + +Object.defineProperty(exports, 'VirtualScroll', { + enumerable: true, + get: function get() { + return _VirtualScroll.VirtualScroll; } +}); - function Body() { - this.bodyUsed = false +var _WindowScroller = require('./WindowScroller'); - this._initBody = function(body) { - this._bodyInit = body - if (!body) { - this._bodyText = '' - } else if (typeof body === 'string') { - this._bodyText = body - } else if (support.blob && Blob.prototype.isPrototypeOf(body)) { - this._bodyBlob = body - } else if (support.formData && FormData.prototype.isPrototypeOf(body)) { - this._bodyFormData = body - } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) { - this._bodyText = body.toString() - } else if (support.arrayBuffer && support.blob && isDataView(body)) { - this._bodyArrayBuffer = bufferClone(body.buffer) - // IE 10-11 can't handle a DataView body. - this._bodyInit = new Blob([this._bodyArrayBuffer]) - } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) { - this._bodyArrayBuffer = bufferClone(body) - } else { - throw new Error('unsupported BodyInit type') - } +Object.defineProperty(exports, 'WindowScroller', { + enumerable: true, + get: function get() { + return _WindowScroller.WindowScroller; + } +}); +},{"./ArrowKeyStepper":35,"./AutoSizer":37,"./CellMeasurer":40,"./Collection":45,"./ColumnSizer":48,"./FlexTable":57,"./Grid":60,"./InfiniteLoader":67,"./ScrollSync":69,"./VirtualScroll":71,"./WindowScroller":73}],76:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = createCallbackMemoizer; +/** + * Helper utility that updates the specified callback whenever any of the specified indices have changed. + */ +function createCallbackMemoizer() { + var requireAllKeys = arguments.length <= 0 || arguments[0] === undefined ? true : arguments[0]; - if (!this.headers.get('content-type')) { - if (typeof body === 'string') { - this.headers.set('content-type', 'text/plain;charset=UTF-8') - } else if (this._bodyBlob && this._bodyBlob.type) { - this.headers.set('content-type', this._bodyBlob.type) - } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) { - this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8') - } - } - } + var cachedIndices = {}; - if (support.blob) { - this.blob = function() { - var rejected = consumed(this) - if (rejected) { - return rejected - } + return function (_ref) { + var callback = _ref.callback; + var indices = _ref.indices; - if (this._bodyBlob) { - return Promise.resolve(this._bodyBlob) - } else if (this._bodyArrayBuffer) { - return Promise.resolve(new Blob([this._bodyArrayBuffer])) - } else if (this._bodyFormData) { - throw new Error('could not read FormData body as blob') - } else { - return Promise.resolve(new Blob([this._bodyText])) - } - } + var keys = Object.keys(indices); + var allInitialized = !requireAllKeys || keys.every(function (key) { + var value = indices[key]; + return Array.isArray(value) ? value.length > 0 : value >= 0; + }); + var indexChanged = keys.length !== Object.keys(cachedIndices).length || keys.some(function (key) { + var cachedValue = cachedIndices[key]; + var value = indices[key]; - this.arrayBuffer = function() { - if (this._bodyArrayBuffer) { - return consumed(this) || Promise.resolve(this._bodyArrayBuffer) - } else { - return this.blob().then(readBlobAsArrayBuffer) - } - } - } + return Array.isArray(value) ? cachedValue.join(',') !== value.join(',') : cachedValue !== value; + }); - this.text = function() { - var rejected = consumed(this) - if (rejected) { - return rejected - } + cachedIndices = indices; - if (this._bodyBlob) { - return readBlobAsText(this._bodyBlob) - } else if (this._bodyArrayBuffer) { - return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer)) - } else if (this._bodyFormData) { - throw new Error('could not read FormData body as text') - } else { - return Promise.resolve(this._bodyText) - } + if (allInitialized && indexChanged) { + callback(indices); } + }; +} +},{}],77:[function(require,module,exports){ +'use strict'; - if (support.formData) { - this.formData = function() { - return this.text().then(decode) - } - } +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = getUpdatedOffsetForIndex; +/** + * Determines a new offset that ensures a certain cell is visible, given the current offset. + * If the cell is already visible then the current offset will be returned. + * If the current offset is too great or small, it will be adjusted just enough to ensure the specified index is visible. + * + * @param align Desired alignment within container; one of "auto" (default), "start", or "end" + * @param cellOffset Offset (x or y) position for cell + * @param cellSize Size (width or height) of cell + * @param containerSize Total size (width or height) of the container + * @param currentOffset Container's current (x or y) offset + * @return Offset to use to ensure the specified cell is visible + */ +function getUpdatedOffsetForIndex(_ref) { + var _ref$align = _ref.align; + var align = _ref$align === undefined ? 'auto' : _ref$align; + var cellOffset = _ref.cellOffset; + var cellSize = _ref.cellSize; + var containerSize = _ref.containerSize; + var currentOffset = _ref.currentOffset; - this.json = function() { - return this.text().then(JSON.parse) - } + var maxOffset = cellOffset; + var minOffset = maxOffset - containerSize + cellSize; - return this + switch (align) { + case 'start': + return maxOffset; + case 'end': + return minOffset; + case 'center': + return maxOffset - (containerSize - cellSize) / 2; + default: + return Math.max(minOffset, Math.min(maxOffset, currentOffset)); } +} +},{}],78:[function(require,module,exports){ +'use strict'; - // HTTP methods whose capitalization should be normalized - var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'] +/** +* Detect Element Resize. +* Forked in order to guard against unsafe 'window' and 'document' references. +* +* https://github.com/sdecima/javascript-detect-element-resize +* Sebastian Decima +* +* version: 0.5.3 +**/ - function normalizeMethod(method) { - var upcased = method.toUpperCase() - return (methods.indexOf(upcased) > -1) ? upcased : method - } +// Check `document` and `window` in case of server-side rendering +var _window; +if (typeof window !== 'undefined') { + _window = window; +} else if (typeof self !== 'undefined') { + _window = self; +} else { + _window = undefined; +} - function Request(input, options) { - options = options || {} - var body = options.body +var attachEvent = typeof document !== 'undefined' && document.attachEvent; +var stylesCreated = false; - if (input instanceof Request) { - if (input.bodyUsed) { - throw new TypeError('Already read') - } - this.url = input.url - this.credentials = input.credentials - if (!options.headers) { - this.headers = new Headers(input.headers) - } - this.method = input.method - this.mode = input.mode - if (!body && input._bodyInit != null) { - body = input._bodyInit - input.bodyUsed = true - } - } else { - this.url = String(input) - } +if (!attachEvent) { + var requestFrame = function () { + var raf = _window.requestAnimationFrame || _window.mozRequestAnimationFrame || _window.webkitRequestAnimationFrame || function (fn) { + return _window.setTimeout(fn, 20); + }; + return function (fn) { + return raf(fn); + }; + }(); - this.credentials = options.credentials || this.credentials || 'omit' - if (options.headers || !this.headers) { - this.headers = new Headers(options.headers) - } - this.method = normalizeMethod(options.method || this.method || 'GET') - this.mode = options.mode || this.mode || null - this.referrer = null + var cancelFrame = function () { + var cancel = _window.cancelAnimationFrame || _window.mozCancelAnimationFrame || _window.webkitCancelAnimationFrame || _window.clearTimeout; + return function (id) { + return cancel(id); + }; + }(); - if ((this.method === 'GET' || this.method === 'HEAD') && body) { - throw new TypeError('Body not allowed for GET or HEAD requests') - } - this._initBody(body) - } + var resetTriggers = function resetTriggers(element) { + var triggers = element.__resizeTriggers__, + expand = triggers.firstElementChild, + contract = triggers.lastElementChild, + expandChild = expand.firstElementChild; + contract.scrollLeft = contract.scrollWidth; + contract.scrollTop = contract.scrollHeight; + expandChild.style.width = expand.offsetWidth + 1 + 'px'; + expandChild.style.height = expand.offsetHeight + 1 + 'px'; + expand.scrollLeft = expand.scrollWidth; + expand.scrollTop = expand.scrollHeight; + }; - Request.prototype.clone = function() { - return new Request(this, { body: this._bodyInit }) - } + var checkTriggers = function checkTriggers(element) { + return element.offsetWidth != element.__resizeLast__.width || element.offsetHeight != element.__resizeLast__.height; + }; - function decode(body) { - var form = new FormData() - body.trim().split('&').forEach(function(bytes) { - if (bytes) { - var split = bytes.split('=') - var name = split.shift().replace(/\+/g, ' ') - var value = split.join('=').replace(/\+/g, ' ') - form.append(decodeURIComponent(name), decodeURIComponent(value)) + var scrollListener = function scrollListener(e) { + var element = this; + resetTriggers(this); + if (this.__resizeRAF__) cancelFrame(this.__resizeRAF__); + this.__resizeRAF__ = requestFrame(function () { + if (checkTriggers(element)) { + element.__resizeLast__.width = element.offsetWidth; + element.__resizeLast__.height = element.offsetHeight; + element.__resizeListeners__.forEach(function (fn) { + fn.call(element, e); + }); + } + }); + }; + + /* Detect CSS Animations support to detect element display/re-attach */ + var animation = false, + animationstring = 'animation', + keyframeprefix = '', + animationstartevent = 'animationstart', + domPrefixes = 'Webkit Moz O ms'.split(' '), + startEvents = 'webkitAnimationStart animationstart oAnimationStart MSAnimationStart'.split(' '), + pfx = ''; + { + var elm = document.createElement('fakeelement'); + if (elm.style.animationName !== undefined) { + animation = true; + } + + if (animation === false) { + for (var i = 0; i < domPrefixes.length; i++) { + if (elm.style[domPrefixes[i] + 'AnimationName'] !== undefined) { + pfx = domPrefixes[i]; + animationstring = pfx + 'Animation'; + keyframeprefix = '-' + pfx.toLowerCase() + '-'; + animationstartevent = startEvents[i]; + animation = true; + break; + } } - }) - return form + } } - function parseHeaders(rawHeaders) { - var headers = new Headers() - rawHeaders.split(/\r?\n/).forEach(function(line) { - var parts = line.split(':') - var key = parts.shift().trim() - if (key) { - var value = parts.join(':').trim() - headers.append(key, value) - } - }) - return headers - } + var animationName = 'resizeanim'; + var animationKeyframes = '@' + keyframeprefix + 'keyframes ' + animationName + ' { from { opacity: 0; } to { opacity: 0; } } '; + var animationStyle = keyframeprefix + 'animation: 1ms ' + animationName + '; '; +} - Body.call(Request.prototype) +var createStyles = function createStyles() { + if (!stylesCreated) { + //opacity:0 works around a chrome bug https://code.google.com/p/chromium/issues/detail?id=286360 + var css = (animationKeyframes ? animationKeyframes : '') + '.resize-triggers { ' + (animationStyle ? animationStyle : '') + 'visibility: hidden; opacity: 0; } ' + '.resize-triggers, .resize-triggers > div, .contract-trigger:before { content: \" \"; display: block; position: absolute; top: 0; left: 0; height: 100%; width: 100%; overflow: hidden; } .resize-triggers > div { background: #eee; overflow: auto; } .contract-trigger:before { width: 200%; height: 200%; }', + head = document.head || document.getElementsByTagName('head')[0], + style = document.createElement('style'); - function Response(bodyInit, options) { - if (!options) { - options = {} + style.type = 'text/css'; + if (style.styleSheet) { + style.styleSheet.cssText = css; + } else { + style.appendChild(document.createTextNode(css)); } - this.type = 'default' - this.status = 'status' in options ? options.status : 200 - this.ok = this.status >= 200 && this.status < 300 - this.statusText = 'statusText' in options ? options.statusText : 'OK' - this.headers = new Headers(options.headers) - this.url = options.url || '' - this._initBody(bodyInit) + head.appendChild(style); + stylesCreated = true; } +}; - Body.call(Response.prototype) +var addResizeListener = function addResizeListener(element, fn) { + if (attachEvent) element.attachEvent('onresize', fn);else { + if (!element.__resizeTriggers__) { + if (getComputedStyle(element).position == 'static') element.style.position = 'relative'; + createStyles(); + element.__resizeLast__ = {}; + element.__resizeListeners__ = []; + (element.__resizeTriggers__ = document.createElement('div')).className = 'resize-triggers'; + element.__resizeTriggers__.innerHTML = '
' + '
'; + element.appendChild(element.__resizeTriggers__); + resetTriggers(element); + element.addEventListener('scroll', scrollListener, true); - Response.prototype.clone = function() { - return new Response(this._bodyInit, { - status: this.status, - statusText: this.statusText, - headers: new Headers(this.headers), - url: this.url - }) + /* Listen for a css animation to detect element display/re-attach */ + animationstartevent && element.__resizeTriggers__.addEventListener(animationstartevent, function (e) { + if (e.animationName == animationName) resetTriggers(element); + }); + } + element.__resizeListeners__.push(fn); } +}; - Response.error = function() { - var response = new Response(null, {status: 0, statusText: ''}) - response.type = 'error' - return response +var removeResizeListener = function removeResizeListener(element, fn) { + if (attachEvent) element.detachEvent('onresize', fn);else { + element.__resizeListeners__.splice(element.__resizeListeners__.indexOf(fn), 1); + if (!element.__resizeListeners__.length) { + element.removeEventListener('scroll', scrollListener, true); + element.__resizeTriggers__ = !element.removeChild(element.__resizeTriggers__); + } } +}; - var redirectStatuses = [301, 302, 303, 307, 308] +module.exports = { + addResizeListener: addResizeListener, + removeResizeListener: removeResizeListener +}; +},{}],79:[function(require,module,exports){ +'use strict'; +module.exports = !!(typeof window !== 'undefined' && window.document && window.document.createElement); +},{}],80:[function(require,module,exports){ +'use strict'; - Response.redirect = function(url, status) { - if (redirectStatuses.indexOf(status) === -1) { - throw new RangeError('Invalid status code') - } +var canUseDOM = require('./inDOM'); - return new Response(null, {status: status, headers: {location: url}}) +var size; + +module.exports = function (recalc) { + if (!size || recalc) { + if (canUseDOM) { + var scrollDiv = document.createElement('div'); + + scrollDiv.style.position = 'absolute'; + scrollDiv.style.top = '-9999px'; + scrollDiv.style.width = '50px'; + scrollDiv.style.height = '50px'; + scrollDiv.style.overflow = 'scroll'; + + document.body.appendChild(scrollDiv); + size = scrollDiv.offsetWidth - scrollDiv.clientWidth; + document.body.removeChild(scrollDiv); + } } - self.Headers = Headers - self.Request = Request - self.Response = Response + return size; +}; +},{"./inDOM":79}],81:[function(require,module,exports){ +(function (global){ +var now = require('performance-now') + , root = typeof window === 'undefined' ? global : window + , vendors = ['moz', 'webkit'] + , suffix = 'AnimationFrame' + , raf = root['request' + suffix] + , caf = root['cancel' + suffix] || root['cancelRequest' + suffix] - self.fetch = function(input, init) { - return new Promise(function(resolve, reject) { - var request = new Request(input, init) - var xhr = new XMLHttpRequest() +for(var i = 0; !raf && i < vendors.length; i++) { + raf = root[vendors[i] + 'Request' + suffix] + caf = root[vendors[i] + 'Cancel' + suffix] + || root[vendors[i] + 'CancelRequest' + suffix] +} - xhr.onload = function() { - var options = { - status: xhr.status, - statusText: xhr.statusText, - headers: parseHeaders(xhr.getAllResponseHeaders() || '') +// Some versions of FF have rAF but not cAF +if(!raf || !caf) { + var last = 0 + , id = 0 + , queue = [] + , frameDuration = 1000 / 60 + + raf = function(callback) { + if(queue.length === 0) { + var _now = now() + , next = Math.max(0, frameDuration - (_now - last)) + last = next + _now + setTimeout(function() { + var cp = queue.slice(0) + // Clear queue here to prevent + // callbacks from appending listeners + // to the current frame's queue + queue.length = 0 + for(var i = 0; i < cp.length; i++) { + if(!cp[i].cancelled) { + try{ + cp[i].callback(last) + } catch(e) { + setTimeout(function() { throw e }, 0) + } + } } - options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL') - var body = 'response' in xhr ? xhr.response : xhr.responseText - resolve(new Response(body, options)) - } + }, Math.round(next)) + } + queue.push({ + handle: ++id, + callback: callback, + cancelled: false + }) + return id + } - xhr.onerror = function() { - reject(new TypeError('Network request failed')) + caf = function(handle) { + for(var i = 0; i < queue.length; i++) { + if(queue[i].handle === handle) { + queue[i].cancelled = true } + } + } +} - xhr.ontimeout = function() { - reject(new TypeError('Network request failed')) - } +module.exports = function(fn) { + // Wrap in a new function to prevent + // `cancel` potentially being assigned + // to the native rAF function + return raf.call(root, fn) +} +module.exports.cancel = function() { + caf.apply(root, arguments) +} +module.exports.polyfill = function() { + root.requestAnimationFrame = raf + root.cancelAnimationFrame = caf +} - xhr.open(request.method, request.url, true) +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) - if (request.credentials === 'include') { - xhr.withCredentials = true - } +},{"performance-now":82}],82:[function(require,module,exports){ +(function (process){ +// Generated by CoffeeScript 1.12.2 +(function() { + var getNanoSeconds, hrtime, loadTime, moduleLoadTime, nodeLoadTime, upTime; - if ('responseType' in xhr && support.blob) { - xhr.responseType = 'blob' - } + if ((typeof performance !== "undefined" && performance !== null) && performance.now) { + module.exports = function() { + return performance.now(); + }; + } else if ((typeof process !== "undefined" && process !== null) && process.hrtime) { + module.exports = function() { + return (getNanoSeconds() - nodeLoadTime) / 1e6; + }; + hrtime = process.hrtime; + getNanoSeconds = function() { + var hr; + hr = hrtime(); + return hr[0] * 1e9 + hr[1]; + }; + moduleLoadTime = getNanoSeconds(); + upTime = process.uptime() * 1e9; + nodeLoadTime = moduleLoadTime - upTime; + } else if (Date.now) { + module.exports = function() { + return Date.now() - loadTime; + }; + loadTime = Date.now(); + } else { + module.exports = function() { + return new Date().getTime() - loadTime; + }; + loadTime = new Date().getTime(); + } - request.headers.forEach(function(value, name) { - xhr.setRequestHeader(name, value) - }) +}).call(this); - xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit) - }) - } - self.fetch.polyfill = true -})(typeof self !== 'undefined' ? self : this); -},{}]},{},[1]); + +}).call(this,require('_process')) + +},{"_process":20}]},{},[1]) +//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["node_modules/react-component-gulp-tasks/node_modules/browserify/node_modules/browser-pack/_prelude.js","/Users/serkanozer/projects/react-select/examples/src/app.js","/Users/serkanozer/projects/react-select/examples/src/components/BooleanSelect.js","/Users/serkanozer/projects/react-select/examples/src/components/Contributors.js","/Users/serkanozer/projects/react-select/examples/src/components/Creatable.js","/Users/serkanozer/projects/react-select/examples/src/components/CustomComponents.js","/Users/serkanozer/projects/react-select/examples/src/components/CustomRender.js","/Users/serkanozer/projects/react-select/examples/src/components/GithubUsers.js","/Users/serkanozer/projects/react-select/examples/src/components/Multiselect.js","/Users/serkanozer/projects/react-select/examples/src/components/NumericSelect.js","/Users/serkanozer/projects/react-select/examples/src/components/States.js","/Users/serkanozer/projects/react-select/examples/src/components/Virtualized.js","/Users/serkanozer/projects/react-select/examples/src/data/cities.js","/Users/serkanozer/projects/react-select/examples/src/data/contributors.js","/Users/serkanozer/projects/react-select/examples/src/data/states.js","/Users/serkanozer/projects/react-select/examples/src/data/users.js","node_modules/isomorphic-fetch/fetch-npm-browserify.js","node_modules/isomorphic-fetch/node_modules/whatwg-fetch/fetch.js","node_modules/react-addons-shallow-compare/index.js","node_modules/react-addons-shallow-compare/node_modules/fbjs/lib/shallowEqual.js","node_modules/react-component-gulp-tasks/node_modules/browserify/node_modules/process/browser.js","node_modules/react-gravatar/dist/index.js","node_modules/react-gravatar/node_modules/is-retina/index.js","node_modules/react-gravatar/node_modules/md5/md5.js","node_modules/react-gravatar/node_modules/md5/node_modules/charenc/charenc.js","node_modules/react-gravatar/node_modules/md5/node_modules/crypt/crypt.js","node_modules/react-gravatar/node_modules/md5/node_modules/is-buffer/index.js","node_modules/react-gravatar/node_modules/query-string/index.js","node_modules/react-gravatar/node_modules/query-string/node_modules/object-assign/index.js","node_modules/react-gravatar/node_modules/query-string/node_modules/strict-uri-encode/index.js","node_modules/react-highlight-words/dist/main.js","node_modules/react-virtualized-select/dist/commonjs/VirtualizedSelect/VirtualizedSelect.js","node_modules/react-virtualized-select/dist/commonjs/VirtualizedSelect/index.js","node_modules/react-virtualized/dist/commonjs/ArrowKeyStepper/ArrowKeyStepper.js","node_modules/react-virtualized/dist/commonjs/ArrowKeyStepper/index.js","node_modules/react-virtualized/dist/commonjs/AutoSizer/AutoSizer.js","node_modules/react-virtualized/dist/commonjs/AutoSizer/index.js","node_modules/react-virtualized/dist/commonjs/CellMeasurer/CellMeasurer.js","node_modules/react-virtualized/dist/commonjs/CellMeasurer/defaultCellSizeCache.js","node_modules/react-virtualized/dist/commonjs/CellMeasurer/index.js","node_modules/react-virtualized/dist/commonjs/Collection/Collection.js","node_modules/react-virtualized/dist/commonjs/Collection/CollectionView.js","node_modules/react-virtualized/dist/commonjs/Collection/Section.js","node_modules/react-virtualized/dist/commonjs/Collection/SectionManager.js","node_modules/react-virtualized/dist/commonjs/Collection/index.js","node_modules/react-virtualized/dist/commonjs/Collection/utils/calculateSizeAndPositionData.js","node_modules/react-virtualized/dist/commonjs/ColumnSizer/ColumnSizer.js","node_modules/react-virtualized/dist/commonjs/ColumnSizer/index.js","node_modules/react-virtualized/dist/commonjs/FlexTable/FlexColumn.js","node_modules/react-virtualized/dist/commonjs/FlexTable/FlexTable.js","node_modules/react-virtualized/dist/commonjs/FlexTable/SortDirection.js","node_modules/react-virtualized/dist/commonjs/FlexTable/SortIndicator.js","node_modules/react-virtualized/dist/commonjs/FlexTable/defaultCellDataGetter.js","node_modules/react-virtualized/dist/commonjs/FlexTable/defaultCellRenderer.js","node_modules/react-virtualized/dist/commonjs/FlexTable/defaultHeaderRenderer.js","node_modules/react-virtualized/dist/commonjs/FlexTable/defaultRowRenderer.js","node_modules/react-virtualized/dist/commonjs/FlexTable/index.js","node_modules/react-virtualized/dist/commonjs/Grid/Grid.js","node_modules/react-virtualized/dist/commonjs/Grid/defaultCellRangeRenderer.js","node_modules/react-virtualized/dist/commonjs/Grid/index.js","node_modules/react-virtualized/dist/commonjs/Grid/utils/CellSizeAndPositionManager.js","node_modules/react-virtualized/dist/commonjs/Grid/utils/ScalingCellSizeAndPositionManager.js","node_modules/react-virtualized/dist/commonjs/Grid/utils/calculateSizeAndPositionDataAndUpdateScrollOffset.js","node_modules/react-virtualized/dist/commonjs/Grid/utils/getOverscanIndices.js","node_modules/react-virtualized/dist/commonjs/Grid/utils/updateScrollIndexHelper.js","node_modules/react-virtualized/dist/commonjs/InfiniteLoader/InfiniteLoader.js","node_modules/react-virtualized/dist/commonjs/InfiniteLoader/index.js","node_modules/react-virtualized/dist/commonjs/ScrollSync/ScrollSync.js","node_modules/react-virtualized/dist/commonjs/ScrollSync/index.js","node_modules/react-virtualized/dist/commonjs/VirtualScroll/VirtualScroll.js","node_modules/react-virtualized/dist/commonjs/VirtualScroll/index.js","node_modules/react-virtualized/dist/commonjs/WindowScroller/WindowScroller.js","node_modules/react-virtualized/dist/commonjs/WindowScroller/index.js","node_modules/react-virtualized/dist/commonjs/WindowScroller/utils/onScroll.js","node_modules/react-virtualized/dist/commonjs/index.js","node_modules/react-virtualized/dist/commonjs/utils/createCallbackMemoizer.js","node_modules/react-virtualized/dist/commonjs/utils/getUpdatedOffsetForIndex.js","node_modules/react-virtualized/dist/commonjs/vendor/detectElementResize.js","node_modules/react-virtualized/node_modules/dom-helpers/util/inDOM.js","node_modules/react-virtualized/node_modules/dom-helpers/util/scrollbarSize.js","node_modules/react-virtualized/node_modules/raf/index.js","node_modules/react-virtualized/node_modules/raf/node_modules/performance-now/lib/performance-now.js"],"names":[],"mappings":"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CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7cA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7MA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1FA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/QA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5KA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChUA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClqBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1JA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChhCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxSA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7RA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpSA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjKA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;ACxEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/* eslint react/prop-types: 0 */\n\nimport React from 'react';\nimport ReactDOM from 'react-dom';\nimport Select from 'react-select';\n\nimport Creatable from './components/Creatable';\nimport Contributors from './components/Contributors';\nimport GithubUsers from './components/GithubUsers';\nimport CustomComponents from './components/CustomComponents';\nimport CustomRender from './components/CustomRender';\nimport Multiselect from './components/Multiselect';\nimport NumericSelect from './components/NumericSelect';\nimport BooleanSelect from './components/BooleanSelect';\nimport Virtualized from './components/Virtualized';\nimport States from './components/States';\n\nReactDOM.render(\n\t<div>\n\t\t<States label=\"States\" searchable />\n\t\t<Multiselect label=\"Multiselect\" />\n\t\t<Virtualized label=\"Virtualized\" />\n\t\t<Contributors label=\"Contributors (Async)\" />\n\t\t<GithubUsers label=\"Github users (Async with fetch.js)\" />\n\t\t<NumericSelect label=\"Numeric Values\" />\n\t\t<BooleanSelect label=\"Boolean Values\" />\n\t\t<CustomRender label=\"Custom Render Methods\"/>\n\t\t<CustomComponents label=\"Custom Placeholder, Option, Value, and Arrow Components\" />\n\t\t<Creatable\n\t\t\thint=\"Enter a value that's NOT in the list, then hit return\"\n\t\t\tlabel=\"Custom tag creation\"\n\t\t/>\n\t</div>,\n\tdocument.getElementById('example')\n);\n","import React from 'react';\nimport createClass from 'create-react-class';\nimport PropTypes from 'prop-types';\nimport Select from 'react-select';\n\nvar ValuesAsBooleansField = createClass({\n\tdisplayName: 'ValuesAsBooleansField',\n\tpropTypes: {\n\t\tlabel: PropTypes.string\n\t},\n\tgetInitialState () {\n\t\treturn {\n\t\t\toptions: [\n\t\t\t\t{ value: true, label: 'Yes' },\n\t\t\t\t{ value: false, label: 'No' }\n\t\t\t],\n\t\t\tvalue: null\n\t\t};\n\t},\n\tonChange(value) {\n\t\tthis.setState({ value });\n\t\tconsole.log('Boolean Select value changed to', value);\n\t},\n\trender () {\n\t\treturn (\n\t\t\t<div className=\"section\">\n\t\t\t\t<h3 className=\"section-heading\">{this.props.label}</h3>\n\t\t\t\t<Select\n\t\t\t\t\tonChange={this.onChange}\n\t\t\t\t\toptions={this.state.options}\n\t\t\t\t\tsimpleValue\n\t\t\t\t\tvalue={this.state.value}\n\t\t\t\t\t/>\n\t\t\t\t<div className=\"hint\">This example uses simple boolean values</div>\n\t\t\t</div>\n\t\t);\n\t}\n});\n\nmodule.exports = ValuesAsBooleansField;\n","import React from 'react';\nimport createClass from 'create-react-class';\nimport PropTypes from 'prop-types';\nimport Select from 'react-select';\n\nconst CONTRIBUTORS = require('../data/contributors');\nconst MAX_CONTRIBUTORS = 6;\nconst ASYNC_DELAY = 500;\n\nconst Contributors = createClass({\n\tdisplayName: 'Contributors',\n\tpropTypes: {\n\t\tlabel: PropTypes.string,\n\t},\n\tgetInitialState () {\n\t\treturn {\n\t\t\tmulti: true,\n\t\t\tvalue: [CONTRIBUTORS[0]],\n\t\t};\n\t},\n\tonChange (value) {\n\t\tthis.setState({\n\t\t\tvalue: value,\n\t\t});\n\t},\n\tswitchToMulti () {\n\t\tthis.setState({\n\t\t\tmulti: true,\n\t\t\tvalue: [this.state.value],\n\t\t});\n\t},\n\tswitchToSingle () {\n\t\tthis.setState({\n\t\t\tmulti: false,\n\t\t\tvalue: this.state.value[0],\n\t\t});\n\t},\n\tgetContributors (input, callback) {\n\t\tinput = input.toLowerCase();\n\t\tvar options = CONTRIBUTORS.filter(i => {\n\t\t\treturn i.github.substr(0, input.length) === input;\n\t\t});\n\t\tvar data = {\n\t\t\toptions: options.slice(0, MAX_CONTRIBUTORS),\n\t\t\tcomplete: options.length <= MAX_CONTRIBUTORS,\n\t\t};\n\t\tsetTimeout(function() {\n\t\t\tcallback(null, data);\n\t\t}, ASYNC_DELAY);\n\t},\n\tgotoContributor (value, event) {\n\t\twindow.open('https://github.com/' + value.github);\n\t},\n\trender () {\n\t\treturn (\n\t\t\t<div className=\"section\">\n\t\t\t\t<h3 className=\"section-heading\">{this.props.label}</h3>\n\t\t\t\t<Select.Async multi={this.state.multi} value={this.state.value} onChange={this.onChange} onValueClick={this.gotoContributor} valueKey=\"github\" labelKey=\"name\" loadOptions={this.getContributors} />\n\t\t\t\t<div className=\"checkbox-list\">\n\t\t\t\t\t<label className=\"checkbox\">\n\t\t\t\t\t\t<input type=\"radio\" className=\"checkbox-control\" checked={this.state.multi} onChange={this.switchToMulti}/>\n\t\t\t\t\t\t<span className=\"checkbox-label\">Multiselect</span>\n\t\t\t\t\t</label>\n\t\t\t\t\t<label className=\"checkbox\">\n\t\t\t\t\t\t<input type=\"radio\" className=\"checkbox-control\" checked={!this.state.multi} onChange={this.switchToSingle}/>\n\t\t\t\t\t\t<span className=\"checkbox-label\">Single Value</span>\n\t\t\t\t\t</label>\n\t\t\t\t</div>\n\t\t\t\t<div className=\"hint\">This example implements custom label and value properties, async options and opens the github profiles in a new window when values are clicked</div>\n\t\t\t</div>\n\t\t);\n\t}\n});\n\nmodule.exports = Contributors;\n","import React from 'react';\nimport createClass from 'create-react-class';\nimport PropTypes from 'prop-types';\nimport Select from 'react-select';\n\nvar CreatableDemo = createClass({\n\tdisplayName: 'CreatableDemo',\n\tpropTypes: {\n\t\thint: PropTypes.string,\n\t\tlabel: PropTypes.string\n\t},\n\tgetInitialState () {\n\t\treturn {\n\t\t\tmulti: true,\n\t\t\tmultiValue: [],\n\t\t\toptions: [\n\t\t\t\t{ value: 'R', label: 'Red' },\n\t\t\t\t{ value: 'G', label: 'Green' },\n\t\t\t\t{ value: 'B', label: 'Blue' }\n\t\t\t],\n\t\t\tvalue: undefined\n\t\t};\n\t},\n\thandleOnChange (value) {\n\t\tconst { multi } = this.state;\n\t\tif (multi) {\n\t\t\tthis.setState({ multiValue: value });\n\t\t} else {\n\t\t\tthis.setState({ value });\n\t\t}\n\t},\n\trender () {\n\t\tconst { multi, multiValue, options, value } = this.state;\n\t\treturn (\n\t\t\t<div className=\"section\">\n\t\t\t\t<h3 className=\"section-heading\">{this.props.label}</h3>\n\t\t\t\t<Select.Creatable\n\t\t\t\t\tmulti={multi}\n\t\t\t\t\toptions={options}\n\t\t\t\t\tonChange={this.handleOnChange}\n\t\t\t\t\tvalue={multi ? multiValue : value}\n\t\t\t\t/>\n\t\t\t\t<div className=\"hint\">{this.props.hint}</div>\n\t\t\t\t<div className=\"checkbox-list\">\n\t\t\t\t\t<label className=\"checkbox\">\n\t\t\t\t\t\t<input\n\t\t\t\t\t\t\ttype=\"radio\"\n\t\t\t\t\t\t\tclassName=\"checkbox-control\"\n\t\t\t\t\t\t\tchecked={multi}\n\t\t\t\t\t\t\tonChange={() => this.setState({ multi: true })}\n\t\t\t\t\t\t/>\n\t\t\t\t\t\t<span className=\"checkbox-label\">Multiselect</span>\n\t\t\t\t\t</label>\n\t\t\t\t\t<label className=\"checkbox\">\n\t\t\t\t\t\t<input\n\t\t\t\t\t\t\ttype=\"radio\"\n\t\t\t\t\t\t\tclassName=\"checkbox-control\"\n\t\t\t\t\t\t\tchecked={!multi}\n\t\t\t\t\t\t\tonChange={() => this.setState({ multi: false })}\n\t\t\t\t\t\t/>\n\t\t\t\t\t\t<span className=\"checkbox-label\">Single Value</span>\n\t\t\t\t\t</label>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t);\n\t}\n});\n\nmodule.exports = CreatableDemo;\n","import React from 'react';\nimport createClass from 'create-react-class';\nimport PropTypes from 'prop-types';\nimport Select from 'react-select';\nimport Gravatar from 'react-gravatar';\n\nconst USERS = require('../data/users');\nconst GRAVATAR_SIZE = 15;\n\nconst GravatarOption = createClass({\n\tpropTypes: {\n\t\tchildren: PropTypes.node,\n\t\tclassName: PropTypes.string,\n\t\tisDisabled: PropTypes.bool,\n\t\tisFocused: PropTypes.bool,\n\t\tisSelected: PropTypes.bool,\n\t\tonFocus: PropTypes.func,\n\t\tonSelect: PropTypes.func,\n\t\toption: PropTypes.object.isRequired,\n\t},\n\thandleMouseDown (event) {\n\t\tevent.preventDefault();\n\t\tevent.stopPropagation();\n\t\tthis.props.onSelect(this.props.option, event);\n\t},\n\thandleMouseEnter (event) {\n\t\tthis.props.onFocus(this.props.option, event);\n\t},\n\thandleMouseMove (event) {\n\t\tif (this.props.isFocused) return;\n\t\tthis.props.onFocus(this.props.option, event);\n\t},\n\trender () {\n\t\tlet gravatarStyle = {\n\t\t\tborderRadius: 3,\n\t\t\tdisplay: 'inline-block',\n\t\t\tmarginRight: 10,\n\t\t\tposition: 'relative',\n\t\t\ttop: -2,\n\t\t\tverticalAlign: 'middle',\n\t\t};\n\t\treturn (\n\t\t\t<div className={this.props.className}\n\t\t\t\tonMouseDown={this.handleMouseDown}\n\t\t\t\tonMouseEnter={this.handleMouseEnter}\n\t\t\t\tonMouseMove={this.handleMouseMove}\n\t\t\t\ttitle={this.props.option.title}>\n\t\t\t\t<Gravatar email={this.props.option.email} size={GRAVATAR_SIZE} style={gravatarStyle} />\n\t\t\t\t{this.props.children}\n\t\t\t</div>\n\t\t);\n\t}\n});\n\nconst GravatarValue = createClass({\n\tpropTypes: {\n\t\tchildren: PropTypes.node,\n\t\tplaceholder: PropTypes.string,\n\t\tvalue: PropTypes.object\n\t},\n\trender () {\n\t\tvar gravatarStyle = {\n\t\t\tborderRadius: 3,\n\t\t\tdisplay: 'inline-block',\n\t\t\tmarginRight: 10,\n\t\t\tposition: 'relative',\n\t\t\ttop: -2,\n\t\t\tverticalAlign: 'middle',\n\t\t};\n\t\treturn (\n\t\t\t<div className=\"Select-value\" title={this.props.value.title}>\n\t\t\t\t<span className=\"Select-value-label\">\n\t\t\t\t\t<Gravatar email={this.props.value.email} size={GRAVATAR_SIZE} style={gravatarStyle} />\n\t\t\t\t\t{this.props.children}\n\t\t\t\t</span>\n\t\t\t</div>\n\t\t);\n\t}\n});\n\nconst UsersField = createClass({\n\tpropTypes: {\n\t\thint: PropTypes.string,\n\t\tlabel: PropTypes.string,\n\t},\n\tgetInitialState () {\n\t\treturn {};\n\t},\n\tsetValue (value) {\n\t\tthis.setState({ value });\n\t},\n\trender () {\n\t\tvar placeholder = <span>&#9786; Select User</span>;\n\n\t\treturn (\n\t\t\t<div className=\"section\">\n\t\t\t\t<h3 className=\"section-heading\">{this.props.label}</h3>\n\t\t\t\t<Select\n\t\t\t\t\tarrowRenderer={arrowRenderer}\n\t\t\t\t\tonChange={this.setValue}\n\t\t\t\t\toptionComponent={GravatarOption}\n\t\t\t\t\toptions={USERS}\n\t\t\t\t\tplaceholder={placeholder}\n\t\t\t\t\tvalue={this.state.value}\n\t\t\t\t\tvalueComponent={GravatarValue}\n\t\t\t\t\t/>\n\t\t\t\t<div className=\"hint\">\n\t\t\t\t\tThis example implements custom Option and Value components to render a Gravatar image for each user based on their email.\n\t\t\t\t\tIt also demonstrates rendering HTML elements as the placeholder.\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t);\n\t}\n});\n\nfunction arrowRenderer () {\n\treturn (\n\t\t<span>+</span>\n\t);\n}\n\nmodule.exports = UsersField;\n","import React from 'react';\nimport createClass from 'create-react-class';\nimport PropTypes from 'prop-types';\nimport Select from 'react-select';\nimport Highlighter from 'react-highlight-words';\n\nvar DisabledUpsellOptions = createClass({\n\tdisplayName: 'DisabledUpsellOptions',\n\tpropTypes: {\n\t\tlabel: PropTypes.string,\n\t},\n\tgetInitialState () {\n\t\treturn {};\n\t},\n\tsetValue (value) {\n\t\tthis.setState({ value });\n\t\tif (value) {\n\t\t\tconsole.log('Support level selected:', value.label);\n\t\t}\n\t},\n\trenderLink: function() {\n\t\treturn <a style={{ marginLeft: 5 }} href=\"/upgrade\" target=\"_blank\">Upgrade here!</a>;\n\t},\n\trenderOption: function(option) {\n\t\treturn (\n\t\t\t<Highlighter\n\t\t\t  searchWords={[this._inputValue]}\n\t\t\t  textToHighlight={option.label}\n\t\t\t/>\n\t\t);\n\t},\n\trenderValue: function(option) {\n\t\treturn <strong style={{ color: option.color }}>{option.label}</strong>;\n\t},\n\trender: function() {\n\t\tvar options = [\n\t\t\t{ label: 'Basic customer support', value: 'basic', color: '#E31864' },\n\t\t\t{ label: 'Premium customer support', value: 'premium', color: '#6216A3' },\n\t\t\t{ label: 'Pro customer support', value: 'pro', disabled: true, link: this.renderLink() },\n\t\t];\n\t\treturn (\n\t\t\t<div className=\"section\">\n\t\t\t\t<h3 className=\"section-heading\">{this.props.label}</h3>\n\t\t\t\t<Select\n\t\t\t\t\tonInputChange={(inputValue) => this._inputValue = inputValue}\n\t\t\t\t\toptions={options}\n\t\t\t\t\toptionRenderer={this.renderOption}\n\t\t\t\t\tonChange={this.setValue}\n\t\t\t\t\tvalue={this.state.value}\n\t\t\t\t\tvalueRenderer={this.renderValue}\n\t\t\t\t\t/>\n\t\t\t\t<div className=\"hint\">This demonstates custom render methods and links in disabled options</div>\n\t\t\t</div>\n\t\t);\n\t}\n});\nmodule.exports = DisabledUpsellOptions;\n","import React from 'react';\nimport createClass from 'create-react-class';\nimport PropTypes from 'prop-types';\nimport Select from 'react-select';\nimport fetch from 'isomorphic-fetch';\n\n\nconst GithubUsers = createClass({\n\tdisplayName: 'GithubUsers',\n\tpropTypes: {\n\t\tlabel: PropTypes.string,\n\t},\n\tgetInitialState () {\n\t\treturn {\n\t\t\tbackspaceRemoves: true,\n\t\t\tmulti: true\n\t\t};\n\t},\n\tonChange (value) {\n\t\tthis.setState({\n\t\t\tvalue: value,\n\t\t});\n\t},\n\tswitchToMulti () {\n\t\tthis.setState({\n\t\t\tmulti: true,\n\t\t\tvalue: [this.state.value],\n\t\t});\n\t},\n\tswitchToSingle () {\n\t\tthis.setState({\n\t\t\tmulti: false,\n\t\t\tvalue: this.state.value ? this.state.value[0] : null\n\t\t});\n\t},\n\tgetUsers (input) {\n\t\tif (!input) {\n\t\t\treturn Promise.resolve({ options: [] });\n\t\t}\n\n\t\treturn fetch(`https://api.github.com/search/users?q=${input}`)\n\t\t.then((response) => response.json())\n\t\t.then((json) => {\n\t\t\treturn { options: json.items };\n\t\t});\n\t},\n\tgotoUser (value, event) {\n\t\twindow.open(value.html_url);\n\t},\n\ttoggleBackspaceRemoves () {\n\t\tthis.setState({\n\t\t\tbackspaceRemoves: !this.state.backspaceRemoves\n\t\t});\n\t},\n\ttoggleCreatable () {\n\t\tthis.setState({\n\t\t\tcreatable: !this.state.creatable\n\t\t});\n\t},\n\trender () {\n\t\tconst AsyncComponent = this.state.creatable\n\t\t\t? Select.AsyncCreatable\n\t\t\t: Select.Async;\n\n\t\treturn (\n\t\t\t<div className=\"section\">\n\t\t\t\t<h3 className=\"section-heading\">{this.props.label}</h3>\n\t\t\t\t<AsyncComponent multi={this.state.multi} value={this.state.value} onChange={this.onChange} onValueClick={this.gotoUser} valueKey=\"id\" labelKey=\"login\" loadOptions={this.getUsers} backspaceRemoves={this.state.backspaceRemoves} />\n\t\t\t\t<div className=\"checkbox-list\">\n\t\t\t\t\t<label className=\"checkbox\">\n\t\t\t\t\t\t<input type=\"radio\" className=\"checkbox-control\" checked={this.state.multi} onChange={this.switchToMulti}/>\n\t\t\t\t\t\t<span className=\"checkbox-label\">Multiselect</span>\n\t\t\t\t\t</label>\n\t\t\t\t\t<label className=\"checkbox\">\n\t\t\t\t\t\t<input type=\"radio\" className=\"checkbox-control\" checked={!this.state.multi} onChange={this.switchToSingle}/>\n\t\t\t\t\t\t<span className=\"checkbox-label\">Single Value</span>\n\t\t\t\t\t</label>\n\t\t\t\t</div>\n\t\t\t\t<div className=\"checkbox-list\">\n\t\t\t\t\t<label className=\"checkbox\">\n\t\t\t\t\t   <input type=\"checkbox\" className=\"checkbox-control\" checked={this.state.creatable} onChange={this.toggleCreatable} />\n\t\t\t\t\t   <span className=\"checkbox-label\">Creatable?</span>\n\t\t\t\t\t</label>\n\t\t\t\t\t<label className=\"checkbox\">\n\t\t\t\t\t   <input type=\"checkbox\" className=\"checkbox-control\" checked={this.state.backspaceRemoves} onChange={this.toggleBackspaceRemoves} />\n\t\t\t\t\t   <span className=\"checkbox-label\">Backspace Removes?</span>\n\t\t\t\t\t</label>\n\t\t\t\t</div>\n\t\t\t\t<div className=\"hint\">This example uses fetch.js for showing Async options with Promises</div>\n\t\t\t</div>\n\t\t);\n\t}\n});\n\nmodule.exports = GithubUsers;\n","import React from 'react';\nimport createClass from 'create-react-class';\nimport PropTypes from 'prop-types';\nimport Select from 'react-select';\n\nconst FLAVOURS = [\n\t{ label: 'Chocolate', value: 'chocolate' },\n\t{ label: 'Vanilla', value: 'vanilla' },\n\t{ label: 'Strawberry', value: 'strawberry' },\n\t{ label: 'Caramel', value: 'caramel' },\n\t{ label: 'Cookies and Cream', value: 'cookiescream' },\n\t{ label: 'Peppermint', value: 'peppermint' },\n];\n\nconst WHY_WOULD_YOU = [\n\t{ label: 'Chocolate (are you crazy?)', value: 'chocolate', disabled: true },\n].concat(FLAVOURS.slice(1));\n\nvar MultiSelectField = createClass({\n\tdisplayName: 'MultiSelectField',\n\tpropTypes: {\n\t\tlabel: PropTypes.string,\n\t},\n\tgetInitialState () {\n\t\treturn {\n\t\t\tdisabled: false,\n\t\t\tcrazy: false,\n\t\t\toptions: FLAVOURS,\n\t\t\tvalue: [],\n\t\t};\n\t},\n\thandleSelectChange (value) {\n\t\tconsole.log('You\\'ve selected:', value);\n\t\tthis.setState({ value });\n\t},\n\ttoggleDisabled (e) {\n\t\tthis.setState({ disabled: e.target.checked });\n\t},\n\ttoggleChocolate (e) {\n\t\tlet crazy = e.target.checked;\n\t\tthis.setState({\n\t\t\tcrazy: crazy,\n\t\t\toptions: crazy ? WHY_WOULD_YOU : FLAVOURS,\n\t\t});\n\t},\n\trender () {\n\t\treturn (\n\t\t\t<div className=\"section\">\n\t\t\t\t<h3 className=\"section-heading\">{this.props.label}</h3>\n\t\t\t\t<Select multi simpleValue disabled={this.state.disabled} value={this.state.value} placeholder=\"Select your favourite(s)\" options={this.state.options} onChange={this.handleSelectChange} />\n\n\t\t\t\t<div className=\"checkbox-list\">\n\t\t\t\t\t<label className=\"checkbox\">\n\t\t\t\t\t\t<input type=\"checkbox\" className=\"checkbox-control\" checked={this.state.disabled} onChange={this.toggleDisabled} />\n\t\t\t\t\t\t<span className=\"checkbox-label\">Disable the control</span>\n\t\t\t\t\t</label>\n\t\t\t\t\t<label className=\"checkbox\">\n\t\t\t\t\t\t<input type=\"checkbox\" className=\"checkbox-control\" checked={this.state.crazy} onChange={this.toggleChocolate} />\n\t\t\t\t\t\t<span className=\"checkbox-label\">I don't like Chocolate (disabled the option)</span>\n\t\t\t\t\t</label>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t);\n\t}\n});\n\nmodule.exports = MultiSelectField;\n","import React from 'react';\nimport createClass from 'create-react-class';\nimport PropTypes from 'prop-types';\nimport Select from 'react-select';\n\nvar ValuesAsNumbersField = createClass({\n\tdisplayName: 'ValuesAsNumbersField',\n\tpropTypes: {\n\t\tlabel: PropTypes.string\n\t},\n\tgetInitialState () {\n\t\treturn {\n\t\t\toptions: [\n\t\t\t\t{ value: 10, label: 'Ten' },\n\t\t\t\t{ value: 11, label: 'Eleven' },\n\t\t\t\t{ value: 12, label: 'Twelve' },\n\t\t\t\t{ value: 23, label: 'Twenty-three' },\n\t\t\t\t{ value: 24, label: 'Twenty-four' }\n\t\t\t],\n\t\t\tmatchPos: 'any',\n\t\t\tmatchValue: true,\n\t\t\tmatchLabel: true,\n\t\t\tvalue: null,\n\t\t\tmulti: false\n\t\t};\n\t},\n\tonChangeMatchStart(event) {\n\t\tthis.setState({\n\t\t\tmatchPos: event.target.checked ? 'start' : 'any'\n\t\t});\n\t},\n\tonChangeMatchValue(event) {\n\t\tthis.setState({\n\t\t\tmatchValue: event.target.checked\n\t\t});\n\t},\n\tonChangeMatchLabel(event) {\n\t\tthis.setState({\n\t\t\tmatchLabel: event.target.checked\n\t\t});\n\t},\n\tonChange(value) {\n\t\tthis.setState({ value });\n\t\tconsole.log('Numeric Select value changed to', value);\n\t},\n\tonChangeMulti(event) {\n\t\tthis.setState({\n\t\t\tmulti: event.target.checked\n\t\t});\n\t},\n\trender () {\n\t\tvar matchProp = 'any';\n\t\tif (this.state.matchLabel && !this.state.matchValue) {\n\t\t\tmatchProp = 'label';\n\t\t}\n\t\tif (!this.state.matchLabel && this.state.matchValue) {\n\t\t\tmatchProp = 'value';\n\t\t}\n\t\treturn (\n\t\t\t<div className=\"section\">\n\t\t\t\t<h3 className=\"section-heading\">{this.props.label}</h3>\n\t\t\t\t<Select\n\t\t\t\t\tmatchPos={this.state.matchPos}\n\t\t\t\t\tmatchProp={matchProp}\n\t\t\t\t\tmulti={this.state.multi}\n\t\t\t\t\tonChange={this.onChange}\n\t\t\t\t\toptions={this.state.options}\n\t\t\t\t\tsimpleValue\n\t\t\t\t\tvalue={this.state.value}\n\t\t\t\t\t/>\n\t\t\t\t<div className=\"checkbox-list\">\n\t\t\t\t\t<label className=\"checkbox\">\n\t\t\t\t\t\t<input type=\"checkbox\" className=\"checkbox-control\" checked={this.state.multi} onChange={this.onChangeMulti} />\n\t\t\t\t\t\t<span className=\"checkbox-label\">Multi-Select</span>\n\t\t\t\t\t</label>\n\t\t\t\t\t<label className=\"checkbox\">\n\t\t\t\t\t\t<input type=\"checkbox\" className=\"checkbox-control\" checked={this.state.matchValue} onChange={this.onChangeMatchValue} />\n\t\t\t\t\t\t<span className=\"checkbox-label\">Match value</span>\n\t\t\t\t\t</label>\n\t\t\t\t\t<label className=\"checkbox\">\n\t\t\t\t\t\t<input type=\"checkbox\" className=\"checkbox-control\" checked={this.state.matchLabel} onChange={this.onChangeMatchLabel} />\n\t\t\t\t\t\t<span className=\"checkbox-label\">Match label</span>\n\t\t\t\t\t</label>\n\t\t\t\t\t<label className=\"checkbox\">\n\t\t\t\t\t\t<input type=\"checkbox\" className=\"checkbox-control\" checked={this.state.matchPos === 'start'} onChange={this.onChangeMatchStart} />\n\t\t\t\t\t\t<span className=\"checkbox-label\">Only include matches from the start of the string</span>\n\t\t\t\t\t</label>\n\t\t\t\t</div>\n\t\t\t\t<div className=\"hint\">This example uses simple numeric values</div>\n\t\t\t</div>\n\t\t);\n\t}\n});\n\nmodule.exports = ValuesAsNumbersField;\n","import React from 'react';\nimport createClass from 'create-react-class';\nimport PropTypes from 'prop-types';\nimport Select from 'react-select';\n\nconst STATES = require('../data/states');\n\nvar StatesField = createClass({\n\tdisplayName: 'StatesField',\n\tpropTypes: {\n\t\tlabel: PropTypes.string,\n\t\tsearchable: PropTypes.bool,\n\t},\n\tgetDefaultProps () {\n\t\treturn {\n\t\t\tlabel: 'States:',\n\t\t\tsearchable: true,\n\t\t};\n\t},\n\tgetInitialState () {\n\t\treturn {\n\t\t\tcountry: 'AU',\n\t\t\tdisabled: false,\n\t\t\tsearchable: this.props.searchable,\n\t\t\tselectValue: 'new-south-wales',\n\t\t\tclearable: true,\n\t\t};\n\t},\n\tswitchCountry (e) {\n\t\tvar newCountry = e.target.value;\n\t\tconsole.log('Country changed to ' + newCountry);\n\t\tthis.setState({\n\t\t\tcountry: newCountry,\n\t\t\tselectValue: null\n\t\t});\n\t},\n\tupdateValue (newValue) {\n\t\tconsole.log('State changed to ' + newValue);\n\t\tthis.setState({\n\t\t\tselectValue: newValue\n\t\t});\n\t},\n\tfocusStateSelect () {\n\t\tthis.refs.stateSelect.focus();\n\t},\n\ttoggleCheckbox (e) {\n\t\tlet newState = {};\n\t\tnewState[e.target.name] = e.target.checked;\n\t\tthis.setState(newState);\n\t},\n\trender () {\n\t\tvar options = STATES[this.state.country];\n\t\treturn (\n\t\t\t<div className=\"section\">\n\t\t\t\t<h3 className=\"section-heading\">{this.props.label}</h3>\n\t\t\t\t<Select ref=\"stateSelect\" autofocus options={options} simpleValue clearable={this.state.clearable} name=\"selected-state\" disabled={this.state.disabled} value={this.state.selectValue} onChange={this.updateValue} searchable={this.state.searchable} />\n\n\t\t\t\t<div style={{ marginTop: 14 }}>\n\t\t\t\t\t<button type=\"button\" onClick={this.focusStateSelect}>Focus Select</button>\n\t\t\t\t\t<label className=\"checkbox\" style={{ marginLeft: 10 }}>\n\t\t\t\t\t\t<input type=\"checkbox\" className=\"checkbox-control\" name=\"searchable\" checked={this.state.searchable} onChange={this.toggleCheckbox}/>\n\t\t\t\t\t\t<span className=\"checkbox-label\">Searchable</span>\n\t\t\t\t\t</label>\n\t\t\t\t\t<label className=\"checkbox\" style={{ marginLeft: 10 }}>\n\t\t\t\t\t\t<input type=\"checkbox\" className=\"checkbox-control\" name=\"disabled\" checked={this.state.disabled} onChange={this.toggleCheckbox}/>\n\t\t\t\t\t\t<span className=\"checkbox-label\">Disabled</span>\n\t\t\t\t\t</label>\n\t\t\t\t\t<label className=\"checkbox\" style={{ marginLeft: 10 }}>\n\t\t\t\t\t\t<input type=\"checkbox\" className=\"checkbox-control\" name=\"clearable\" checked={this.state.clearable} onChange={this.toggleCheckbox}/>\n\t\t\t\t\t\t<span className=\"checkbox-label\">Clearable</span>\n\t\t\t\t\t</label>\n\t\t\t\t</div>\n\t\t\t\t<div className=\"checkbox-list\">\n\t\t\t\t\t<label className=\"checkbox\">\n\t\t\t\t\t\t<input type=\"radio\" className=\"checkbox-control\" checked={this.state.country === 'AU'} value=\"AU\" onChange={this.switchCountry}/>\n\t\t\t\t\t\t<span className=\"checkbox-label\">Australia</span>\n\t\t\t\t\t</label>\n\t\t\t\t\t<label className=\"checkbox\">\n\t\t\t\t\t\t<input type=\"radio\" className=\"checkbox-control\" checked={this.state.country === 'US'} value=\"US\" onChange={this.switchCountry}/>\n\t\t\t\t\t\t<span className=\"checkbox-label\">United States</span>\n\t\t\t\t\t</label>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t);\n\t}\n});\n\n\nmodule.exports = StatesField;\n","import React from 'react';\nimport createClass from 'create-react-class';\nimport VirtualizedSelect from 'react-virtualized-select';\n\nconst DATA = require('../data/cities');\n\nvar CitiesField = createClass({\n\tdisplayName: 'CitiesField',\n\tgetInitialState () {\n\t\treturn {};\n\t},\n\tupdateValue (newValue) {\n\t\tthis.setState({\n\t\t\tselectValue: newValue\n\t\t});\n\t},\n\trender () {\n\t\tvar options = DATA.CITIES;\n\t\treturn (\n\t\t\t<div className=\"section\">\n\t\t\t\t<h3 className=\"section-heading\">Cities (Large Dataset)</h3>\n\t\t\t\t<VirtualizedSelect ref=\"citySelect\"\n\t\t\t\t\toptions={options}\n\t\t\t\t\tsimpleValue\n\t\t\t\t\tclearable\n\t\t\t\t\tname=\"select-city\"\n\t\t\t\t\tvalue={this.state.selectValue}\n\t\t\t\t\tonChange={this.updateValue}\n\t\t\t\t\tsearchable\n\t\t\t\t\tlabelKey=\"name\"\n\t\t\t\t\tvalueKey=\"name\"\n\t\t\t\t/>\n\t\t\t\t<div className=\"hint\">\n\t\t\t\t\tUses <a href=\"https://github.com/bvaughn/react-virtualized\">react-virtualized</a> and <a href=\"https://github.com/bvaughn/react-virtualized-select/\">react-virtualized-select</a> to display a list of the world's 1,000 largest cities.\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t);\n\t}\n});\n\n\nmodule.exports = CitiesField;\n","exports.CITIES = [\n  { name: 'Abilene' },\n  { name: 'Addison' },\n  { name: 'Akron' },\n  { name: 'Alameda' },\n  { name: 'Albany' },\n  { name: 'Albany' },\n  { name: 'Albany' },\n  { name: 'Albuquerque' },\n  { name: 'Alexandria' },\n  { name: 'Alexandria' },\n  { name: 'Alhambra' },\n  { name: 'Aliso Viejo' },\n  { name: 'Allen' },\n  { name: 'Allentown' },\n  { name: 'Alpharetta' },\n  { name: 'Altamonte Springs' },\n  { name: 'Altoona' },\n  { name: 'Amarillo' },\n  { name: 'Ames' },\n  { name: 'Anaheim' },\n  { name: 'Anchorage' },\n  { name: 'Anderson' },\n  { name: 'Ankeny' },\n  { name: 'Ann Arbor' },\n  { name: 'Annapolis' },\n  { name: 'Antioch' },\n  { name: 'Apache Junction' },\n  { name: 'Apex' },\n  { name: 'Apopka' },\n  { name: 'Apple Valley' },\n  { name: 'Apple Valley' },\n  { name: 'Appleton' },\n  { name: 'Arcadia' },\n  { name: 'Arlington' },\n  { name: 'Arlington Heights' },\n  { name: 'Arvada' },\n  { name: 'Asheville' },\n  { name: 'Athens-Clarke County' },\n  { name: 'Atlanta' },\n  { name: 'Atlantic City' },\n  { name: 'Attleboro' },\n  { name: 'Auburn' },\n  { name: 'Auburn' },\n  { name: 'Augusta-Richmond County' },\n  { name: 'Aurora' },\n  { name: 'Aurora' },\n  { name: 'Austin' },\n  { name: 'Aventura' },\n  { name: 'Avondale' },\n  { name: 'Azusa' },\n  { name: 'Bakersfield' },\n  { name: 'Baldwin Park' },\n  { name: 'Baltimore' },\n  { name: 'Barnstable Town' },\n  { name: 'Bartlett' },\n  { name: 'Bartlett' },\n  { name: 'Baton Rouge' },\n  { name: 'Battle Creek' },\n  { name: 'Bayonne' },\n  { name: 'Baytown' },\n  { name: 'Beaumont' },\n  { name: 'Beaumont' },\n  { name: 'Beavercreek' },\n  { name: 'Beaverton' },\n  { name: 'Bedford' },\n  { name: 'Bell Gardens' },\n  { name: 'Belleville' },\n  { name: 'Bellevue' },\n  { name: 'Bellevue' },\n  { name: 'Bellflower' },\n  { name: 'Bellingham' },\n  { name: 'Beloit' },\n  { name: 'Bend' },\n  { name: 'Bentonville' },\n  { name: 'Berkeley' },\n  { name: 'Berwyn' },\n  { name: 'Bethlehem' },\n  { name: 'Beverly' },\n  { name: 'Billings' },\n  { name: 'Biloxi' },\n  { name: 'Binghamton' },\n  { name: 'Birmingham' },\n  { name: 'Bismarck' },\n  { name: 'Blacksburg' },\n  { name: 'Blaine' },\n  { name: 'Bloomington' },\n  { name: 'Bloomington' },\n  { name: 'Bloomington' },\n  { name: 'Blue Springs' },\n  { name: 'Boca Raton' },\n  { name: 'Boise City' },\n  { name: 'Bolingbrook' },\n  { name: 'Bonita Springs' },\n  { name: 'Bossier City' },\n  { name: 'Boston' },\n  { name: 'Boulder' },\n  { name: 'Bountiful' },\n  { name: 'Bowie' },\n  { name: 'Bowling Green' },\n  { name: 'Boynton Beach' },\n  { name: 'Bozeman' },\n  { name: 'Bradenton' },\n  { name: 'Brea' },\n  { name: 'Bremerton' },\n  { name: 'Brentwood' },\n  { name: 'Brentwood' },\n  { name: 'Bridgeport' },\n  { name: 'Bristol' },\n  { name: 'Brockton' },\n  { name: 'Broken Arrow' },\n  { name: 'Brookfield' },\n  { name: 'Brookhaven' },\n  { name: 'Brooklyn Park' },\n  { name: 'Broomfield' },\n  { name: 'Brownsville' },\n  { name: 'Bryan' },\n  { name: 'Buckeye' },\n  { name: 'Buena Park' },\n  { name: 'Buffalo' },\n  { name: 'Buffalo Grove' },\n  { name: 'Bullhead City' },\n  { name: 'Burbank' },\n  { name: 'Burien' },\n  { name: 'Burleson' },\n  { name: 'Burlington' },\n  { name: 'Burlington' },\n  { name: 'Burnsville' },\n  { name: 'Caldwell' },\n  { name: 'Calexico' },\n  { name: 'Calumet City' },\n  { name: 'Camarillo' },\n  { name: 'Cambridge' },\n  { name: 'Camden' },\n  { name: 'Campbell' },\n  { name: 'Canton' },\n  { name: 'Cape Coral' },\n  { name: 'Cape Girardeau' },\n  { name: 'Carlsbad' },\n  { name: 'Carmel' },\n  { name: 'Carol Stream' },\n  { name: 'Carpentersville' },\n  { name: 'Carrollton' },\n  { name: 'Carson' },\n  { name: 'Carson City' },\n  { name: 'Cary' },\n  { name: 'Casa Grande' },\n  { name: 'Casper' },\n  { name: 'Castle Rock' },\n  { name: 'Cathedral City' },\n  { name: 'Cedar Falls' },\n  { name: 'Cedar Hill' },\n  { name: 'Cedar Park' },\n  { name: 'Cedar Rapids' },\n  { name: 'Centennial' },\n  { name: 'Ceres' },\n  { name: 'Cerritos' },\n  { name: 'Champaign' },\n  { name: 'Chandler' },\n  { name: 'Chapel Hill' },\n  { name: 'Charleston' },\n  { name: 'Charleston' },\n  { name: 'Charlotte' },\n  { name: 'Charlottesville' },\n  { name: 'Chattanooga' },\n  { name: 'Chelsea' },\n  { name: 'Chesapeake' },\n  { name: 'Chesterfield' },\n  { name: 'Cheyenne' },\n  { name: 'Chicago' },\n  { name: 'Chico' },\n  { name: 'Chicopee' },\n  { name: 'Chino' },\n  { name: 'Chino Hills' },\n  { name: 'Chula Vista' },\n  { name: 'Cicero' },\n  { name: 'Cincinnati' },\n  { name: 'Citrus Heights' },\n  { name: 'Clarksville' },\n  { name: 'Clearwater' },\n  { name: 'Cleveland' },\n  { name: 'Cleveland' },\n  { name: 'Cleveland Heights' },\n  { name: 'Clifton' },\n  { name: 'Clovis' },\n  { name: 'Clovis' },\n  { name: 'Coachella' },\n  { name: 'Coconut Creek' },\n  { name: 'Coeur d\\'Alene' },\n  { name: 'College Station' },\n  { name: 'Collierville' },\n  { name: 'Colorado Springs' },\n  { name: 'Colton' },\n  { name: 'Columbia' },\n  { name: 'Columbia' },\n  { name: 'Columbus' },\n  { name: 'Columbus' },\n  { name: 'Columbus' },\n  { name: 'Commerce City' },\n  { name: 'Compton' },\n  { name: 'Concord' },\n  { name: 'Concord' },\n  { name: 'Concord' },\n  { name: 'Conroe' },\n  { name: 'Conway' },\n  { name: 'Coon Rapids' },\n  { name: 'Coppell' },\n  { name: 'Coral Gables' },\n  { name: 'Coral Springs' },\n  { name: 'Corona' },\n  { name: 'Corpus Christi' },\n  { name: 'Corvallis' },\n  { name: 'Costa Mesa' },\n  { name: 'Council Bluffs' },\n  { name: 'Covina' },\n  { name: 'Covington' },\n  { name: 'Cranston' },\n  { name: 'Crystal Lake' },\n  { name: 'Culver City' },\n  { name: 'Cupertino' },\n  { name: 'Cutler Bay' },\n  { name: 'Cuyahoga Falls' },\n  { name: 'Cypress' },\n  { name: 'Dallas' },\n  { name: 'Daly City' },\n  { name: 'Danbury' },\n  { name: 'Danville' },\n  { name: 'Danville' },\n  { name: 'Davenport' },\n  { name: 'Davie' },\n  { name: 'Davis' },\n  { name: 'Dayton' },\n  { name: 'Daytona Beach' },\n  { name: 'DeKalb' },\n  { name: 'DeSoto' },\n  { name: 'Dearborn' },\n  { name: 'Dearborn Heights' },\n  { name: 'Decatur' },\n  { name: 'Decatur' },\n  { name: 'Deerfield Beach' },\n  { name: 'Delano' },\n  { name: 'Delray Beach' },\n  { name: 'Deltona' },\n  { name: 'Denton' },\n  { name: 'Denver' },\n  { name: 'Des Moines' },\n  { name: 'Des Plaines' },\n  { name: 'Detroit' },\n  { name: 'Diamond Bar' },\n  { name: 'Doral' },\n  { name: 'Dothan' },\n  { name: 'Dover' },\n  { name: 'Downers Grove' },\n  { name: 'Downey' },\n  { name: 'Draper' },\n  { name: 'Dublin' },\n  { name: 'Dublin' },\n  { name: 'Dubuque' },\n  { name: 'Duluth' },\n  { name: 'Duncanville' },\n  { name: 'Dunwoody' },\n  { name: 'Durham' },\n  { name: 'Eagan' },\n  { name: 'East Lansing' },\n  { name: 'East Orange' },\n  { name: 'East Providence' },\n  { name: 'Eastvale' },\n  { name: 'Eau Claire' },\n  { name: 'Eden Prairie' },\n  { name: 'Edina' },\n  { name: 'Edinburg' },\n  { name: 'Edmond' },\n  { name: 'Edmonds' },\n  { name: 'El Cajon' },\n  { name: 'El Centro' },\n  { name: 'El Monte' },\n  { name: 'El Paso' },\n  { name: 'Elgin' },\n  { name: 'Elizabeth' },\n  { name: 'Elk Grove' },\n  { name: 'Elkhart' },\n  { name: 'Elmhurst' },\n  { name: 'Elyria' },\n  { name: 'Encinitas' },\n  { name: 'Enid' },\n  { name: 'Erie' },\n  { name: 'Escondido' },\n  { name: 'Euclid' },\n  { name: 'Eugene' },\n  { name: 'Euless' },\n  { name: 'Evanston' },\n  { name: 'Evansville' },\n  { name: 'Everett' },\n  { name: 'Everett' },\n  { name: 'Fairfield' },\n  { name: 'Fairfield' },\n  { name: 'Fall River' },\n  { name: 'Fargo' },\n  { name: 'Farmington' },\n  { name: 'Farmington Hills' },\n  { name: 'Fayetteville' },\n  { name: 'Fayetteville' },\n  { name: 'Federal Way' },\n  { name: 'Findlay' },\n  { name: 'Fishers' },\n  { name: 'Fitchburg' },\n  { name: 'Flagstaff' },\n  { name: 'Flint' },\n  { name: 'Florence' },\n  { name: 'Florence' },\n  { name: 'Florissant' },\n  { name: 'Flower Mound' },\n  { name: 'Folsom' },\n  { name: 'Fond du Lac' },\n  { name: 'Fontana' },\n  { name: 'Fort Collins' },\n  { name: 'Fort Lauderdale' },\n  { name: 'Fort Myers' },\n  { name: 'Fort Pierce' },\n  { name: 'Fort Smith' },\n  { name: 'Fort Wayne' },\n  { name: 'Fort Worth' },\n  { name: 'Fountain Valley' },\n  { name: 'Franklin' },\n  { name: 'Frederick' },\n  { name: 'Freeport' },\n  { name: 'Fremont' },\n  { name: 'Fresno' },\n  { name: 'Friendswood' },\n  { name: 'Frisco' },\n  { name: 'Fullerton' },\n  { name: 'Gainesville' },\n  { name: 'Gaithersburg' },\n  { name: 'Galveston' },\n  { name: 'Garden Grove' },\n  { name: 'Gardena' },\n  { name: 'Garland' },\n  { name: 'Gary' },\n  { name: 'Gastonia' },\n  { name: 'Georgetown' },\n  { name: 'Germantown' },\n  { name: 'Gilbert' },\n  { name: 'Gilroy' },\n  { name: 'Glendale' },\n  { name: 'Glendale' },\n  { name: 'Glendora' },\n  { name: 'Glenview' },\n  { name: 'Goodyear' },\n  { name: 'Goose Creek' },\n  { name: 'Grand Forks' },\n  { name: 'Grand Island' },\n  { name: 'Grand Junction' },\n  { name: 'Grand Prairie' },\n  { name: 'Grand Rapids' },\n  { name: 'Grapevine' },\n  { name: 'Great Falls' },\n  { name: 'Greeley' },\n  { name: 'Green Bay' },\n  { name: 'Greenacres' },\n  { name: 'Greenfield' },\n  { name: 'Greensboro' },\n  { name: 'Greenville' },\n  { name: 'Greenville' },\n  { name: 'Greenwood' },\n  { name: 'Gresham' },\n  { name: 'Grove City' },\n  { name: 'Gulfport' },\n  { name: 'Hackensack' },\n  { name: 'Hagerstown' },\n  { name: 'Hallandale Beach' },\n  { name: 'Haltom City' },\n  { name: 'Hamilton' },\n  { name: 'Hammond' },\n  { name: 'Hampton' },\n  { name: 'Hanford' },\n  { name: 'Hanover Park' },\n  { name: 'Harlingen' },\n  { name: 'Harrisburg' },\n  { name: 'Harrisonburg' },\n  { name: 'Hartford' },\n  { name: 'Hattiesburg' },\n  { name: 'Haverhill' },\n  { name: 'Hawthorne' },\n  { name: 'Hayward' },\n  { name: 'Hemet' },\n  { name: 'Hempstead' },\n  { name: 'Henderson' },\n  { name: 'Hendersonville' },\n  { name: 'Hesperia' },\n  { name: 'Hialeah' },\n  { name: 'Hickory' },\n  { name: 'High Point' },\n  { name: 'Highland' },\n  { name: 'Hillsboro' },\n  { name: 'Hilton Head Island' },\n  { name: 'Hoboken' },\n  { name: 'Hoffman Estates' },\n  { name: 'Hollywood' },\n  { name: 'Holyoke' },\n  { name: 'Homestead' },\n  { name: 'Honolulu' },\n  { name: 'Hoover' },\n  { name: 'Houston' },\n  { name: 'Huber Heights' },\n  { name: 'Huntersville' },\n  { name: 'Huntington' },\n  { name: 'Huntington Beach' },\n  { name: 'Huntington Park' },\n  { name: 'Huntsville' },\n  { name: 'Huntsville' },\n  { name: 'Hurst' },\n  { name: 'Hutchinson' },\n  { name: 'Idaho Falls' },\n  { name: 'Independence' },\n  { name: 'Indianapolis' },\n  { name: 'Indio' },\n  { name: 'Inglewood' },\n  { name: 'Iowa City' },\n  { name: 'Irvine' },\n  { name: 'Irving' },\n  { name: 'Jackson' },\n  { name: 'Jackson' },\n  { name: 'Jacksonville' },\n  { name: 'Jacksonville' },\n  { name: 'Janesville' },\n  { name: 'Jefferson City' },\n  { name: 'Jeffersonville' },\n  { name: 'Jersey City' },\n  { name: 'Johns Creek' },\n  { name: 'Johnson City' },\n  { name: 'Joliet' },\n  { name: 'Jonesboro' },\n  { name: 'Joplin' },\n  { name: 'Jupiter' },\n  { name: 'Jurupa Valley' },\n  { name: 'Kalamazoo' },\n  { name: 'Kannapolis' },\n  { name: 'Kansas City' },\n  { name: 'Kansas City' },\n  { name: 'Kearny' },\n  { name: 'Keizer' },\n  { name: 'Keller' },\n  { name: 'Kenner' },\n  { name: 'Kennewick' },\n  { name: 'Kenosha' },\n  { name: 'Kent' },\n  { name: 'Kentwood' },\n  { name: 'Kettering' },\n  { name: 'Killeen' },\n  { name: 'Kingsport' },\n  { name: 'Kirkland' },\n  { name: 'Kissimmee' },\n  { name: 'Knoxville' },\n  { name: 'Kokomo' },\n  { name: 'La Crosse' },\n  { name: 'La Habra' },\n  { name: 'La Mesa' },\n  { name: 'La Mirada' },\n  { name: 'La Puente' },\n  { name: 'La Quinta' },\n  { name: 'Lacey' },\n  { name: 'Lafayette' },\n  { name: 'Lafayette' },\n  { name: 'Laguna Niguel' },\n  { name: 'Lake Charles' },\n  { name: 'Lake Elsinore' },\n  { name: 'Lake Forest' },\n  { name: 'Lake Havasu City' },\n  { name: 'Lake Oswego' },\n  { name: 'Lakeland' },\n  { name: 'Lakeville' },\n  { name: 'Lakewood' },\n  { name: 'Lakewood' },\n  { name: 'Lakewood' },\n  { name: 'Lakewood' },\n  { name: 'Lancaster' },\n  { name: 'Lancaster' },\n  { name: 'Lancaster' },\n  { name: 'Lancaster' },\n  { name: 'Lansing' },\n  { name: 'Laredo' },\n  { name: 'Largo' },\n  { name: 'Las Cruces' },\n  { name: 'Las Vegas' },\n  { name: 'Lauderhill' },\n  { name: 'Lawrence' },\n  { name: 'Lawrence' },\n  { name: 'Lawrence' },\n  { name: 'Lawton' },\n  { name: 'Layton' },\n  { name: 'League City' },\n  { name: 'Lee\\'s Summit' },\n  { name: 'Leesburg' },\n  { name: 'Lehi' },\n  { name: 'Lenexa' },\n  { name: 'Leominster' },\n  { name: 'Lewisville' },\n  { name: 'Lexington-Fayette' },\n  { name: 'Lima' },\n  { name: 'Lincoln' },\n  { name: 'Lincoln' },\n  { name: 'Lincoln Park' },\n  { name: 'Linden' },\n  { name: 'Little Rock' },\n  { name: 'Littleton' },\n  { name: 'Livermore' },\n  { name: 'Livonia' },\n  { name: 'Lodi' },\n  { name: 'Logan' },\n  { name: 'Lombard' },\n  { name: 'Lompoc' },\n  { name: 'Long Beach' },\n  { name: 'Longmont' },\n  { name: 'Longview' },\n  { name: 'Lorain' },\n  { name: 'Los Angeles' },\n  { name: 'Louisville/Jefferson County' },\n  { name: 'Loveland' },\n  { name: 'Lowell' },\n  { name: 'Lubbock' },\n  { name: 'Lynchburg' },\n  { name: 'Lynn' },\n  { name: 'Lynwood' },\n  { name: 'Macon' },\n  { name: 'Madera' },\n  { name: 'Madison' },\n  { name: 'Madison' },\n  { name: 'Malden' },\n  { name: 'Manassas' },\n  { name: 'Manchester' },\n  { name: 'Manhattan' },\n  { name: 'Mankato' },\n  { name: 'Mansfield' },\n  { name: 'Mansfield' },\n  { name: 'Manteca' },\n  { name: 'Maple Grove' },\n  { name: 'Maplewood' },\n  { name: 'Marana' },\n  { name: 'Margate' },\n  { name: 'Maricopa' },\n  { name: 'Marietta' },\n  { name: 'Marlborough' },\n  { name: 'Martinez' },\n  { name: 'Marysville' },\n  { name: 'McAllen' },\n  { name: 'McKinney' },\n  { name: 'Medford' },\n  { name: 'Medford' },\n  { name: 'Melbourne' },\n  { name: 'Memphis' },\n  { name: 'Menifee' },\n  { name: 'Mentor' },\n  { name: 'Merced' },\n  { name: 'Meriden' },\n  { name: 'Meridian' },\n  { name: 'Meridian' },\n  { name: 'Mesa' },\n  { name: 'Mesquite' },\n  { name: 'Methuen' },\n  { name: 'Miami' },\n  { name: 'Miami Beach' },\n  { name: 'Miami Gardens' },\n  { name: 'Middletown' },\n  { name: 'Middletown' },\n  { name: 'Midland' },\n  { name: 'Midland' },\n  { name: 'Midwest City' },\n  { name: 'Milford' },\n  { name: 'Milpitas' },\n  { name: 'Milwaukee' },\n  { name: 'Minneapolis' },\n  { name: 'Minnetonka' },\n  { name: 'Minot' },\n  { name: 'Miramar' },\n  { name: 'Mishawaka' },\n  { name: 'Mission' },\n  { name: 'Mission Viejo' },\n  { name: 'Missoula' },\n  { name: 'Missouri City' },\n  { name: 'Mobile' },\n  { name: 'Modesto' },\n  { name: 'Moline' },\n  { name: 'Monroe' },\n  { name: 'Monrovia' },\n  { name: 'Montclair' },\n  { name: 'Montebello' },\n  { name: 'Monterey Park' },\n  { name: 'Montgomery' },\n  { name: 'Moore' },\n  { name: 'Moorhead' },\n  { name: 'Moreno Valley' },\n  { name: 'Morgan Hill' },\n  { name: 'Mount Pleasant' },\n  { name: 'Mount Prospect' },\n  { name: 'Mount Vernon' },\n  { name: 'Mountain View' },\n  { name: 'Muncie' },\n  { name: 'Murfreesboro' },\n  { name: 'Murray' },\n  { name: 'Murrieta' },\n  { name: 'Muskegon' },\n  { name: 'Muskogee' },\n  { name: 'Nampa' },\n  { name: 'Napa' },\n  { name: 'Naperville' },\n  { name: 'Nashua' },\n  { name: 'Nashville-Davidson' },\n  { name: 'National City' },\n  { name: 'New Bedford' },\n  { name: 'New Berlin' },\n  { name: 'New Braunfels' },\n  { name: 'New Britain' },\n  { name: 'New Brunswick' },\n  { name: 'New Haven' },\n  { name: 'New Orleans' },\n  { name: 'New Rochelle' },\n  { name: 'New York' },\n  { name: 'Newark' },\n  { name: 'Newark' },\n  { name: 'Newark' },\n  { name: 'Newport Beach' },\n  { name: 'Newport News' },\n  { name: 'Newton' },\n  { name: 'Niagara Falls' },\n  { name: 'Noblesville' },\n  { name: 'Norfolk' },\n  { name: 'Normal' },\n  { name: 'Norman' },\n  { name: 'North Charleston' },\n  { name: 'North Las Vegas' },\n  { name: 'North Lauderdale' },\n  { name: 'North Little Rock' },\n  { name: 'North Miami' },\n  { name: 'North Miami Beach' },\n  { name: 'North Port' },\n  { name: 'North Richland Hills' },\n  { name: 'Northglenn' },\n  { name: 'Norwalk' },\n  { name: 'Norwalk' },\n  { name: 'Norwich' },\n  { name: 'Novato' },\n  { name: 'Novi' },\n  { name: 'O\\'Fallon' },\n  { name: 'Oak Lawn' },\n  { name: 'Oak Park' },\n  { name: 'Oakland' },\n  { name: 'Oakland Park' },\n  { name: 'Oakley' },\n  { name: 'Ocala' },\n  { name: 'Oceanside' },\n  { name: 'Ocoee' },\n  { name: 'Odessa' },\n  { name: 'Ogden' },\n  { name: 'Oklahoma City' },\n  { name: 'Olathe' },\n  { name: 'Olympia' },\n  { name: 'Omaha' },\n  { name: 'Ontario' },\n  { name: 'Orange' },\n  { name: 'Orem' },\n  { name: 'Orland Park' },\n  { name: 'Orlando' },\n  { name: 'Ormond Beach' },\n  { name: 'Oro Valley' },\n  { name: 'Oshkosh' },\n  { name: 'Overland Park' },\n  { name: 'Owensboro' },\n  { name: 'Oxnard' },\n  { name: 'Pacifica' },\n  { name: 'Palatine' },\n  { name: 'Palm Bay' },\n  { name: 'Palm Beach Gardens' },\n  { name: 'Palm Coast' },\n  { name: 'Palm Desert' },\n  { name: 'Palm Springs' },\n  { name: 'Palmdale' },\n  { name: 'Palo Alto' },\n  { name: 'Panama City' },\n  { name: 'Paramount' },\n  { name: 'Park Ridge' },\n  { name: 'Parker' },\n  { name: 'Parma' },\n  { name: 'Pasadena' },\n  { name: 'Pasadena' },\n  { name: 'Pasco' },\n  { name: 'Passaic' },\n  { name: 'Paterson' },\n  { name: 'Pawtucket' },\n  { name: 'Peabody' },\n  { name: 'Peachtree Corners' },\n  { name: 'Pearland' },\n  { name: 'Pembroke Pines' },\n  { name: 'Pensacola' },\n  { name: 'Peoria' },\n  { name: 'Peoria' },\n  { name: 'Perris' },\n  { name: 'Perth Amboy' },\n  { name: 'Petaluma' },\n  { name: 'Pflugerville' },\n  { name: 'Pharr' },\n  { name: 'Phenix City' },\n  { name: 'Philadelphia' },\n  { name: 'Phoenix' },\n  { name: 'Pico Rivera' },\n  { name: 'Pine Bluff' },\n  { name: 'Pinellas Park' },\n  { name: 'Pittsburg' },\n  { name: 'Pittsburgh' },\n  { name: 'Pittsfield' },\n  { name: 'Placentia' },\n  { name: 'Plainfield' },\n  { name: 'Plainfield' },\n  { name: 'Plano' },\n  { name: 'Plantation' },\n  { name: 'Pleasanton' },\n  { name: 'Plymouth' },\n  { name: 'Pocatello' },\n  { name: 'Pomona' },\n  { name: 'Pompano Beach' },\n  { name: 'Pontiac' },\n  { name: 'Port Arthur' },\n  { name: 'Port Orange' },\n  { name: 'Port St. Lucie' },\n  { name: 'Portage' },\n  { name: 'Porterville' },\n  { name: 'Portland' },\n  { name: 'Portland' },\n  { name: 'Portsmouth' },\n  { name: 'Poway' },\n  { name: 'Prescott' },\n  { name: 'Prescott Valley' },\n  { name: 'Providence' },\n  { name: 'Provo' },\n  { name: 'Pueblo' },\n  { name: 'Puyallup' },\n  { name: 'Quincy' },\n  { name: 'Quincy' },\n  { name: 'Racine' },\n  { name: 'Raleigh' },\n  { name: 'Rancho Cordova' },\n  { name: 'Rancho Cucamonga' },\n  { name: 'Rancho Palos Verdes' },\n  { name: 'Rancho Santa Margarita' },\n  { name: 'Rapid City' },\n  { name: 'Reading' },\n  { name: 'Redding' },\n  { name: 'Redlands' },\n  { name: 'Redmond' },\n  { name: 'Redondo Beach' },\n  { name: 'Redwood City' },\n  { name: 'Reno' },\n  { name: 'Renton' },\n  { name: 'Revere' },\n  { name: 'Rialto' },\n  { name: 'Richardson' },\n  { name: 'Richland' },\n  { name: 'Richmond' },\n  { name: 'Richmond' },\n  { name: 'Rio Rancho' },\n  { name: 'Riverside' },\n  { name: 'Riverton' },\n  { name: 'Roanoke' },\n  { name: 'Rochester' },\n  { name: 'Rochester' },\n  { name: 'Rochester Hills' },\n  { name: 'Rock Hill' },\n  { name: 'Rock Island' },\n  { name: 'Rockford' },\n  { name: 'Rocklin' },\n  { name: 'Rockville' },\n  { name: 'Rockwall' },\n  { name: 'Rocky Mount' },\n  { name: 'Rogers' },\n  { name: 'Rohnert Park' },\n  { name: 'Romeoville' },\n  { name: 'Rosemead' },\n  { name: 'Roseville' },\n  { name: 'Roseville' },\n  { name: 'Roswell' },\n  { name: 'Roswell' },\n  { name: 'Round Rock' },\n  { name: 'Rowlett' },\n  { name: 'Roy' },\n  { name: 'Royal Oak' },\n  { name: 'Sacramento' },\n  { name: 'Saginaw' },\n  { name: 'Salem' },\n  { name: 'Salem' },\n  { name: 'Salina' },\n  { name: 'Salinas' },\n  { name: 'Salt Lake City' },\n  { name: 'Sammamish' },\n  { name: 'San Angelo' },\n  { name: 'San Antonio' },\n  { name: 'San Bernardino' },\n  { name: 'San Bruno' },\n  { name: 'San Buenaventura (Ventura)' },\n  { name: 'San Clemente' },\n  { name: 'San Diego' },\n  { name: 'San Francisco' },\n  { name: 'San Gabriel' },\n  { name: 'San Jacinto' },\n  { name: 'San Jose' },\n  { name: 'San Leandro' },\n  { name: 'San Luis Obispo' },\n  { name: 'San Marcos' },\n  { name: 'San Marcos' },\n  { name: 'San Mateo' },\n  { name: 'San Rafael' },\n  { name: 'San Ramon' },\n  { name: 'Sandy' },\n  { name: 'Sandy Springs' },\n  { name: 'Sanford' },\n  { name: 'Santa Ana' },\n  { name: 'Santa Barbara' },\n  { name: 'Santa Clara' },\n  { name: 'Santa Clarita' },\n  { name: 'Santa Cruz' },\n  { name: 'Santa Fe' },\n  { name: 'Santa Maria' },\n  { name: 'Santa Monica' },\n  { name: 'Santa Rosa' },\n  { name: 'Santee' },\n  { name: 'Sarasota' },\n  { name: 'Savannah' },\n  { name: 'Sayreville' },\n  { name: 'Schaumburg' },\n  { name: 'Schenectady' },\n  { name: 'Scottsdale' },\n  { name: 'Scranton' },\n  { name: 'Seattle' },\n  { name: 'Shakopee' },\n  { name: 'Shawnee' },\n  { name: 'Sheboygan' },\n  { name: 'Shelton' },\n  { name: 'Sherman' },\n  { name: 'Shoreline' },\n  { name: 'Shreveport' },\n  { name: 'Sierra Vista' },\n  { name: 'Simi Valley' },\n  { name: 'Sioux City' },\n  { name: 'Sioux Falls' },\n  { name: 'Skokie' },\n  { name: 'Smyrna' },\n  { name: 'Smyrna' },\n  { name: 'Somerville' },\n  { name: 'South Bend' },\n  { name: 'South Gate' },\n  { name: 'South Jordan' },\n  { name: 'South San Francisco' },\n  { name: 'Southaven' },\n  { name: 'Southfield' },\n  { name: 'Spanish Fork' },\n  { name: 'Sparks' },\n  { name: 'Spartanburg' },\n  { name: 'Spokane' },\n  { name: 'Spokane Valley' },\n  { name: 'Springdale' },\n  { name: 'Springfield' },\n  { name: 'Springfield' },\n  { name: 'Springfield' },\n  { name: 'Springfield' },\n  { name: 'Springfield' },\n  { name: 'St. Charles' },\n  { name: 'St. Clair Shores' },\n  { name: 'St. Cloud' },\n  { name: 'St. Cloud' },\n  { name: 'St. George' },\n  { name: 'St. Joseph' },\n  { name: 'St. Louis' },\n  { name: 'St. Louis Park' },\n  { name: 'St. Paul' },\n  { name: 'St. Peters' },\n  { name: 'St. Petersburg' },\n  { name: 'Stamford' },\n  { name: 'Stanton' },\n  { name: 'State College' },\n  { name: 'Sterling Heights' },\n  { name: 'Stillwater' },\n  { name: 'Stockton' },\n  { name: 'Streamwood' },\n  { name: 'Strongsville' },\n  { name: 'Suffolk' },\n  { name: 'Sugar Land' },\n  { name: 'Summerville' },\n  { name: 'Sumter' },\n  { name: 'Sunnyvale' },\n  { name: 'Sunrise' },\n  { name: 'Surprise' },\n  { name: 'Syracuse' },\n  { name: 'Tacoma' },\n  { name: 'Tallahassee' },\n  { name: 'Tamarac' },\n  { name: 'Tampa' },\n  { name: 'Taunton' },\n  { name: 'Taylor' },\n  { name: 'Taylorsville' },\n  { name: 'Temecula' },\n  { name: 'Tempe' },\n  { name: 'Temple' },\n  { name: 'Terre Haute' },\n  { name: 'Texarkana' },\n  { name: 'Texas City' },\n  { name: 'The Colony' },\n  { name: 'Thornton' },\n  { name: 'Thousand Oaks' },\n  { name: 'Tigard' },\n  { name: 'Tinley Park' },\n  { name: 'Titusville' },\n  { name: 'Toledo' },\n  { name: 'Topeka' },\n  { name: 'Torrance' },\n  { name: 'Tracy' },\n  { name: 'Trenton' },\n  { name: 'Troy' },\n  { name: 'Troy' },\n  { name: 'Tucson' },\n  { name: 'Tulare' },\n  { name: 'Tulsa' },\n  { name: 'Turlock' },\n  { name: 'Tuscaloosa' },\n  { name: 'Tustin' },\n  { name: 'Twin Falls' },\n  { name: 'Tyler' },\n  { name: 'Union City' },\n  { name: 'Union City' },\n  { name: 'Upland' },\n  { name: 'Urbana' },\n  { name: 'Urbandale' },\n  { name: 'Utica' },\n  { name: 'Vacaville' },\n  { name: 'Valdosta' },\n  { name: 'Vallejo' },\n  { name: 'Valley Stream' },\n  { name: 'Vancouver' },\n  { name: 'Victoria' },\n  { name: 'Victorville' },\n  { name: 'Vineland' },\n  { name: 'Virginia Beach' },\n  { name: 'Visalia' },\n  { name: 'Vista' },\n  { name: 'Waco' },\n  { name: 'Walnut Creek' },\n  { name: 'Waltham' },\n  { name: 'Warner Robins' },\n  { name: 'Warren' },\n  { name: 'Warren' },\n  { name: 'Warwick' },\n  { name: 'Washington' },\n  { name: 'Waterbury' },\n  { name: 'Waterloo' },\n  { name: 'Watsonville' },\n  { name: 'Waukegan' },\n  { name: 'Waukesha' },\n  { name: 'Wausau' },\n  { name: 'Wauwatosa' },\n  { name: 'Wellington' },\n  { name: 'Weslaco' },\n  { name: 'West Allis' },\n  { name: 'West Covina' },\n  { name: 'West Des Moines' },\n  { name: 'West Haven' },\n  { name: 'West Jordan' },\n  { name: 'West New York' },\n  { name: 'West Palm Beach' },\n  { name: 'West Sacramento' },\n  { name: 'West Valley City' },\n  { name: 'Westerville' },\n  { name: 'Westfield' },\n  { name: 'Westland' },\n  { name: 'Westminster' },\n  { name: 'Westminster' },\n  { name: 'Weston' },\n  { name: 'Weymouth Town' },\n  { name: 'Wheaton' },\n  { name: 'Wheeling' },\n  { name: 'White Plains' },\n  { name: 'Whittier' },\n  { name: 'Wichita' },\n  { name: 'Wichita Falls' },\n  { name: 'Wilkes-Barre' },\n  { name: 'Wilmington' },\n  { name: 'Wilmington' },\n  { name: 'Wilson' },\n  { name: 'Winston-Salem' },\n  { name: 'Winter Garden' },\n  { name: 'Woburn' },\n  { name: 'Woodbury' },\n  { name: 'Woodland' },\n  { name: 'Woonsocket' },\n  { name: 'Worcester' },\n  { name: 'Wylie' },\n  { name: 'Wyoming' },\n  { name: 'Yakima' },\n  { name: 'Yonkers' },\n  { name: 'Yorba Linda' },\n  { name: 'York' },\n  { name: 'Youngstown' },\n  { name: 'Yuba City' },\n  { name: 'Yucaipa' },\n  { name: 'Yuma' }\n];\n","module.exports = [\n\t{ github: 'jedwatson', name: 'Jed Watson' },\n\t{ github: 'bruderstein', name: 'Dave Brotherstone' },\n\t{ github: 'jossmac', name: 'Joss Mackison' },\n\t{ github: 'jniechcial', name: 'Jakub Niechciał' },\n\t{ github: 'craigdallimore', name: 'Craig Dallimore' },\n\t{ github: 'julen', name: 'Julen Ruiz Aizpuru' },\n\t{ github: 'dcousens', name: 'Daniel Cousens' },\n\t{ github: 'jgautsch', name: 'Jon Gautsch' },\n\t{ github: 'dmitry-smirnov', name: 'Dmitry Smirnov' },\n];\n","exports.AU = [\n\t{ value: 'australian-capital-territory', label: 'Australian Capital Territory', className: 'State-ACT' },\n\t{ value: 'new-south-wales', label: 'New South Wales', className: 'State-NSW' },\n\t{ value: 'victoria', label: 'Victoria', className: 'State-Vic' },\n\t{ value: 'queensland', label: 'Queensland', className: 'State-Qld' },\n\t{ value: 'western-australia', label: 'Western Australia', className: 'State-WA' },\n\t{ value: 'south-australia', label: 'South Australia', className: 'State-SA' },\n\t{ value: 'tasmania', label: 'Tasmania', className: 'State-Tas' },\n\t{ value: 'northern-territory', label: 'Northern Territory', className: 'State-NT' },\n];\n\nexports.US = [\n    { value: 'AL', label: 'Alabama', disabled: true },\n    { value: 'AK', label: 'Alaska' },\n    { value: 'AS', label: 'American Samoa' },\n    { value: 'AZ', label: 'Arizona' },\n    { value: 'AR', label: 'Arkansas' },\n    { value: 'CA', label: 'California' },\n    { value: 'CO', label: 'Colorado' },\n    { value: 'CT', label: 'Connecticut' },\n    { value: 'DE', label: 'Delaware' },\n    { value: 'DC', label: 'District Of Columbia' },\n    { value: 'FM', label: 'Federated States Of Micronesia' },\n    { value: 'FL', label: 'Florida' },\n    { value: 'GA', label: 'Georgia' },\n    { value: 'GU', label: 'Guam' },\n    { value: 'HI', label: 'Hawaii' },\n    { value: 'ID', label: 'Idaho' },\n    { value: 'IL', label: 'Illinois' },\n    { value: 'IN', label: 'Indiana' },\n    { value: 'IA', label: 'Iowa' },\n    { value: 'KS', label: 'Kansas' },\n    { value: 'KY', label: 'Kentucky' },\n    { value: 'LA', label: 'Louisiana' },\n    { value: 'ME', label: 'Maine' },\n    { value: 'MH', label: 'Marshall Islands' },\n    { value: 'MD', label: 'Maryland' },\n    { value: 'MA', label: 'Massachusetts' },\n    { value: 'MI', label: 'Michigan' },\n    { value: 'MN', label: 'Minnesota' },\n    { value: 'MS', label: 'Mississippi' },\n    { value: 'MO', label: 'Missouri' },\n    { value: 'MT', label: 'Montana' },\n    { value: 'NE', label: 'Nebraska' },\n    { value: 'NV', label: 'Nevada' },\n    { value: 'NH', label: 'New Hampshire' },\n    { value: 'NJ', label: 'New Jersey' },\n    { value: 'NM', label: 'New Mexico' },\n    { value: 'NY', label: 'New York' },\n    { value: 'NC', label: 'North Carolina' },\n    { value: 'ND', label: 'North Dakota' },\n    { value: 'MP', label: 'Northern Mariana Islands' },\n    { value: 'OH', label: 'Ohio' },\n    { value: 'OK', label: 'Oklahoma' },\n    { value: 'OR', label: 'Oregon' },\n    { value: 'PW', label: 'Palau' },\n    { value: 'PA', label: 'Pennsylvania' },\n    { value: 'PR', label: 'Puerto Rico' },\n    { value: 'RI', label: 'Rhode Island' },\n    { value: 'SC', label: 'South Carolina' },\n    { value: 'SD', label: 'South Dakota' },\n    { value: 'TN', label: 'Tennessee' },\n    { value: 'TX', label: 'Texas' },\n    { value: 'UT', label: 'Utah' },\n    { value: 'VT', label: 'Vermont' },\n    { value: 'VI', label: 'Virgin Islands' },\n    { value: 'VA', label: 'Virginia' },\n    { value: 'WA', label: 'Washington' },\n    { value: 'WV', label: 'West Virginia' },\n    { value: 'WI', label: 'Wisconsin' },\n    { value: 'WY', label: 'Wyoming' },\n];\n","module.exports = [\n\t{ value: 'John Smith', label: 'John Smith', email: 'john@smith.com' },\n\t{ value: 'Merry Jane', label: 'Merry Jane', email: 'merry@jane.com' },\n\t{ value: 'Stan Hoper', label: 'Stan Hoper', email: 'stan@hoper.com' }\n];\n","// the whatwg-fetch polyfill installs the fetch() function\n// on the global object (window or self)\n//\n// Return that as the export for use in Webpack, Browserify etc.\nrequire('whatwg-fetch');\nmodule.exports = self.fetch.bind(self);\n","(function(self) {\n  'use strict';\n\n  if (self.fetch) {\n    return\n  }\n\n  var support = {\n    searchParams: 'URLSearchParams' in self,\n    iterable: 'Symbol' in self && 'iterator' in Symbol,\n    blob: 'FileReader' in self && 'Blob' in self && (function() {\n      try {\n        new Blob()\n        return true\n      } catch(e) {\n        return false\n      }\n    })(),\n    formData: 'FormData' in self,\n    arrayBuffer: 'ArrayBuffer' in self\n  }\n\n  if (support.arrayBuffer) {\n    var viewClasses = [\n      '[object Int8Array]',\n      '[object Uint8Array]',\n      '[object Uint8ClampedArray]',\n      '[object Int16Array]',\n      '[object Uint16Array]',\n      '[object Int32Array]',\n      '[object Uint32Array]',\n      '[object Float32Array]',\n      '[object Float64Array]'\n    ]\n\n    var isDataView = function(obj) {\n      return obj && DataView.prototype.isPrototypeOf(obj)\n    }\n\n    var isArrayBufferView = ArrayBuffer.isView || function(obj) {\n      return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1\n    }\n  }\n\n  function normalizeName(name) {\n    if (typeof name !== 'string') {\n      name = String(name)\n    }\n    if (/[^a-z0-9\\-#$%&'*+.\\^_`|~]/i.test(name)) {\n      throw new TypeError('Invalid character in header field name')\n    }\n    return name.toLowerCase()\n  }\n\n  function normalizeValue(value) {\n    if (typeof value !== 'string') {\n      value = String(value)\n    }\n    return value\n  }\n\n  // Build a destructive iterator for the value list\n  function iteratorFor(items) {\n    var iterator = {\n      next: function() {\n        var value = items.shift()\n        return {done: value === undefined, value: value}\n      }\n    }\n\n    if (support.iterable) {\n      iterator[Symbol.iterator] = function() {\n        return iterator\n      }\n    }\n\n    return iterator\n  }\n\n  function Headers(headers) {\n    this.map = {}\n\n    if (headers instanceof Headers) {\n      headers.forEach(function(value, name) {\n        this.append(name, value)\n      }, this)\n    } else if (Array.isArray(headers)) {\n      headers.forEach(function(header) {\n        this.append(header[0], header[1])\n      }, this)\n    } else if (headers) {\n      Object.getOwnPropertyNames(headers).forEach(function(name) {\n        this.append(name, headers[name])\n      }, this)\n    }\n  }\n\n  Headers.prototype.append = function(name, value) {\n    name = normalizeName(name)\n    value = normalizeValue(value)\n    var oldValue = this.map[name]\n    this.map[name] = oldValue ? oldValue+','+value : value\n  }\n\n  Headers.prototype['delete'] = function(name) {\n    delete this.map[normalizeName(name)]\n  }\n\n  Headers.prototype.get = function(name) {\n    name = normalizeName(name)\n    return this.has(name) ? this.map[name] : null\n  }\n\n  Headers.prototype.has = function(name) {\n    return this.map.hasOwnProperty(normalizeName(name))\n  }\n\n  Headers.prototype.set = function(name, value) {\n    this.map[normalizeName(name)] = normalizeValue(value)\n  }\n\n  Headers.prototype.forEach = function(callback, thisArg) {\n    for (var name in this.map) {\n      if (this.map.hasOwnProperty(name)) {\n        callback.call(thisArg, this.map[name], name, this)\n      }\n    }\n  }\n\n  Headers.prototype.keys = function() {\n    var items = []\n    this.forEach(function(value, name) { items.push(name) })\n    return iteratorFor(items)\n  }\n\n  Headers.prototype.values = function() {\n    var items = []\n    this.forEach(function(value) { items.push(value) })\n    return iteratorFor(items)\n  }\n\n  Headers.prototype.entries = function() {\n    var items = []\n    this.forEach(function(value, name) { items.push([name, value]) })\n    return iteratorFor(items)\n  }\n\n  if (support.iterable) {\n    Headers.prototype[Symbol.iterator] = Headers.prototype.entries\n  }\n\n  function consumed(body) {\n    if (body.bodyUsed) {\n      return Promise.reject(new TypeError('Already read'))\n    }\n    body.bodyUsed = true\n  }\n\n  function fileReaderReady(reader) {\n    return new Promise(function(resolve, reject) {\n      reader.onload = function() {\n        resolve(reader.result)\n      }\n      reader.onerror = function() {\n        reject(reader.error)\n      }\n    })\n  }\n\n  function readBlobAsArrayBuffer(blob) {\n    var reader = new FileReader()\n    var promise = fileReaderReady(reader)\n    reader.readAsArrayBuffer(blob)\n    return promise\n  }\n\n  function readBlobAsText(blob) {\n    var reader = new FileReader()\n    var promise = fileReaderReady(reader)\n    reader.readAsText(blob)\n    return promise\n  }\n\n  function readArrayBufferAsText(buf) {\n    var view = new Uint8Array(buf)\n    var chars = new Array(view.length)\n\n    for (var i = 0; i < view.length; i++) {\n      chars[i] = String.fromCharCode(view[i])\n    }\n    return chars.join('')\n  }\n\n  function bufferClone(buf) {\n    if (buf.slice) {\n      return buf.slice(0)\n    } else {\n      var view = new Uint8Array(buf.byteLength)\n      view.set(new Uint8Array(buf))\n      return view.buffer\n    }\n  }\n\n  function Body() {\n    this.bodyUsed = false\n\n    this._initBody = function(body) {\n      this._bodyInit = body\n      if (!body) {\n        this._bodyText = ''\n      } else if (typeof body === 'string') {\n        this._bodyText = body\n      } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {\n        this._bodyBlob = body\n      } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {\n        this._bodyFormData = body\n      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {\n        this._bodyText = body.toString()\n      } else if (support.arrayBuffer && support.blob && isDataView(body)) {\n        this._bodyArrayBuffer = bufferClone(body.buffer)\n        // IE 10-11 can't handle a DataView body.\n        this._bodyInit = new Blob([this._bodyArrayBuffer])\n      } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {\n        this._bodyArrayBuffer = bufferClone(body)\n      } else {\n        throw new Error('unsupported BodyInit type')\n      }\n\n      if (!this.headers.get('content-type')) {\n        if (typeof body === 'string') {\n          this.headers.set('content-type', 'text/plain;charset=UTF-8')\n        } else if (this._bodyBlob && this._bodyBlob.type) {\n          this.headers.set('content-type', this._bodyBlob.type)\n        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {\n          this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8')\n        }\n      }\n    }\n\n    if (support.blob) {\n      this.blob = function() {\n        var rejected = consumed(this)\n        if (rejected) {\n          return rejected\n        }\n\n        if (this._bodyBlob) {\n          return Promise.resolve(this._bodyBlob)\n        } else if (this._bodyArrayBuffer) {\n          return Promise.resolve(new Blob([this._bodyArrayBuffer]))\n        } else if (this._bodyFormData) {\n          throw new Error('could not read FormData body as blob')\n        } else {\n          return Promise.resolve(new Blob([this._bodyText]))\n        }\n      }\n\n      this.arrayBuffer = function() {\n        if (this._bodyArrayBuffer) {\n          return consumed(this) || Promise.resolve(this._bodyArrayBuffer)\n        } else {\n          return this.blob().then(readBlobAsArrayBuffer)\n        }\n      }\n    }\n\n    this.text = function() {\n      var rejected = consumed(this)\n      if (rejected) {\n        return rejected\n      }\n\n      if (this._bodyBlob) {\n        return readBlobAsText(this._bodyBlob)\n      } else if (this._bodyArrayBuffer) {\n        return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))\n      } else if (this._bodyFormData) {\n        throw new Error('could not read FormData body as text')\n      } else {\n        return Promise.resolve(this._bodyText)\n      }\n    }\n\n    if (support.formData) {\n      this.formData = function() {\n        return this.text().then(decode)\n      }\n    }\n\n    this.json = function() {\n      return this.text().then(JSON.parse)\n    }\n\n    return this\n  }\n\n  // HTTP methods whose capitalization should be normalized\n  var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT']\n\n  function normalizeMethod(method) {\n    var upcased = method.toUpperCase()\n    return (methods.indexOf(upcased) > -1) ? upcased : method\n  }\n\n  function Request(input, options) {\n    options = options || {}\n    var body = options.body\n\n    if (input instanceof Request) {\n      if (input.bodyUsed) {\n        throw new TypeError('Already read')\n      }\n      this.url = input.url\n      this.credentials = input.credentials\n      if (!options.headers) {\n        this.headers = new Headers(input.headers)\n      }\n      this.method = input.method\n      this.mode = input.mode\n      if (!body && input._bodyInit != null) {\n        body = input._bodyInit\n        input.bodyUsed = true\n      }\n    } else {\n      this.url = String(input)\n    }\n\n    this.credentials = options.credentials || this.credentials || 'omit'\n    if (options.headers || !this.headers) {\n      this.headers = new Headers(options.headers)\n    }\n    this.method = normalizeMethod(options.method || this.method || 'GET')\n    this.mode = options.mode || this.mode || null\n    this.referrer = null\n\n    if ((this.method === 'GET' || this.method === 'HEAD') && body) {\n      throw new TypeError('Body not allowed for GET or HEAD requests')\n    }\n    this._initBody(body)\n  }\n\n  Request.prototype.clone = function() {\n    return new Request(this, { body: this._bodyInit })\n  }\n\n  function decode(body) {\n    var form = new FormData()\n    body.trim().split('&').forEach(function(bytes) {\n      if (bytes) {\n        var split = bytes.split('=')\n        var name = split.shift().replace(/\\+/g, ' ')\n        var value = split.join('=').replace(/\\+/g, ' ')\n        form.append(decodeURIComponent(name), decodeURIComponent(value))\n      }\n    })\n    return form\n  }\n\n  function parseHeaders(rawHeaders) {\n    var headers = new Headers()\n    rawHeaders.split(/\\r?\\n/).forEach(function(line) {\n      var parts = line.split(':')\n      var key = parts.shift().trim()\n      if (key) {\n        var value = parts.join(':').trim()\n        headers.append(key, value)\n      }\n    })\n    return headers\n  }\n\n  Body.call(Request.prototype)\n\n  function Response(bodyInit, options) {\n    if (!options) {\n      options = {}\n    }\n\n    this.type = 'default'\n    this.status = 'status' in options ? options.status : 200\n    this.ok = this.status >= 200 && this.status < 300\n    this.statusText = 'statusText' in options ? options.statusText : 'OK'\n    this.headers = new Headers(options.headers)\n    this.url = options.url || ''\n    this._initBody(bodyInit)\n  }\n\n  Body.call(Response.prototype)\n\n  Response.prototype.clone = function() {\n    return new Response(this._bodyInit, {\n      status: this.status,\n      statusText: this.statusText,\n      headers: new Headers(this.headers),\n      url: this.url\n    })\n  }\n\n  Response.error = function() {\n    var response = new Response(null, {status: 0, statusText: ''})\n    response.type = 'error'\n    return response\n  }\n\n  var redirectStatuses = [301, 302, 303, 307, 308]\n\n  Response.redirect = function(url, status) {\n    if (redirectStatuses.indexOf(status) === -1) {\n      throw new RangeError('Invalid status code')\n    }\n\n    return new Response(null, {status: status, headers: {location: url}})\n  }\n\n  self.Headers = Headers\n  self.Request = Request\n  self.Response = Response\n\n  self.fetch = function(input, init) {\n    return new Promise(function(resolve, reject) {\n      var request = new Request(input, init)\n      var xhr = new XMLHttpRequest()\n\n      xhr.onload = function() {\n        var options = {\n          status: xhr.status,\n          statusText: xhr.statusText,\n          headers: parseHeaders(xhr.getAllResponseHeaders() || '')\n        }\n        options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL')\n        var body = 'response' in xhr ? xhr.response : xhr.responseText\n        resolve(new Response(body, options))\n      }\n\n      xhr.onerror = function() {\n        reject(new TypeError('Network request failed'))\n      }\n\n      xhr.ontimeout = function() {\n        reject(new TypeError('Network request failed'))\n      }\n\n      xhr.open(request.method, request.url, true)\n\n      if (request.credentials === 'include') {\n        xhr.withCredentials = true\n      }\n\n      if ('responseType' in xhr && support.blob) {\n        xhr.responseType = 'blob'\n      }\n\n      request.headers.forEach(function(value, name) {\n        xhr.setRequestHeader(name, value)\n      })\n\n      xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit)\n    })\n  }\n  self.fetch.polyfill = true\n})(typeof self !== 'undefined' ? self : this);\n","/**\n * Copyright 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule shallowCompare\n */\n\n'use strict';\n\nvar shallowEqual = require('fbjs/lib/shallowEqual');\n\n/**\n * Does a shallow comparison for props and state.\n * See ReactComponentWithPureRenderMixin\n * See also https://facebook.github.io/react/docs/shallow-compare.html\n */\nfunction shallowCompare(instance, nextProps, nextState) {\n  return (\n    !shallowEqual(instance.props, nextProps) ||\n    !shallowEqual(instance.state, nextState)\n  );\n}\n\nmodule.exports = shallowCompare;\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @typechecks\n * \n */\n\n/*eslint-disable no-self-compare */\n\n'use strict';\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\n/**\n * inlined Object.is polyfill to avoid requiring consumers ship their own\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\n */\nfunction is(x, y) {\n  // SameValue algorithm\n  if (x === y) {\n    // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    // Added the nonzero y check to make Flow happy, but it is redundant\n    return x !== 0 || y !== 0 || 1 / x === 1 / y;\n  } else {\n    // Step 6.a: NaN == NaN\n    return x !== x && y !== y;\n  }\n}\n\n/**\n * Performs equality by iterating through keys on an object and returning false\n * when any key has values which are not strictly equal between the arguments.\n * Returns true when the values of all keys are strictly equal.\n */\nfunction shallowEqual(objA, objB) {\n  if (is(objA, objB)) {\n    return true;\n  }\n\n  if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {\n    return false;\n  }\n\n  var keysA = Object.keys(objA);\n  var keysB = Object.keys(objB);\n\n  if (keysA.length !== keysB.length) {\n    return false;\n  }\n\n  // Test for A's keys different from B.\n  for (var i = 0; i < keysA.length; i++) {\n    if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nmodule.exports = shallowEqual;","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","'use strict';\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _md = require('md5');\n\nvar _md2 = _interopRequireDefault(_md);\n\nvar _queryString = require('query-string');\n\nvar _queryString2 = _interopRequireDefault(_queryString);\n\nvar _isRetina = require('is-retina');\n\nvar _isRetina2 = _interopRequireDefault(_isRetina);\n\nvar _propTypes = require('prop-types');\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar Gravatar = function (_React$Component) {\n  _inherits(Gravatar, _React$Component);\n\n  function Gravatar() {\n    _classCallCheck(this, Gravatar);\n\n    return _possibleConstructorReturn(this, (Gravatar.__proto__ || Object.getPrototypeOf(Gravatar)).apply(this, arguments));\n  }\n\n  _createClass(Gravatar, [{\n    key: 'render',\n    value: function render() {\n      var base = this.props.protocol + 'www.gravatar.com/avatar/';\n\n      var query = _queryString2.default.stringify({\n        s: this.props.size,\n        r: this.props.rating,\n        d: this.props.default\n      });\n\n      var retinaQuery = _queryString2.default.stringify({\n        s: this.props.size * 2,\n        r: this.props.rating,\n        d: this.props.default\n      });\n\n      // Gravatar service currently trims and lowercases all registered emails\n      var formattedEmail = ('' + this.props.email).trim().toLowerCase();\n\n      var hash = void 0;\n      if (this.props.md5) {\n        hash = this.props.md5;\n      } else if (typeof this.props.email === 'string') {\n        hash = (0, _md2.default)(formattedEmail, { encoding: \"binary\" });\n      } else {\n        console.warn('Gravatar image can not be fetched. Either the \"email\" or \"md5\" prop must be specified.');\n        return _react2.default.createElement('script', null);\n      }\n\n      var src = '' + base + hash + '?' + query;\n      var retinaSrc = '' + base + hash + '?' + retinaQuery;\n\n      var modernBrowser = true; // server-side, we render for modern browsers\n\n      if (typeof window !== 'undefined') {\n        // this is not NodeJS\n        modernBrowser = 'srcset' in document.createElement('img');\n      }\n\n      var className = 'react-gravatar';\n      if (this.props.className) {\n        className = className + ' ' + this.props.className;\n      }\n\n      // Clone this.props and then delete Component specific props so we can\n      // spread the rest into the img.\n\n      var rest = _objectWithoutProperties(this.props, []);\n\n      delete rest.md5;\n      delete rest.email;\n      delete rest.protocol;\n      delete rest.rating;\n      delete rest.size;\n      delete rest.style;\n      delete rest.className;\n      delete rest.default;\n      if (!modernBrowser && (0, _isRetina2.default)()) {\n        return _react2.default.createElement('img', _extends({\n          alt: 'Gravatar for ' + formattedEmail,\n          style: this.props.style,\n          src: retinaSrc,\n          height: this.props.size,\n          width: this.props.size\n        }, rest, {\n          className: className\n        }));\n      }\n      return _react2.default.createElement('img', _extends({\n        alt: 'Gravatar for ' + formattedEmail,\n        style: this.props.style,\n        src: src,\n        srcSet: retinaSrc + ' 2x',\n        height: this.props.size,\n        width: this.props.size\n      }, rest, {\n        className: className\n      }));\n    }\n  }]);\n\n  return Gravatar;\n}(_react2.default.Component);\n\nGravatar.displayName = 'Gravatar';\nGravatar.propTypes = {\n  email: _propTypes2.default.string,\n  md5: _propTypes2.default.string,\n  size: _propTypes2.default.number,\n  rating: _propTypes2.default.string,\n  default: _propTypes2.default.string,\n  className: _propTypes2.default.string,\n  protocol: _propTypes2.default.string,\n  style: _propTypes2.default.object\n};\nGravatar.defaultProps = {\n  size: 50,\n  rating: 'g',\n  default: 'retro',\n  protocol: '//'\n};\n\n\nmodule.exports = Gravatar;","module.exports = function() {\n  var mediaQuery;\n  if (typeof window !== \"undefined\" && window !== null) {\n    mediaQuery = \"(-webkit-min-device-pixel-ratio: 1.25), (min--moz-device-pixel-ratio: 1.25), (-o-min-device-pixel-ratio: 5/4), (min-resolution: 1.25dppx)\";\n    if (window.devicePixelRatio > 1.25) {\n      return true;\n    }\n    if (window.matchMedia && window.matchMedia(mediaQuery).matches) {\n      return true;\n    }\n  }\n  return false;\n};\n","(function(){\r\n  var crypt = require('crypt'),\r\n      utf8 = require('charenc').utf8,\r\n      isBuffer = require('is-buffer'),\r\n      bin = require('charenc').bin,\r\n\r\n  // The core\r\n  md5 = function (message, options) {\r\n    // Convert to byte array\r\n    if (message.constructor == String)\r\n      if (options && options.encoding === 'binary')\r\n        message = bin.stringToBytes(message);\r\n      else\r\n        message = utf8.stringToBytes(message);\r\n    else if (isBuffer(message))\r\n      message = Array.prototype.slice.call(message, 0);\r\n    else if (!Array.isArray(message))\r\n      message = message.toString();\r\n    // else, assume byte array already\r\n\r\n    var m = crypt.bytesToWords(message),\r\n        l = message.length * 8,\r\n        a =  1732584193,\r\n        b = -271733879,\r\n        c = -1732584194,\r\n        d =  271733878;\r\n\r\n    // Swap endian\r\n    for (var i = 0; i < m.length; i++) {\r\n      m[i] = ((m[i] <<  8) | (m[i] >>> 24)) & 0x00FF00FF |\r\n             ((m[i] << 24) | (m[i] >>>  8)) & 0xFF00FF00;\r\n    }\r\n\r\n    // Padding\r\n    m[l >>> 5] |= 0x80 << (l % 32);\r\n    m[(((l + 64) >>> 9) << 4) + 14] = l;\r\n\r\n    // Method shortcuts\r\n    var FF = md5._ff,\r\n        GG = md5._gg,\r\n        HH = md5._hh,\r\n        II = md5._ii;\r\n\r\n    for (var i = 0; i < m.length; i += 16) {\r\n\r\n      var aa = a,\r\n          bb = b,\r\n          cc = c,\r\n          dd = d;\r\n\r\n      a = FF(a, b, c, d, m[i+ 0],  7, -680876936);\r\n      d = FF(d, a, b, c, m[i+ 1], 12, -389564586);\r\n      c = FF(c, d, a, b, m[i+ 2], 17,  606105819);\r\n      b = FF(b, c, d, a, m[i+ 3], 22, -1044525330);\r\n      a = FF(a, b, c, d, m[i+ 4],  7, -176418897);\r\n      d = FF(d, a, b, c, m[i+ 5], 12,  1200080426);\r\n      c = FF(c, d, a, b, m[i+ 6], 17, -1473231341);\r\n      b = FF(b, c, d, a, m[i+ 7], 22, -45705983);\r\n      a = FF(a, b, c, d, m[i+ 8],  7,  1770035416);\r\n      d = FF(d, a, b, c, m[i+ 9], 12, -1958414417);\r\n      c = FF(c, d, a, b, m[i+10], 17, -42063);\r\n      b = FF(b, c, d, a, m[i+11], 22, -1990404162);\r\n      a = FF(a, b, c, d, m[i+12],  7,  1804603682);\r\n      d = FF(d, a, b, c, m[i+13], 12, -40341101);\r\n      c = FF(c, d, a, b, m[i+14], 17, -1502002290);\r\n      b = FF(b, c, d, a, m[i+15], 22,  1236535329);\r\n\r\n      a = GG(a, b, c, d, m[i+ 1],  5, -165796510);\r\n      d = GG(d, a, b, c, m[i+ 6],  9, -1069501632);\r\n      c = GG(c, d, a, b, m[i+11], 14,  643717713);\r\n      b = GG(b, c, d, a, m[i+ 0], 20, -373897302);\r\n      a = GG(a, b, c, d, m[i+ 5],  5, -701558691);\r\n      d = GG(d, a, b, c, m[i+10],  9,  38016083);\r\n      c = GG(c, d, a, b, m[i+15], 14, -660478335);\r\n      b = GG(b, c, d, a, m[i+ 4], 20, -405537848);\r\n      a = GG(a, b, c, d, m[i+ 9],  5,  568446438);\r\n      d = GG(d, a, b, c, m[i+14],  9, -1019803690);\r\n      c = GG(c, d, a, b, m[i+ 3], 14, -187363961);\r\n      b = GG(b, c, d, a, m[i+ 8], 20,  1163531501);\r\n      a = GG(a, b, c, d, m[i+13],  5, -1444681467);\r\n      d = GG(d, a, b, c, m[i+ 2],  9, -51403784);\r\n      c = GG(c, d, a, b, m[i+ 7], 14,  1735328473);\r\n      b = GG(b, c, d, a, m[i+12], 20, -1926607734);\r\n\r\n      a = HH(a, b, c, d, m[i+ 5],  4, -378558);\r\n      d = HH(d, a, b, c, m[i+ 8], 11, -2022574463);\r\n      c = HH(c, d, a, b, m[i+11], 16,  1839030562);\r\n      b = HH(b, c, d, a, m[i+14], 23, -35309556);\r\n      a = HH(a, b, c, d, m[i+ 1],  4, -1530992060);\r\n      d = HH(d, a, b, c, m[i+ 4], 11,  1272893353);\r\n      c = HH(c, d, a, b, m[i+ 7], 16, -155497632);\r\n      b = HH(b, c, d, a, m[i+10], 23, -1094730640);\r\n      a = HH(a, b, c, d, m[i+13],  4,  681279174);\r\n      d = HH(d, a, b, c, m[i+ 0], 11, -358537222);\r\n      c = HH(c, d, a, b, m[i+ 3], 16, -722521979);\r\n      b = HH(b, c, d, a, m[i+ 6], 23,  76029189);\r\n      a = HH(a, b, c, d, m[i+ 9],  4, -640364487);\r\n      d = HH(d, a, b, c, m[i+12], 11, -421815835);\r\n      c = HH(c, d, a, b, m[i+15], 16,  530742520);\r\n      b = HH(b, c, d, a, m[i+ 2], 23, -995338651);\r\n\r\n      a = II(a, b, c, d, m[i+ 0],  6, -198630844);\r\n      d = II(d, a, b, c, m[i+ 7], 10,  1126891415);\r\n      c = II(c, d, a, b, m[i+14], 15, -1416354905);\r\n      b = II(b, c, d, a, m[i+ 5], 21, -57434055);\r\n      a = II(a, b, c, d, m[i+12],  6,  1700485571);\r\n      d = II(d, a, b, c, m[i+ 3], 10, -1894986606);\r\n      c = II(c, d, a, b, m[i+10], 15, -1051523);\r\n      b = II(b, c, d, a, m[i+ 1], 21, -2054922799);\r\n      a = II(a, b, c, d, m[i+ 8],  6,  1873313359);\r\n      d = II(d, a, b, c, m[i+15], 10, -30611744);\r\n      c = II(c, d, a, b, m[i+ 6], 15, -1560198380);\r\n      b = II(b, c, d, a, m[i+13], 21,  1309151649);\r\n      a = II(a, b, c, d, m[i+ 4],  6, -145523070);\r\n      d = II(d, a, b, c, m[i+11], 10, -1120210379);\r\n      c = II(c, d, a, b, m[i+ 2], 15,  718787259);\r\n      b = II(b, c, d, a, m[i+ 9], 21, -343485551);\r\n\r\n      a = (a + aa) >>> 0;\r\n      b = (b + bb) >>> 0;\r\n      c = (c + cc) >>> 0;\r\n      d = (d + dd) >>> 0;\r\n    }\r\n\r\n    return crypt.endian([a, b, c, d]);\r\n  };\r\n\r\n  // Auxiliary functions\r\n  md5._ff  = function (a, b, c, d, x, s, t) {\r\n    var n = a + (b & c | ~b & d) + (x >>> 0) + t;\r\n    return ((n << s) | (n >>> (32 - s))) + b;\r\n  };\r\n  md5._gg  = function (a, b, c, d, x, s, t) {\r\n    var n = a + (b & d | c & ~d) + (x >>> 0) + t;\r\n    return ((n << s) | (n >>> (32 - s))) + b;\r\n  };\r\n  md5._hh  = function (a, b, c, d, x, s, t) {\r\n    var n = a + (b ^ c ^ d) + (x >>> 0) + t;\r\n    return ((n << s) | (n >>> (32 - s))) + b;\r\n  };\r\n  md5._ii  = function (a, b, c, d, x, s, t) {\r\n    var n = a + (c ^ (b | ~d)) + (x >>> 0) + t;\r\n    return ((n << s) | (n >>> (32 - s))) + b;\r\n  };\r\n\r\n  // Package private blocksize\r\n  md5._blocksize = 16;\r\n  md5._digestsize = 16;\r\n\r\n  module.exports = function (message, options) {\r\n    if (message === undefined || message === null)\r\n      throw new Error('Illegal argument ' + message);\r\n\r\n    var digestbytes = crypt.wordsToBytes(md5(message, options));\r\n    return options && options.asBytes ? digestbytes :\r\n        options && options.asString ? bin.bytesToString(digestbytes) :\r\n        crypt.bytesToHex(digestbytes);\r\n  };\r\n\r\n})();\r\n","var charenc = {\n  // UTF-8 encoding\n  utf8: {\n    // Convert a string to a byte array\n    stringToBytes: function(str) {\n      return charenc.bin.stringToBytes(unescape(encodeURIComponent(str)));\n    },\n\n    // Convert a byte array to a string\n    bytesToString: function(bytes) {\n      return decodeURIComponent(escape(charenc.bin.bytesToString(bytes)));\n    }\n  },\n\n  // Binary encoding\n  bin: {\n    // Convert a string to a byte array\n    stringToBytes: function(str) {\n      for (var bytes = [], i = 0; i < str.length; i++)\n        bytes.push(str.charCodeAt(i) & 0xFF);\n      return bytes;\n    },\n\n    // Convert a byte array to a string\n    bytesToString: function(bytes) {\n      for (var str = [], i = 0; i < bytes.length; i++)\n        str.push(String.fromCharCode(bytes[i]));\n      return str.join('');\n    }\n  }\n};\n\nmodule.exports = charenc;\n","(function() {\n  var base64map\n      = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',\n\n  crypt = {\n    // Bit-wise rotation left\n    rotl: function(n, b) {\n      return (n << b) | (n >>> (32 - b));\n    },\n\n    // Bit-wise rotation right\n    rotr: function(n, b) {\n      return (n << (32 - b)) | (n >>> b);\n    },\n\n    // Swap big-endian to little-endian and vice versa\n    endian: function(n) {\n      // If number given, swap endian\n      if (n.constructor == Number) {\n        return crypt.rotl(n, 8) & 0x00FF00FF | crypt.rotl(n, 24) & 0xFF00FF00;\n      }\n\n      // Else, assume array and swap all items\n      for (var i = 0; i < n.length; i++)\n        n[i] = crypt.endian(n[i]);\n      return n;\n    },\n\n    // Generate an array of any length of random bytes\n    randomBytes: function(n) {\n      for (var bytes = []; n > 0; n--)\n        bytes.push(Math.floor(Math.random() * 256));\n      return bytes;\n    },\n\n    // Convert a byte array to big-endian 32-bit words\n    bytesToWords: function(bytes) {\n      for (var words = [], i = 0, b = 0; i < bytes.length; i++, b += 8)\n        words[b >>> 5] |= bytes[i] << (24 - b % 32);\n      return words;\n    },\n\n    // Convert big-endian 32-bit words to a byte array\n    wordsToBytes: function(words) {\n      for (var bytes = [], b = 0; b < words.length * 32; b += 8)\n        bytes.push((words[b >>> 5] >>> (24 - b % 32)) & 0xFF);\n      return bytes;\n    },\n\n    // Convert a byte array to a hex string\n    bytesToHex: function(bytes) {\n      for (var hex = [], i = 0; i < bytes.length; i++) {\n        hex.push((bytes[i] >>> 4).toString(16));\n        hex.push((bytes[i] & 0xF).toString(16));\n      }\n      return hex.join('');\n    },\n\n    // Convert a hex string to a byte array\n    hexToBytes: function(hex) {\n      for (var bytes = [], c = 0; c < hex.length; c += 2)\n        bytes.push(parseInt(hex.substr(c, 2), 16));\n      return bytes;\n    },\n\n    // Convert a byte array to a base-64 string\n    bytesToBase64: function(bytes) {\n      for (var base64 = [], i = 0; i < bytes.length; i += 3) {\n        var triplet = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];\n        for (var j = 0; j < 4; j++)\n          if (i * 8 + j * 6 <= bytes.length * 8)\n            base64.push(base64map.charAt((triplet >>> 6 * (3 - j)) & 0x3F));\n          else\n            base64.push('=');\n      }\n      return base64.join('');\n    },\n\n    // Convert a base-64 string to a byte array\n    base64ToBytes: function(base64) {\n      // Remove non-base-64 characters\n      base64 = base64.replace(/[^A-Z0-9+\\/]/ig, '');\n\n      for (var bytes = [], i = 0, imod4 = 0; i < base64.length;\n          imod4 = ++i % 4) {\n        if (imod4 == 0) continue;\n        bytes.push(((base64map.indexOf(base64.charAt(i - 1))\n            & (Math.pow(2, -2 * imod4 + 8) - 1)) << (imod4 * 2))\n            | (base64map.indexOf(base64.charAt(i)) >>> (6 - imod4 * 2)));\n      }\n      return bytes;\n    }\n  };\n\n  module.exports = crypt;\n})();\n","/*!\n * Determine if an object is a Buffer\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n\n// The _isBuffer check is for Safari 5-7 support, because it's missing\n// Object.prototype.constructor. Remove this eventually\nmodule.exports = function (obj) {\n  return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)\n}\n\nfunction isBuffer (obj) {\n  return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)\n}\n\n// For Node v0.10 support. Remove this eventually.\nfunction isSlowBuffer (obj) {\n  return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))\n}\n","'use strict';\nvar strictUriEncode = require('strict-uri-encode');\nvar objectAssign = require('object-assign');\n\nfunction encoderForArrayFormat(opts) {\n\tswitch (opts.arrayFormat) {\n\t\tcase 'index':\n\t\t\treturn function (key, value, index) {\n\t\t\t\treturn value === null ? [\n\t\t\t\t\tencode(key, opts),\n\t\t\t\t\t'[',\n\t\t\t\t\tindex,\n\t\t\t\t\t']'\n\t\t\t\t].join('') : [\n\t\t\t\t\tencode(key, opts),\n\t\t\t\t\t'[',\n\t\t\t\t\tencode(index, opts),\n\t\t\t\t\t']=',\n\t\t\t\t\tencode(value, opts)\n\t\t\t\t].join('');\n\t\t\t};\n\n\t\tcase 'bracket':\n\t\t\treturn function (key, value) {\n\t\t\t\treturn value === null ? encode(key, opts) : [\n\t\t\t\t\tencode(key, opts),\n\t\t\t\t\t'[]=',\n\t\t\t\t\tencode(value, opts)\n\t\t\t\t].join('');\n\t\t\t};\n\n\t\tdefault:\n\t\t\treturn function (key, value) {\n\t\t\t\treturn value === null ? encode(key, opts) : [\n\t\t\t\t\tencode(key, opts),\n\t\t\t\t\t'=',\n\t\t\t\t\tencode(value, opts)\n\t\t\t\t].join('');\n\t\t\t};\n\t}\n}\n\nfunction parserForArrayFormat(opts) {\n\tvar result;\n\n\tswitch (opts.arrayFormat) {\n\t\tcase 'index':\n\t\t\treturn function (key, value, accumulator) {\n\t\t\t\tresult = /\\[(\\d*)\\]$/.exec(key);\n\n\t\t\t\tkey = key.replace(/\\[\\d*\\]$/, '');\n\n\t\t\t\tif (!result) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = {};\n\t\t\t\t}\n\n\t\t\t\taccumulator[key][result[1]] = value;\n\t\t\t};\n\n\t\tcase 'bracket':\n\t\t\treturn function (key, value, accumulator) {\n\t\t\t\tresult = /(\\[\\])$/.exec(key);\n\t\t\t\tkey = key.replace(/\\[\\]$/, '');\n\n\t\t\t\tif (!result) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t} else if (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = [value];\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\taccumulator[key] = [].concat(accumulator[key], value);\n\t\t\t};\n\n\t\tdefault:\n\t\t\treturn function (key, value, accumulator) {\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\taccumulator[key] = [].concat(accumulator[key], value);\n\t\t\t};\n\t}\n}\n\nfunction encode(value, opts) {\n\tif (opts.encode) {\n\t\treturn opts.strict ? strictUriEncode(value) : encodeURIComponent(value);\n\t}\n\n\treturn value;\n}\n\nfunction keysSorter(input) {\n\tif (Array.isArray(input)) {\n\t\treturn input.sort();\n\t} else if (typeof input === 'object') {\n\t\treturn keysSorter(Object.keys(input)).sort(function (a, b) {\n\t\t\treturn Number(a) - Number(b);\n\t\t}).map(function (key) {\n\t\t\treturn input[key];\n\t\t});\n\t}\n\n\treturn input;\n}\n\nexports.extract = function (str) {\n\treturn str.split('?')[1] || '';\n};\n\nexports.parse = function (str, opts) {\n\topts = objectAssign({arrayFormat: 'none'}, opts);\n\n\tvar formatter = parserForArrayFormat(opts);\n\n\t// Create an object with no prototype\n\t// https://github.com/sindresorhus/query-string/issues/47\n\tvar ret = Object.create(null);\n\n\tif (typeof str !== 'string') {\n\t\treturn ret;\n\t}\n\n\tstr = str.trim().replace(/^(\\?|#|&)/, '');\n\n\tif (!str) {\n\t\treturn ret;\n\t}\n\n\tstr.split('&').forEach(function (param) {\n\t\tvar parts = param.replace(/\\+/g, ' ').split('=');\n\t\t// Firefox (pre 40) decodes `%3D` to `=`\n\t\t// https://github.com/sindresorhus/query-string/pull/37\n\t\tvar key = parts.shift();\n\t\tvar val = parts.length > 0 ? parts.join('=') : undefined;\n\n\t\t// missing `=` should be `null`:\n\t\t// http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters\n\t\tval = val === undefined ? null : decodeURIComponent(val);\n\n\t\tformatter(decodeURIComponent(key), val, ret);\n\t});\n\n\treturn Object.keys(ret).sort().reduce(function (result, key) {\n\t\tvar val = ret[key];\n\t\tif (Boolean(val) && typeof val === 'object' && !Array.isArray(val)) {\n\t\t\t// Sort object keys, not values\n\t\t\tresult[key] = keysSorter(val);\n\t\t} else {\n\t\t\tresult[key] = val;\n\t\t}\n\n\t\treturn result;\n\t}, Object.create(null));\n};\n\nexports.stringify = function (obj, opts) {\n\tvar defaults = {\n\t\tencode: true,\n\t\tstrict: true,\n\t\tarrayFormat: 'none'\n\t};\n\n\topts = objectAssign(defaults, opts);\n\n\tvar formatter = encoderForArrayFormat(opts);\n\n\treturn obj ? Object.keys(obj).sort().map(function (key) {\n\t\tvar val = obj[key];\n\n\t\tif (val === undefined) {\n\t\t\treturn '';\n\t\t}\n\n\t\tif (val === null) {\n\t\t\treturn encode(key, opts);\n\t\t}\n\n\t\tif (Array.isArray(val)) {\n\t\t\tvar result = [];\n\n\t\t\tval.slice().forEach(function (val2) {\n\t\t\t\tif (val2 === undefined) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tresult.push(formatter(key, val2, result.length));\n\t\t\t});\n\n\t\t\treturn result.join('&');\n\t\t}\n\n\t\treturn encode(key, opts) + '=' + encode(val, opts);\n\t}).filter(function (x) {\n\t\treturn x.length > 0;\n\t}).join('&') : '';\n};\n","/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc');  // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n","'use strict';\nmodule.exports = function (str) {\n\treturn encodeURIComponent(str).replace(/[!'()*]/g, function (c) {\n\t\treturn '%' + c.charCodeAt(0).toString(16).toUpperCase();\n\t});\n};\n","module.exports =\n/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tmodule.exports = __webpack_require__(1);\n\n\n/***/ },\n/* 1 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tvar _Highlighter = __webpack_require__(2);\n\t\n\tvar _Highlighter2 = _interopRequireDefault(_Highlighter);\n\t\n\tvar _utils = __webpack_require__(4);\n\t\n\texports['default'] = _Highlighter2['default'];\n\texports.combineChunks = _utils.combineChunks;\n\texports.fillInChunks = _utils.fillInChunks;\n\texports.findAll = _utils.findAll;\n\texports.findChunks = _utils.findChunks;\n\n/***/ },\n/* 2 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\texports['default'] = Highlighter;\n\t\n\tfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tvar _react = __webpack_require__(3);\n\t\n\tvar _react2 = _interopRequireDefault(_react);\n\t\n\tvar _utilsJs = __webpack_require__(4);\n\t\n\tvar Chunks = _interopRequireWildcard(_utilsJs);\n\t\n\tHighlighter.propTypes = {\n\t  highlightClassName: _react.PropTypes.string,\n\t  highlightStyle: _react.PropTypes.object,\n\t  searchWords: _react.PropTypes.arrayOf(_react.PropTypes.string).isRequired,\n\t  textToHighlight: _react.PropTypes.string.isRequired,\n\t  sanitize: _react.PropTypes.func\n\t};\n\t\n\t/**\n\t * Highlights all occurrences of search terms (searchText) within a string (textToHighlight).\n\t * This function returns an array of strings and <span>s (wrapping highlighted words).\n\t */\n\t\n\tfunction Highlighter(_ref) {\n\t  var _ref$highlightClassName = _ref.highlightClassName;\n\t  var highlightClassName = _ref$highlightClassName === undefined ? '' : _ref$highlightClassName;\n\t  var _ref$highlightStyle = _ref.highlightStyle;\n\t  var highlightStyle = _ref$highlightStyle === undefined ? {} : _ref$highlightStyle;\n\t  var searchWords = _ref.searchWords;\n\t  var textToHighlight = _ref.textToHighlight;\n\t  var sanitize = _ref.sanitize;\n\t\n\t  var chunks = Chunks.findAll(textToHighlight, searchWords, sanitize);\n\t\n\t  return _react2['default'].createElement(\n\t    'span',\n\t    null,\n\t    chunks.map(function (chunk, index) {\n\t      var text = textToHighlight.substr(chunk.start, chunk.end - chunk.start);\n\t\n\t      if (chunk.highlight) {\n\t        return _react2['default'].createElement(\n\t          'mark',\n\t          {\n\t            className: highlightClassName,\n\t            key: index,\n\t            style: highlightStyle\n\t          },\n\t          text\n\t        );\n\t      } else {\n\t        return _react2['default'].createElement(\n\t          'span',\n\t          { key: index },\n\t          text\n\t        );\n\t      }\n\t    })\n\t  );\n\t}\n\t\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 3 */\n/***/ function(module, exports) {\n\n\tmodule.exports = require(\"react\");\n\n/***/ },\n/* 4 */\n/***/ function(module, exports) {\n\n\t/**\n\t * Creates an array of chunk objects representing both higlightable and non highlightable pieces of text that match each search word.\n\t * @param searchWords string[]\n\t * @param textToSearch string\n\t * @return {start:number, end:number, highlight:boolean}[]\n\t */\n\t'use strict';\n\t\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\tvar findAll = function findAll(textToSearch, wordsToFind, sanitize) {\n\t  return fillInChunks(combineChunks(findChunks(textToSearch, wordsToFind, sanitize)), textToSearch.length);\n\t};\n\t\n\texports.findAll = findAll;\n\t/**\n\t * Takes an array of {start:number, end:number} objects and combines chunks that overlap into single chunks.\n\t * @param chunks {start:number, end:number}[]\n\t * @return {start:number, end:number}[]\n\t */\n\tvar combineChunks = function combineChunks(chunks) {\n\t  chunks = chunks.sort(function (first, second) {\n\t    return first.start - second.start;\n\t  }).reduce(function (processedChunks, nextChunk) {\n\t    // First chunk just goes straight in the array...\n\t    if (processedChunks.length === 0) {\n\t      return [nextChunk];\n\t    } else {\n\t      // ... subsequent chunks get checked to see if they overlap...\n\t      var prevChunk = processedChunks.pop();\n\t      if (nextChunk.start <= prevChunk.end) {\n\t        // It may be the case that prevChunk completely surrounds nextChunk, so take the\n\t        // largest of the end indeces.\n\t        var endIndex = Math.max(prevChunk.end, nextChunk.end);\n\t        processedChunks.push({ start: prevChunk.start, end: endIndex });\n\t      } else {\n\t        processedChunks.push(prevChunk, nextChunk);\n\t      }\n\t      return processedChunks;\n\t    }\n\t  }, []);\n\t\n\t  return chunks;\n\t};\n\t\n\texports.combineChunks = combineChunks;\n\t/**\n\t * Examine textToSearch for any matches.\n\t * If we find matches, add them to the returned array as a \"chunk\" object ({start:number, end:number}).\n\t * @param textToSearch string\n\t * @param wordsToFind string[]\n\t * @param sanitize Process and optionally modify textToSearch and wordsToFind before comparison; this can be used to eg. remove accents\n\t * @return {start:number, end:number}[]\n\t */\n\tvar findChunks = function findChunks(textToSearch, wordsToFind) {\n\t  var sanitize = arguments.length <= 2 || arguments[2] === undefined ? identity : arguments[2];\n\t  return wordsToFind.filter(function (searchWord) {\n\t    return searchWord;\n\t  }) // Remove empty words\n\t  .reduce(function (chunks, searchWord) {\n\t    var normalizedWord = sanitize(searchWord);\n\t    var normalizedText = sanitize(textToSearch);\n\t    var regex = new RegExp(normalizedWord, 'gi');\n\t    var match = undefined;\n\t    while ((match = regex.exec(normalizedText)) != null) {\n\t      chunks.push({ start: match.index, end: regex.lastIndex });\n\t    }\n\t    return chunks;\n\t  }, []);\n\t};\n\t\n\texports.findChunks = findChunks;\n\t/**\n\t * Given a set of chunks to highlight, create an additional set of chunks\n\t * to represent the bits of text between the highlighted text.\n\t * @param chunksToHighlight {start:number, end:number}[]\n\t * @param totalLength number\n\t * @return {start:number, end:number, highlight:boolean}[]\n\t */\n\tvar fillInChunks = function fillInChunks(chunksToHighlight, totalLength) {\n\t  var allChunks = [];\n\t  var append = function append(start, end, highlight) {\n\t    if (end - start > 0) {\n\t      allChunks.push({ start: start, end: end, highlight: highlight });\n\t    }\n\t  };\n\t\n\t  if (chunksToHighlight.length === 0) {\n\t    append(0, totalLength, false);\n\t  } else {\n\t    (function () {\n\t      var lastIndex = 0;\n\t      chunksToHighlight.forEach(function (chunk) {\n\t        append(lastIndex, chunk.start, false);\n\t        append(chunk.start, chunk.end, true);\n\t        lastIndex = chunk.end;\n\t      });\n\t      append(lastIndex, totalLength, false);\n\t    })();\n\t  }\n\t  return allChunks;\n\t};\n\t\n\texports.fillInChunks = fillInChunks;\n\tfunction identity(value) {\n\t  return value;\n\t}\n\n/***/ }\n/******/ ]);\n//# sourceMappingURL=main.js.map","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _reactSelect = require('react-select');\n\nvar _reactSelect2 = _interopRequireDefault(_reactSelect);\n\nvar _reactVirtualized = require('react-virtualized');\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar VirtualizedSelect = function (_Component) {\n  _inherits(VirtualizedSelect, _Component);\n\n  function VirtualizedSelect(props, context) {\n    _classCallCheck(this, VirtualizedSelect);\n\n    var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(VirtualizedSelect).call(this, props, context));\n\n    _this._renderMenu = _this._renderMenu.bind(_this);\n    _this._optionRenderer = _this._optionRenderer.bind(_this);\n    return _this;\n  }\n\n  /** See VirtualScroll#recomputeRowHeights */\n\n\n  _createClass(VirtualizedSelect, [{\n    key: 'recomputeOptionHeights',\n    value: function recomputeOptionHeights() {\n      var index = arguments.length <= 0 || arguments[0] === undefined ? 0 : arguments[0];\n\n      if (this._virtualScroll) {\n        this._virtualScroll.recomputeRowHeights(index);\n      }\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      var SelectComponent = this._getSelectComponent();\n\n      return _react2.default.createElement(SelectComponent, _extends({}, this.props, {\n        menuRenderer: this._renderMenu,\n        menuStyle: { overflow: 'hidden' }\n      }));\n    }\n\n    // See https://github.com/JedWatson/react-select/#effeciently-rendering-large-lists-with-windowing\n\n  }, {\n    key: '_renderMenu',\n    value: function _renderMenu(_ref) {\n      var _this2 = this;\n\n      var focusedOption = _ref.focusedOption;\n      var focusOption = _ref.focusOption;\n      var labelKey = _ref.labelKey;\n      var options = _ref.options;\n      var selectValue = _ref.selectValue;\n      var valueArray = _ref.valueArray;\n      var optionRenderer = this.props.optionRenderer;\n\n      var focusedOptionIndex = options.indexOf(focusedOption);\n      var height = this._calculateVirtualScrollHeight({ options: options });\n      var innerRowRenderer = optionRenderer || this._optionRenderer;\n\n      function wrappedRowRenderer(_ref2) {\n        var index = _ref2.index;\n\n        var option = options[index];\n\n        return innerRowRenderer({\n          focusedOption: focusedOption,\n          focusedOptionIndex: focusedOptionIndex,\n          focusOption: focusOption,\n          labelKey: labelKey,\n          option: option,\n          optionIndex: index,\n          options: options,\n          selectValue: selectValue,\n          valueArray: valueArray\n        });\n      }\n\n      return _react2.default.createElement(\n        _reactVirtualized.AutoSizer,\n        { disableHeight: true },\n        function (_ref3) {\n          var width = _ref3.width;\n          return _react2.default.createElement(_reactVirtualized.VirtualScroll, {\n            className: 'VirtualSelectGrid',\n            height: height,\n            ref: function ref(_ref5) {\n              return _this2._virtualScroll = _ref5;\n            },\n            rowCount: options.length,\n            rowHeight: function rowHeight(_ref4) {\n              var index = _ref4.index;\n              return _this2._getOptionHeight({\n                option: options[index]\n              });\n            },\n            rowRenderer: wrappedRowRenderer,\n            scrollToIndex: focusedOptionIndex,\n            width: width\n          });\n        }\n      );\n    }\n  }, {\n    key: '_calculateVirtualScrollHeight',\n    value: function _calculateVirtualScrollHeight(_ref6) {\n      var options = _ref6.options;\n      var maxHeight = this.props.maxHeight;\n\n\n      var height = 0;\n\n      for (var optionIndex = 0; optionIndex < options.length; optionIndex++) {\n        var option = options[optionIndex];\n\n        height += this._getOptionHeight({ option: option });\n\n        if (height > maxHeight) {\n          return maxHeight;\n        }\n      }\n\n      return height;\n    }\n  }, {\n    key: '_getOptionHeight',\n    value: function _getOptionHeight(_ref7) {\n      var option = _ref7.option;\n      var optionHeight = this.props.optionHeight;\n\n\n      return optionHeight instanceof Function ? optionHeight({ option: option }) : optionHeight;\n    }\n  }, {\n    key: '_getSelectComponent',\n    value: function _getSelectComponent() {\n      var _props = this.props;\n      var async = _props.async;\n      var selectComponent = _props.selectComponent;\n\n\n      if (selectComponent) {\n        return selectComponent;\n      } else if (async) {\n        return _reactSelect2.default.Async;\n      } else {\n        return _reactSelect2.default;\n      }\n    }\n  }, {\n    key: '_optionRenderer',\n    value: function _optionRenderer(_ref8) {\n      var focusedOption = _ref8.focusedOption;\n      var focusOption = _ref8.focusOption;\n      var labelKey = _ref8.labelKey;\n      var option = _ref8.option;\n      var selectValue = _ref8.selectValue;\n\n      var height = this._getOptionHeight({ option: option });\n\n      var className = ['VirtualizedSelectOption'];\n\n      if (option === focusedOption) {\n        className.push('VirtualizedSelectFocusedOption');\n      }\n\n      if (option.disabled) {\n        className.push('VirtualizedSelectDisabledOption');\n      }\n\n      var events = option.disabled ? {} : {\n        onClick: function onClick() {\n          return selectValue(option);\n        },\n        onMouseOver: function onMouseOver() {\n          return focusOption(option);\n        }\n      };\n\n      return _react2.default.createElement(\n        'div',\n        _extends({\n          className: className.join(' '),\n          style: { height: height }\n        }, events),\n        option[labelKey]\n      );\n    }\n  }]);\n\n  return VirtualizedSelect;\n}(_react.Component);\n\nVirtualizedSelect.propTypes = {\n  async: _react.PropTypes.bool,\n  maxHeight: _react.PropTypes.number.isRequired,\n  optionHeight: _react.PropTypes.oneOfType([_react.PropTypes.number, _react.PropTypes.func]).isRequired,\n  optionRenderer: _react.PropTypes.func,\n  selectComponent: _react.PropTypes.func\n};\nVirtualizedSelect.defaultProps = {\n  async: false,\n  maxHeight: 200,\n  optionHeight: 35\n};\nexports.default = VirtualizedSelect;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = undefined;\n\nvar _VirtualizedSelect = require('./VirtualizedSelect');\n\nvar _VirtualizedSelect2 = _interopRequireDefault(_VirtualizedSelect);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = _VirtualizedSelect2.default;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _reactAddonsShallowCompare = require('react-addons-shallow-compare');\n\nvar _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/**\n * This HOC decorates a virtualized component and responds to arrow-key events by scrolling one row or column at a time.\n */\nvar ArrowKeyStepper = function (_Component) {\n  _inherits(ArrowKeyStepper, _Component);\n\n  function ArrowKeyStepper(props, context) {\n    _classCallCheck(this, ArrowKeyStepper);\n\n    var _this = _possibleConstructorReturn(this, (ArrowKeyStepper.__proto__ || Object.getPrototypeOf(ArrowKeyStepper)).call(this, props, context));\n\n    _this.state = {\n      scrollToColumn: 0,\n      scrollToRow: 0\n    };\n\n    _this._columnStartIndex = 0;\n    _this._columnStopIndex = 0;\n    _this._rowStartIndex = 0;\n    _this._rowStopIndex = 0;\n\n    _this._onKeyDown = _this._onKeyDown.bind(_this);\n    _this._onSectionRendered = _this._onSectionRendered.bind(_this);\n    return _this;\n  }\n\n  _createClass(ArrowKeyStepper, [{\n    key: 'render',\n    value: function render() {\n      var _props = this.props;\n      var className = _props.className;\n      var children = _props.children;\n      var _state = this.state;\n      var scrollToColumn = _state.scrollToColumn;\n      var scrollToRow = _state.scrollToRow;\n\n\n      return _react2.default.createElement(\n        'div',\n        {\n          className: className,\n          onKeyDown: this._onKeyDown\n        },\n        children({\n          onSectionRendered: this._onSectionRendered,\n          scrollToColumn: scrollToColumn,\n          scrollToRow: scrollToRow\n        })\n      );\n    }\n  }, {\n    key: 'shouldComponentUpdate',\n    value: function shouldComponentUpdate(nextProps, nextState) {\n      return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState);\n    }\n  }, {\n    key: '_onKeyDown',\n    value: function _onKeyDown(event) {\n      var _props2 = this.props;\n      var columnCount = _props2.columnCount;\n      var rowCount = _props2.rowCount;\n\n      // The above cases all prevent default event event behavior.\n      // This is to keep the grid from scrolling after the snap-to update.\n\n      switch (event.key) {\n        case 'ArrowDown':\n          event.preventDefault();\n          this.setState({\n            scrollToRow: Math.min(this._rowStopIndex + 1, rowCount - 1)\n          });\n          break;\n        case 'ArrowLeft':\n          event.preventDefault();\n          this.setState({\n            scrollToColumn: Math.max(this._columnStartIndex - 1, 0)\n          });\n          break;\n        case 'ArrowRight':\n          event.preventDefault();\n          this.setState({\n            scrollToColumn: Math.min(this._columnStopIndex + 1, columnCount - 1)\n          });\n          break;\n        case 'ArrowUp':\n          event.preventDefault();\n          this.setState({\n            scrollToRow: Math.max(this._rowStartIndex - 1, 0)\n          });\n          break;\n      }\n    }\n  }, {\n    key: '_onSectionRendered',\n    value: function _onSectionRendered(_ref) {\n      var columnStartIndex = _ref.columnStartIndex;\n      var columnStopIndex = _ref.columnStopIndex;\n      var rowStartIndex = _ref.rowStartIndex;\n      var rowStopIndex = _ref.rowStopIndex;\n\n      this._columnStartIndex = columnStartIndex;\n      this._columnStopIndex = columnStopIndex;\n      this._rowStartIndex = rowStartIndex;\n      this._rowStopIndex = rowStopIndex;\n    }\n  }]);\n\n  return ArrowKeyStepper;\n}(_react.Component);\n\nArrowKeyStepper.propTypes = {\n  children: _react.PropTypes.func.isRequired,\n  className: _react.PropTypes.string,\n  columnCount: _react.PropTypes.number.isRequired,\n  rowCount: _react.PropTypes.number.isRequired\n};\nexports.default = ArrowKeyStepper;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.ArrowKeyStepper = exports.default = undefined;\n\nvar _ArrowKeyStepper2 = require('./ArrowKeyStepper');\n\nvar _ArrowKeyStepper3 = _interopRequireDefault(_ArrowKeyStepper2);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = _ArrowKeyStepper3.default;\nexports.ArrowKeyStepper = _ArrowKeyStepper3.default;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _reactAddonsShallowCompare = require('react-addons-shallow-compare');\n\nvar _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/**\n * Decorator component that automatically adjusts the width and height of a single child.\n * Child component should not be declared as a child but should rather be specified by a `ChildComponent` property.\n * All other properties will be passed through to the child component.\n */\nvar AutoSizer = function (_Component) {\n  _inherits(AutoSizer, _Component);\n\n  function AutoSizer(props) {\n    _classCallCheck(this, AutoSizer);\n\n    var _this = _possibleConstructorReturn(this, (AutoSizer.__proto__ || Object.getPrototypeOf(AutoSizer)).call(this, props));\n\n    _this.state = {\n      height: 0,\n      width: 0\n    };\n\n    _this._onResize = _this._onResize.bind(_this);\n    _this._onScroll = _this._onScroll.bind(_this);\n    _this._setRef = _this._setRef.bind(_this);\n    return _this;\n  }\n\n  _createClass(AutoSizer, [{\n    key: 'componentDidMount',\n    value: function componentDidMount() {\n      // Delay access of parentNode until mount.\n      // This handles edge-cases where the component has already been unmounted before its ref has been set,\n      // As well as libraries like react-lite which have a slightly different lifecycle.\n      this._parentNode = this._autoSizer.parentNode;\n\n      // Defer requiring resize handler in order to support server-side rendering.\n      // See issue #41\n      this._detectElementResize = require('../vendor/detectElementResize');\n      this._detectElementResize.addResizeListener(this._parentNode, this._onResize);\n\n      this._onResize();\n    }\n  }, {\n    key: 'componentWillUnmount',\n    value: function componentWillUnmount() {\n      if (this._detectElementResize) {\n        this._detectElementResize.removeResizeListener(this._parentNode, this._onResize);\n      }\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      var _props = this.props;\n      var children = _props.children;\n      var disableHeight = _props.disableHeight;\n      var disableWidth = _props.disableWidth;\n      var _state = this.state;\n      var height = _state.height;\n      var width = _state.width;\n\n      // Outer div should not force width/height since that may prevent containers from shrinking.\n      // Inner component should overflow and use calculated width/height.\n      // See issue #68 for more information.\n\n      var outerStyle = { overflow: 'visible' };\n\n      if (!disableHeight) {\n        outerStyle.height = 0;\n      }\n\n      if (!disableWidth) {\n        outerStyle.width = 0;\n      }\n\n      return _react2.default.createElement(\n        'div',\n        {\n          ref: this._setRef,\n          onScroll: this._onScroll,\n          style: outerStyle\n        },\n        children({ height: height, width: width })\n      );\n    }\n  }, {\n    key: 'shouldComponentUpdate',\n    value: function shouldComponentUpdate(nextProps, nextState) {\n      return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState);\n    }\n  }, {\n    key: '_onResize',\n    value: function _onResize() {\n      var onResize = this.props.onResize;\n\n      // Gaurd against AutoSizer component being removed from the DOM immediately after being added.\n      // This can result in invalid style values which can result in NaN values if we don't handle them.\n      // See issue #150 for more context.\n\n      var boundingRect = this._parentNode.getBoundingClientRect();\n      var height = boundingRect.height || 0;\n      var width = boundingRect.width || 0;\n\n      var style = getComputedStyle(this._parentNode);\n      var paddingLeft = parseInt(style.paddingLeft, 10) || 0;\n      var paddingRight = parseInt(style.paddingRight, 10) || 0;\n      var paddingTop = parseInt(style.paddingTop, 10) || 0;\n      var paddingBottom = parseInt(style.paddingBottom, 10) || 0;\n\n      this.setState({\n        height: height - paddingTop - paddingBottom,\n        width: width - paddingLeft - paddingRight\n      });\n\n      onResize({ height: height, width: width });\n    }\n  }, {\n    key: '_onScroll',\n    value: function _onScroll(event) {\n      // Prevent detectElementResize library from being triggered by this scroll event.\n      event.stopPropagation();\n    }\n  }, {\n    key: '_setRef',\n    value: function _setRef(autoSizer) {\n      this._autoSizer = autoSizer;\n    }\n  }]);\n\n  return AutoSizer;\n}(_react.Component);\n\nAutoSizer.propTypes = {\n  /**\n   * Function respondible for rendering children.\n   * This function should implement the following signature:\n   * ({ height, width }) => PropTypes.element\n   */\n  children: _react.PropTypes.func.isRequired,\n\n  /** Disable dynamic :height property */\n  disableHeight: _react.PropTypes.bool,\n\n  /** Disable dynamic :width property */\n  disableWidth: _react.PropTypes.bool,\n\n  /** Callback to be invoked on-resize: ({ height, width }) */\n  onResize: _react.PropTypes.func.isRequired\n};\nAutoSizer.defaultProps = {\n  onResize: function onResize() {}\n};\nexports.default = AutoSizer;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.AutoSizer = exports.default = undefined;\n\nvar _AutoSizer2 = require('./AutoSizer');\n\nvar _AutoSizer3 = _interopRequireDefault(_AutoSizer2);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = _AutoSizer3.default;\nexports.AutoSizer = _AutoSizer3.default;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _reactAddonsShallowCompare = require('react-addons-shallow-compare');\n\nvar _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare);\n\nvar _reactDom = require('react-dom');\n\nvar _reactDom2 = _interopRequireDefault(_reactDom);\n\nvar _defaultCellSizeCache = require('./defaultCellSizeCache');\n\nvar _defaultCellSizeCache2 = _interopRequireDefault(_defaultCellSizeCache);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/**\n * Measures a Grid cell's contents by rendering them in a way that is not visible to the user.\n * Either a fixed width or height may be provided if it is desirable to measure only in one direction.\n */\nvar CellMeasurer = function (_Component) {\n  _inherits(CellMeasurer, _Component);\n\n  function CellMeasurer(props, state) {\n    _classCallCheck(this, CellMeasurer);\n\n    var _this = _possibleConstructorReturn(this, (CellMeasurer.__proto__ || Object.getPrototypeOf(CellMeasurer)).call(this, props, state));\n\n    _this._cellSizeCache = props.cellSizeCache || new _defaultCellSizeCache2.default();\n\n    _this.getColumnWidth = _this.getColumnWidth.bind(_this);\n    _this.getRowHeight = _this.getRowHeight.bind(_this);\n    _this.resetMeasurements = _this.resetMeasurements.bind(_this);\n    _this.resetMeasurementForColumn = _this.resetMeasurementForColumn.bind(_this);\n    _this.resetMeasurementForRow = _this.resetMeasurementForRow.bind(_this);\n    return _this;\n  }\n\n  _createClass(CellMeasurer, [{\n    key: 'getColumnWidth',\n    value: function getColumnWidth(_ref) {\n      var index = _ref.index;\n\n      if (this._cellSizeCache.hasColumnWidth(index)) {\n        return this._cellSizeCache.getColumnWidth(index);\n      }\n\n      var rowCount = this.props.rowCount;\n\n\n      var maxWidth = 0;\n\n      for (var rowIndex = 0; rowIndex < rowCount; rowIndex++) {\n        var _measureCell2 = this._measureCell({\n          clientWidth: true,\n          columnIndex: index,\n          rowIndex: rowIndex\n        });\n\n        var width = _measureCell2.width;\n\n\n        maxWidth = Math.max(maxWidth, width);\n      }\n\n      this._cellSizeCache.setColumnWidth(index, maxWidth);\n\n      return maxWidth;\n    }\n  }, {\n    key: 'getRowHeight',\n    value: function getRowHeight(_ref2) {\n      var index = _ref2.index;\n\n      if (this._cellSizeCache.hasRowHeight(index)) {\n        return this._cellSizeCache.getRowHeight(index);\n      }\n\n      var columnCount = this.props.columnCount;\n\n\n      var maxHeight = 0;\n\n      for (var columnIndex = 0; columnIndex < columnCount; columnIndex++) {\n        var _measureCell3 = this._measureCell({\n          clientHeight: true,\n          columnIndex: columnIndex,\n          rowIndex: index\n        });\n\n        var height = _measureCell3.height;\n\n\n        maxHeight = Math.max(maxHeight, height);\n      }\n\n      this._cellSizeCache.setRowHeight(index, maxHeight);\n\n      return maxHeight;\n    }\n  }, {\n    key: 'resetMeasurementForColumn',\n    value: function resetMeasurementForColumn(columnIndex) {\n      this._cellSizeCache.clearColumnWidth(columnIndex);\n    }\n  }, {\n    key: 'resetMeasurementForRow',\n    value: function resetMeasurementForRow(rowIndex) {\n      this._cellSizeCache.clearRowHeight(rowIndex);\n    }\n  }, {\n    key: 'resetMeasurements',\n    value: function resetMeasurements() {\n      this._cellSizeCache.clearAllColumnWidths();\n      this._cellSizeCache.clearAllRowHeights();\n    }\n  }, {\n    key: 'componentDidMount',\n    value: function componentDidMount() {\n      this._renderAndMount();\n    }\n  }, {\n    key: 'componentWillReceiveProps',\n    value: function componentWillReceiveProps(nextProps) {\n      var cellSizeCache = this.props.cellSizeCache;\n\n\n      if (cellSizeCache !== nextProps.cellSizeCache) {\n        this._cellSizeCache = nextProps.cellSizeCache;\n      }\n\n      this._updateDivDimensions(nextProps);\n    }\n  }, {\n    key: 'componentWillUnmount',\n    value: function componentWillUnmount() {\n      this._unmountContainer();\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      var children = this.props.children;\n\n\n      return children({\n        getColumnWidth: this.getColumnWidth,\n        getRowHeight: this.getRowHeight,\n        resetMeasurements: this.resetMeasurements,\n        resetMeasurementForColumn: this.resetMeasurementForColumn,\n        resetMeasurementForRow: this.resetMeasurementForRow\n      });\n    }\n  }, {\n    key: 'shouldComponentUpdate',\n    value: function shouldComponentUpdate(nextProps, nextState) {\n      return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState);\n    }\n  }, {\n    key: '_getContainerNode',\n    value: function _getContainerNode(props) {\n      var container = props.container;\n\n\n      if (container) {\n        return _reactDom2.default.findDOMNode(typeof container === 'function' ? container() : container);\n      } else {\n        return document.body;\n      }\n    }\n  }, {\n    key: '_measureCell',\n    value: function _measureCell(_ref3) {\n      var _ref3$clientHeight = _ref3.clientHeight;\n      var clientHeight = _ref3$clientHeight === undefined ? false : _ref3$clientHeight;\n      var _ref3$clientWidth = _ref3.clientWidth;\n      var clientWidth = _ref3$clientWidth === undefined ? true : _ref3$clientWidth;\n      var columnIndex = _ref3.columnIndex;\n      var rowIndex = _ref3.rowIndex;\n      var cellRenderer = this.props.cellRenderer;\n\n\n      var rendered = cellRenderer({\n        columnIndex: columnIndex,\n        rowIndex: rowIndex\n      });\n\n      // Handle edge case where this method is called before the CellMeasurer has completed its initial render (and mounted).\n      this._renderAndMount();\n\n      // @TODO Keep an eye on this for future React updates as the interface may change:\n      // https://twitter.com/soprano/status/737316379712331776\n      _reactDom2.default.unstable_renderSubtreeIntoContainer(this, rendered, this._div);\n\n      var measurements = {\n        height: clientHeight && this._div.clientHeight,\n        width: clientWidth && this._div.clientWidth\n      };\n\n      _reactDom2.default.unmountComponentAtNode(this._div);\n\n      return measurements;\n    }\n  }, {\n    key: '_renderAndMount',\n    value: function _renderAndMount() {\n      if (!this._div) {\n        this._div = document.createElement('div');\n        this._div.style.display = 'inline-block';\n        this._div.style.position = 'absolute';\n        this._div.style.visibility = 'hidden';\n        this._div.style.zIndex = -1;\n\n        this._updateDivDimensions(this.props);\n\n        this._containerNode = this._getContainerNode(this.props);\n        this._containerNode.appendChild(this._div);\n      }\n    }\n  }, {\n    key: '_unmountContainer',\n    value: function _unmountContainer() {\n      if (this._div) {\n        this._containerNode.removeChild(this._div);\n\n        this._div = null;\n      }\n\n      this._containerNode = null;\n    }\n  }, {\n    key: '_updateDivDimensions',\n    value: function _updateDivDimensions(props) {\n      var height = props.height;\n      var width = props.width;\n\n\n      if (height && height !== this._divHeight) {\n        this._divHeight = height;\n        this._div.style.height = height + 'px';\n      }\n\n      if (width && width !== this._divWidth) {\n        this._divWidth = width;\n        this._div.style.width = width + 'px';\n      }\n    }\n  }]);\n\n  return CellMeasurer;\n}(_react.Component);\n\nCellMeasurer.propTypes = {\n  /**\n   * Renders a cell given its indices.\n   * Should implement the following interface: ({ columnIndex: number, rowIndex: number }): PropTypes.node\n   */\n  cellRenderer: _react.PropTypes.func.isRequired,\n\n  /**\n   * Optional, custom caching strategy for cell sizes.\n   */\n  cellSizeCache: _react.PropTypes.object,\n\n  /**\n   * Function respondible for rendering a virtualized component.\n   * This function should implement the following signature:\n   * ({ getColumnWidth, getRowHeight, resetMeasurements }) => PropTypes.element\n   */\n  children: _react.PropTypes.func.isRequired,\n\n  /**\n   * Number of columns in grid.\n   */\n  columnCount: _react.PropTypes.number.isRequired,\n\n  /**\n   * A Node, Component instance, or function that returns either.\n   * If this property is not specified the document body will be used.\n   */\n  container: _react2.default.PropTypes.oneOfType([_react2.default.PropTypes.func, _react2.default.PropTypes.node]),\n\n  /**\n   * Assign a fixed :height in order to measure dynamic text :width only.\n   */\n  height: _react.PropTypes.number,\n\n  /**\n   * Number of rows in grid.\n   */\n  rowCount: _react.PropTypes.number.isRequired,\n\n  /**\n   * Assign a fixed :width in order to measure dynamic text :height only.\n   */\n  width: _react.PropTypes.number\n};\nexports.default = CellMeasurer;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * Default CellMeasurer `cellSizeCache` implementation.\n * Permanently caches all cell sizes (identified by column and row index) unless explicitly cleared.\n * Can be configured to handle uniform cell widths and/or heights as a way of optimizing certain use cases.\n */\nvar CellSizeCache = function () {\n  function CellSizeCache() {\n    var _ref = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n\n    var _ref$uniformRowHeight = _ref.uniformRowHeight;\n    var uniformRowHeight = _ref$uniformRowHeight === undefined ? false : _ref$uniformRowHeight;\n    var _ref$uniformColumnWid = _ref.uniformColumnWidth;\n    var uniformColumnWidth = _ref$uniformColumnWid === undefined ? false : _ref$uniformColumnWid;\n\n    _classCallCheck(this, CellSizeCache);\n\n    this._uniformRowHeight = uniformRowHeight;\n    this._uniformColumnWidth = uniformColumnWidth;\n\n    this._cachedColumnWidths = {};\n    this._cachedRowHeights = {};\n  }\n\n  _createClass(CellSizeCache, [{\n    key: \"clearAllColumnWidths\",\n    value: function clearAllColumnWidths() {\n      this._cachedColumnWidth = undefined;\n      this._cachedColumnWidths = {};\n    }\n  }, {\n    key: \"clearAllRowHeights\",\n    value: function clearAllRowHeights() {\n      this._cachedRowHeight = undefined;\n      this._cachedRowHeights = {};\n    }\n  }, {\n    key: \"clearColumnWidth\",\n    value: function clearColumnWidth(index) {\n      this._cachedColumnWidth = undefined;\n\n      delete this._cachedColumnWidths[index];\n    }\n  }, {\n    key: \"clearRowHeight\",\n    value: function clearRowHeight(index) {\n      this._cachedRowHeight = undefined;\n\n      delete this._cachedRowHeights[index];\n    }\n  }, {\n    key: \"getColumnWidth\",\n    value: function getColumnWidth(index) {\n      return this._uniformColumnWidth ? this._cachedColumnWidth : this._cachedColumnWidths[index];\n    }\n  }, {\n    key: \"getRowHeight\",\n    value: function getRowHeight(index) {\n      return this._uniformRowHeight ? this._cachedRowHeight : this._cachedRowHeights[index];\n    }\n  }, {\n    key: \"hasColumnWidth\",\n    value: function hasColumnWidth(index) {\n      return this._uniformColumnWidth ? !!this._cachedColumnWidth : !!this._cachedColumnWidths[index];\n    }\n  }, {\n    key: \"hasRowHeight\",\n    value: function hasRowHeight(index) {\n      return this._uniformRowHeight ? !!this._cachedRowHeight : !!this._cachedRowHeights[index];\n    }\n  }, {\n    key: \"setColumnWidth\",\n    value: function setColumnWidth(index, width) {\n      this._cachedColumnWidth = width;\n      this._cachedColumnWidths[index] = width;\n    }\n  }, {\n    key: \"setRowHeight\",\n    value: function setRowHeight(index, height) {\n      this._cachedRowHeight = height;\n      this._cachedRowHeights[index] = height;\n    }\n  }]);\n\n  return CellSizeCache;\n}();\n\nexports.default = CellSizeCache;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.defaultCellSizeCache = exports.CellMeasurer = exports.default = undefined;\n\nvar _CellMeasurer2 = require('./CellMeasurer');\n\nvar _CellMeasurer3 = _interopRequireDefault(_CellMeasurer2);\n\nvar _defaultCellSizeCache2 = require('./defaultCellSizeCache');\n\nvar _defaultCellSizeCache3 = _interopRequireDefault(_defaultCellSizeCache2);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = _CellMeasurer3.default;\nexports.CellMeasurer = _CellMeasurer3.default;\nexports.defaultCellSizeCache = _defaultCellSizeCache3.default;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _CollectionView = require('./CollectionView');\n\nvar _CollectionView2 = _interopRequireDefault(_CollectionView);\n\nvar _calculateSizeAndPositionData2 = require('./utils/calculateSizeAndPositionData');\n\nvar _calculateSizeAndPositionData3 = _interopRequireDefault(_calculateSizeAndPositionData2);\n\nvar _getUpdatedOffsetForIndex = require('../utils/getUpdatedOffsetForIndex');\n\nvar _getUpdatedOffsetForIndex2 = _interopRequireDefault(_getUpdatedOffsetForIndex);\n\nvar _reactAddonsShallowCompare = require('react-addons-shallow-compare');\n\nvar _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/**\n * Renders scattered or non-linear data.\n * Unlike Grid, which renders checkerboard data, Collection can render arbitrarily positioned- even overlapping- data.\n */\nvar Collection = function (_Component) {\n  _inherits(Collection, _Component);\n\n  function Collection(props, context) {\n    _classCallCheck(this, Collection);\n\n    var _this = _possibleConstructorReturn(this, (Collection.__proto__ || Object.getPrototypeOf(Collection)).call(this, props, context));\n\n    _this._cellMetadata = [];\n    _this._lastRenderedCellIndices = [];\n\n    // Cell cache during scroll (for perforamnce)\n    _this._cellCache = [];\n\n    _this._isScrollingChange = _this._isScrollingChange.bind(_this);\n    return _this;\n  }\n\n  /** See Collection#recomputeCellSizesAndPositions */\n\n\n  _createClass(Collection, [{\n    key: 'recomputeCellSizesAndPositions',\n    value: function recomputeCellSizesAndPositions() {\n      this._cellCache = [];\n      this._collectionView.recomputeCellSizesAndPositions();\n    }\n\n    /** React lifecycle methods */\n\n  }, {\n    key: 'render',\n    value: function render() {\n      var _this2 = this;\n\n      var props = _objectWithoutProperties(this.props, []);\n\n      return _react2.default.createElement(_CollectionView2.default, _extends({\n        cellLayoutManager: this,\n        isScrollingChange: this._isScrollingChange,\n        ref: function ref(_ref) {\n          _this2._collectionView = _ref;\n        }\n      }, props));\n    }\n  }, {\n    key: 'shouldComponentUpdate',\n    value: function shouldComponentUpdate(nextProps, nextState) {\n      return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState);\n    }\n\n    /** CellLayoutManager interface */\n\n  }, {\n    key: 'calculateSizeAndPositionData',\n    value: function calculateSizeAndPositionData() {\n      var _props = this.props;\n      var cellCount = _props.cellCount;\n      var cellSizeAndPositionGetter = _props.cellSizeAndPositionGetter;\n      var sectionSize = _props.sectionSize;\n\n\n      var data = (0, _calculateSizeAndPositionData3.default)({\n        cellCount: cellCount,\n        cellSizeAndPositionGetter: cellSizeAndPositionGetter,\n        sectionSize: sectionSize\n      });\n\n      this._cellMetadata = data.cellMetadata;\n      this._sectionManager = data.sectionManager;\n      this._height = data.height;\n      this._width = data.width;\n    }\n\n    /**\n     * Returns the most recently rendered set of cell indices.\n     */\n\n  }, {\n    key: 'getLastRenderedIndices',\n    value: function getLastRenderedIndices() {\n      return this._lastRenderedCellIndices;\n    }\n\n    /**\n     * Calculates the minimum amount of change from the current scroll position to ensure the specified cell is (fully) visible.\n     */\n\n  }, {\n    key: 'getScrollPositionForCell',\n    value: function getScrollPositionForCell(_ref2) {\n      var align = _ref2.align;\n      var cellIndex = _ref2.cellIndex;\n      var height = _ref2.height;\n      var scrollLeft = _ref2.scrollLeft;\n      var scrollTop = _ref2.scrollTop;\n      var width = _ref2.width;\n      var cellCount = this.props.cellCount;\n\n\n      if (cellIndex >= 0 && cellIndex < cellCount) {\n        var cellMetadata = this._cellMetadata[cellIndex];\n\n        scrollLeft = (0, _getUpdatedOffsetForIndex2.default)({\n          align: align,\n          cellOffset: cellMetadata.x,\n          cellSize: cellMetadata.width,\n          containerSize: width,\n          currentOffset: scrollLeft,\n          targetIndex: cellIndex\n        });\n\n        scrollTop = (0, _getUpdatedOffsetForIndex2.default)({\n          align: align,\n          cellOffset: cellMetadata.y,\n          cellSize: cellMetadata.height,\n          containerSize: height,\n          currentOffset: scrollTop,\n          targetIndex: cellIndex\n        });\n      }\n\n      return {\n        scrollLeft: scrollLeft,\n        scrollTop: scrollTop\n      };\n    }\n  }, {\n    key: 'getTotalSize',\n    value: function getTotalSize() {\n      return {\n        height: this._height,\n        width: this._width\n      };\n    }\n  }, {\n    key: 'cellRenderers',\n    value: function cellRenderers(_ref3) {\n      var _this3 = this;\n\n      var height = _ref3.height;\n      var isScrolling = _ref3.isScrolling;\n      var width = _ref3.width;\n      var x = _ref3.x;\n      var y = _ref3.y;\n      var _props2 = this.props;\n      var cellGroupRenderer = _props2.cellGroupRenderer;\n      var cellRenderer = _props2.cellRenderer;\n\n      // Store for later calls to getLastRenderedIndices()\n\n      this._lastRenderedCellIndices = this._sectionManager.getCellIndices({\n        height: height,\n        width: width,\n        x: x,\n        y: y\n      });\n\n      return cellGroupRenderer({\n        cellCache: this._cellCache,\n        cellRenderer: cellRenderer,\n        cellSizeAndPositionGetter: function cellSizeAndPositionGetter(_ref4) {\n          var index = _ref4.index;\n          return _this3._sectionManager.getCellMetadata({ index: index });\n        },\n        indices: this._lastRenderedCellIndices,\n        isScrolling: isScrolling\n      });\n    }\n  }, {\n    key: '_isScrollingChange',\n    value: function _isScrollingChange(isScrolling) {\n      if (!isScrolling) {\n        this._cellCache = [];\n      }\n    }\n  }]);\n\n  return Collection;\n}(_react.Component);\n\nCollection.propTypes = {\n  'aria-label': _react.PropTypes.string,\n\n  /**\n   * Number of cells in Collection.\n   */\n  cellCount: _react.PropTypes.number.isRequired,\n\n  /**\n   * Responsible for rendering a group of cells given their indices.\n   * Should implement the following interface: ({\n   *   cellSizeAndPositionGetter:Function,\n   *   indices: Array<number>,\n   *   cellRenderer: Function\n   * }): Array<PropTypes.node>\n   */\n  cellGroupRenderer: _react.PropTypes.func.isRequired,\n\n  /**\n   * Responsible for rendering a cell given an row and column index.\n   * Should implement the following interface: ({ index: number }): PropTypes.element\n   */\n  cellRenderer: _react.PropTypes.func.isRequired,\n\n  /**\n   * Callback responsible for returning size and offset/position information for a given cell (index).\n   * ({ index: number }): { height: number, width: number, x: number, y: number }\n   */\n  cellSizeAndPositionGetter: _react.PropTypes.func.isRequired,\n\n  /**\n   * Optionally override the size of the sections a Collection's cells are split into.\n   */\n  sectionSize: _react.PropTypes.number\n};\nCollection.defaultProps = {\n  'aria-label': 'grid',\n  cellGroupRenderer: defaultCellGroupRenderer\n};\nexports.default = Collection;\n\n\nfunction defaultCellGroupRenderer(_ref5) {\n  var cellCache = _ref5.cellCache;\n  var cellRenderer = _ref5.cellRenderer;\n  var cellSizeAndPositionGetter = _ref5.cellSizeAndPositionGetter;\n  var indices = _ref5.indices;\n  var isScrolling = _ref5.isScrolling;\n\n  return indices.map(function (index) {\n    var cellMetadata = cellSizeAndPositionGetter({ index: index });\n\n    // Avoid re-creating cells while scrolling.\n    // This can lead to the same cell being created many times and can cause performance issues for \"heavy\" cells.\n    // If a scroll is in progress- cache and reuse cells.\n    // This cache will be thrown away once scrolling complets.\n    var renderedCell = void 0;\n\n    if (isScrolling) {\n      if (!(index in cellCache)) {\n        cellCache[index] = cellRenderer({\n          index: index,\n          isScrolling: isScrolling\n        });\n      }\n\n      renderedCell = cellCache[index];\n    } else {\n      renderedCell = cellRenderer({\n        index: index,\n        isScrolling: isScrolling\n      });\n    }\n\n    if (renderedCell == null || renderedCell === false) {\n      return null;\n    }\n\n    return _react2.default.createElement(\n      'div',\n      {\n        className: 'Collection__cell',\n        key: index,\n        style: {\n          height: cellMetadata.height,\n          left: cellMetadata.x,\n          top: cellMetadata.y,\n          width: cellMetadata.width\n        }\n      },\n      renderedCell\n    );\n  }).filter(function (renderedCell) {\n    return !!renderedCell;\n  });\n}","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _classnames = require('classnames');\n\nvar _classnames2 = _interopRequireDefault(_classnames);\n\nvar _createCallbackMemoizer = require('../utils/createCallbackMemoizer');\n\nvar _createCallbackMemoizer2 = _interopRequireDefault(_createCallbackMemoizer);\n\nvar _scrollbarSize = require('dom-helpers/util/scrollbarSize');\n\nvar _scrollbarSize2 = _interopRequireDefault(_scrollbarSize);\n\nvar _raf = require('raf');\n\nvar _raf2 = _interopRequireDefault(_raf);\n\nvar _reactAddonsShallowCompare = require('react-addons-shallow-compare');\n\nvar _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n// @TODO It would be nice to refactor Grid to use this code as well.\n\n/**\n * Specifies the number of miliseconds during which to disable pointer events while a scroll is in progress.\n * This improves performance and makes scrolling smoother.\n */\nvar IS_SCROLLING_TIMEOUT = 150;\n\n/**\n * Controls whether the Grid updates the DOM element's scrollLeft/scrollTop based on the current state or just observes it.\n * This prevents Grid from interrupting mouse-wheel animations (see issue #2).\n */\nvar SCROLL_POSITION_CHANGE_REASONS = {\n  OBSERVED: 'observed',\n  REQUESTED: 'requested'\n};\n\n/**\n * Monitors changes in properties (eg. cellCount) and state (eg. scroll offsets) to determine when rendering needs to occur.\n * This component does not render any visible content itself; it defers to the specified :cellLayoutManager.\n */\n\nvar CollectionView = function (_Component) {\n  _inherits(CollectionView, _Component);\n\n  function CollectionView(props, context) {\n    _classCallCheck(this, CollectionView);\n\n    var _this = _possibleConstructorReturn(this, (CollectionView.__proto__ || Object.getPrototypeOf(CollectionView)).call(this, props, context));\n\n    _this.state = {\n      calculateSizeAndPositionDataOnNextUpdate: false,\n      isScrolling: false,\n      scrollLeft: 0,\n      scrollTop: 0\n    };\n\n    // Invokes callbacks only when their values have changed.\n    _this._onSectionRenderedMemoizer = (0, _createCallbackMemoizer2.default)();\n    _this._onScrollMemoizer = (0, _createCallbackMemoizer2.default)(false);\n\n    // Bind functions to instance so they don't lose context when passed around.\n    _this._invokeOnSectionRenderedHelper = _this._invokeOnSectionRenderedHelper.bind(_this);\n    _this._onScroll = _this._onScroll.bind(_this);\n    _this._updateScrollPositionForScrollToCell = _this._updateScrollPositionForScrollToCell.bind(_this);\n    return _this;\n  }\n\n  /**\n   * Forced recompute of cell sizes and positions.\n   * This function should be called if cell sizes have changed but nothing else has.\n   * Since cell positions are calculated by callbacks, the collection view has no way of detecting when the underlying data has changed.\n   */\n\n\n  _createClass(CollectionView, [{\n    key: 'recomputeCellSizesAndPositions',\n    value: function recomputeCellSizesAndPositions() {\n      this.setState({\n        calculateSizeAndPositionDataOnNextUpdate: true\n      });\n    }\n\n    /* ---------------------------- Component lifecycle methods ---------------------------- */\n\n  }, {\n    key: 'componentDidMount',\n    value: function componentDidMount() {\n      var _props = this.props;\n      var cellLayoutManager = _props.cellLayoutManager;\n      var scrollLeft = _props.scrollLeft;\n      var scrollToCell = _props.scrollToCell;\n      var scrollTop = _props.scrollTop;\n\n      // If this component was first rendered server-side, scrollbar size will be undefined.\n      // In that event we need to remeasure.\n\n      if (!this._scrollbarSizeMeasured) {\n        this._scrollbarSize = (0, _scrollbarSize2.default)();\n        this._scrollbarSizeMeasured = true;\n        this.setState({});\n      }\n\n      if (scrollToCell >= 0) {\n        this._updateScrollPositionForScrollToCell();\n      } else if (scrollLeft >= 0 || scrollTop >= 0) {\n        this._setScrollPosition({ scrollLeft: scrollLeft, scrollTop: scrollTop });\n      }\n\n      // Update onSectionRendered callback.\n      this._invokeOnSectionRenderedHelper();\n\n      var _cellLayoutManager$ge = cellLayoutManager.getTotalSize();\n\n      var totalHeight = _cellLayoutManager$ge.height;\n      var totalWidth = _cellLayoutManager$ge.width;\n\n      // Initialize onScroll callback.\n\n      this._invokeOnScrollMemoizer({\n        scrollLeft: scrollLeft || 0,\n        scrollTop: scrollTop || 0,\n        totalHeight: totalHeight,\n        totalWidth: totalWidth\n      });\n    }\n  }, {\n    key: 'componentDidUpdate',\n    value: function componentDidUpdate(prevProps, prevState) {\n      var _props2 = this.props;\n      var height = _props2.height;\n      var scrollToCell = _props2.scrollToCell;\n      var width = _props2.width;\n      var _state = this.state;\n      var scrollLeft = _state.scrollLeft;\n      var scrollPositionChangeReason = _state.scrollPositionChangeReason;\n      var scrollToAlignment = _state.scrollToAlignment;\n      var scrollTop = _state.scrollTop;\n\n      // Make sure requested changes to :scrollLeft or :scrollTop get applied.\n      // Assigning to scrollLeft/scrollTop tells the browser to interrupt any running scroll animations,\n      // And to discard any pending async changes to the scroll position that may have happened in the meantime (e.g. on a separate scrolling thread).\n      // So we only set these when we require an adjustment of the scroll position.\n      // See issue #2 for more information.\n\n      if (scrollPositionChangeReason === SCROLL_POSITION_CHANGE_REASONS.REQUESTED) {\n        if (scrollLeft >= 0 && scrollLeft !== prevState.scrollLeft && scrollLeft !== this._scrollingContainer.scrollLeft) {\n          this._scrollingContainer.scrollLeft = scrollLeft;\n        }\n        if (scrollTop >= 0 && scrollTop !== prevState.scrollTop && scrollTop !== this._scrollingContainer.scrollTop) {\n          this._scrollingContainer.scrollTop = scrollTop;\n        }\n      }\n\n      // Update scroll offsets if the current :scrollToCell values requires it\n      if (height !== prevProps.height || scrollToAlignment !== prevProps.scrollToAlignment || scrollToCell !== prevProps.scrollToCell || width !== prevProps.width) {\n        this._updateScrollPositionForScrollToCell();\n      }\n\n      // Update onRowsRendered callback if start/stop indices have changed\n      this._invokeOnSectionRenderedHelper();\n    }\n  }, {\n    key: 'componentWillMount',\n    value: function componentWillMount() {\n      var cellLayoutManager = this.props.cellLayoutManager;\n\n\n      cellLayoutManager.calculateSizeAndPositionData();\n\n      // If this component is being rendered server-side, getScrollbarSize() will return undefined.\n      // We handle this case in componentDidMount()\n      this._scrollbarSize = (0, _scrollbarSize2.default)();\n      if (this._scrollbarSize === undefined) {\n        this._scrollbarSizeMeasured = false;\n        this._scrollbarSize = 0;\n      } else {\n        this._scrollbarSizeMeasured = true;\n      }\n    }\n  }, {\n    key: 'componentWillUnmount',\n    value: function componentWillUnmount() {\n      if (this._disablePointerEventsTimeoutId) {\n        clearTimeout(this._disablePointerEventsTimeoutId);\n      }\n\n      if (this._setNextStateAnimationFrameId) {\n        _raf2.default.cancel(this._setNextStateAnimationFrameId);\n      }\n    }\n\n    /**\n     * @private\n     * This method updates scrollLeft/scrollTop in state for the following conditions:\n     * 1) Empty content (0 rows or columns)\n     * 2) New scroll props overriding the current state\n     * 3) Cells-count or cells-size has changed, making previous scroll offsets invalid\n     */\n\n  }, {\n    key: 'componentWillUpdate',\n    value: function componentWillUpdate(nextProps, nextState) {\n      if (nextProps.cellCount === 0 && (nextState.scrollLeft !== 0 || nextState.scrollTop !== 0)) {\n        this._setScrollPosition({\n          scrollLeft: 0,\n          scrollTop: 0\n        });\n      } else if (nextProps.scrollLeft !== this.props.scrollLeft || nextProps.scrollTop !== this.props.scrollTop) {\n        this._setScrollPosition({\n          scrollLeft: nextProps.scrollLeft,\n          scrollTop: nextProps.scrollTop\n        });\n      }\n\n      if (nextProps.cellCount !== this.props.cellCount || nextProps.cellLayoutManager !== this.props.cellLayoutManager || nextState.calculateSizeAndPositionDataOnNextUpdate) {\n        nextProps.cellLayoutManager.calculateSizeAndPositionData();\n      }\n\n      if (nextState.calculateSizeAndPositionDataOnNextUpdate) {\n        this.setState({\n          calculateSizeAndPositionDataOnNextUpdate: false\n        });\n      }\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      var _this2 = this;\n\n      var _props3 = this.props;\n      var autoHeight = _props3.autoHeight;\n      var cellCount = _props3.cellCount;\n      var cellLayoutManager = _props3.cellLayoutManager;\n      var className = _props3.className;\n      var height = _props3.height;\n      var horizontalOverscanSize = _props3.horizontalOverscanSize;\n      var noContentRenderer = _props3.noContentRenderer;\n      var style = _props3.style;\n      var verticalOverscanSize = _props3.verticalOverscanSize;\n      var width = _props3.width;\n      var _state2 = this.state;\n      var isScrolling = _state2.isScrolling;\n      var scrollLeft = _state2.scrollLeft;\n      var scrollTop = _state2.scrollTop;\n\n      var _cellLayoutManager$ge2 = cellLayoutManager.getTotalSize();\n\n      var totalHeight = _cellLayoutManager$ge2.height;\n      var totalWidth = _cellLayoutManager$ge2.width;\n\n      // Safely expand the rendered area by the specified overscan amount\n\n      var left = Math.max(0, scrollLeft - horizontalOverscanSize);\n      var top = Math.max(0, scrollTop - verticalOverscanSize);\n      var right = Math.min(totalWidth, scrollLeft + width + horizontalOverscanSize);\n      var bottom = Math.min(totalHeight, scrollTop + height + verticalOverscanSize);\n\n      var childrenToDisplay = height > 0 && width > 0 ? cellLayoutManager.cellRenderers({\n        height: bottom - top,\n        isScrolling: isScrolling,\n        width: right - left,\n        x: left,\n        y: top\n      }) : [];\n\n      var collectionStyle = {\n        height: autoHeight ? 'auto' : height,\n        width: width\n      };\n\n      // Force browser to hide scrollbars when we know they aren't necessary.\n      // Otherwise once scrollbars appear they may not disappear again.\n      // For more info see issue #116\n      var verticalScrollBarSize = totalHeight > height ? this._scrollbarSize : 0;\n      var horizontalScrollBarSize = totalWidth > width ? this._scrollbarSize : 0;\n      if (totalWidth + verticalScrollBarSize <= width) {\n        collectionStyle.overflowX = 'hidden';\n      }\n      if (totalHeight + horizontalScrollBarSize <= height) {\n        collectionStyle.overflowY = 'hidden';\n      }\n\n      return _react2.default.createElement(\n        'div',\n        {\n          ref: function ref(_ref) {\n            _this2._scrollingContainer = _ref;\n          },\n          'aria-label': this.props['aria-label'],\n          className: (0, _classnames2.default)('Collection', className),\n          onScroll: this._onScroll,\n          role: 'grid',\n          style: _extends({}, collectionStyle, style),\n          tabIndex: 0\n        },\n        cellCount > 0 && _react2.default.createElement(\n          'div',\n          {\n            className: 'Collection__innerScrollContainer',\n            style: {\n              height: totalHeight,\n              maxHeight: totalHeight,\n              maxWidth: totalWidth,\n              pointerEvents: isScrolling ? 'none' : '',\n              width: totalWidth\n            }\n          },\n          childrenToDisplay\n        ),\n        cellCount === 0 && noContentRenderer()\n      );\n    }\n  }, {\n    key: 'shouldComponentUpdate',\n    value: function shouldComponentUpdate(nextProps, nextState) {\n      return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState);\n    }\n\n    /* ---------------------------- Helper methods ---------------------------- */\n\n    /**\n     * Sets an :isScrolling flag for a small window of time.\n     * This flag is used to disable pointer events on the scrollable portion of the Collection.\n     * This prevents jerky/stuttery mouse-wheel scrolling.\n     */\n\n  }, {\n    key: '_enablePointerEventsAfterDelay',\n    value: function _enablePointerEventsAfterDelay() {\n      var _this3 = this;\n\n      if (this._disablePointerEventsTimeoutId) {\n        clearTimeout(this._disablePointerEventsTimeoutId);\n      }\n\n      this._disablePointerEventsTimeoutId = setTimeout(function () {\n        var isScrollingChange = _this3.props.isScrollingChange;\n\n\n        isScrollingChange(false);\n\n        _this3._disablePointerEventsTimeoutId = null;\n        _this3.setState({\n          isScrolling: false\n        });\n      }, IS_SCROLLING_TIMEOUT);\n    }\n  }, {\n    key: '_invokeOnSectionRenderedHelper',\n    value: function _invokeOnSectionRenderedHelper() {\n      var _props4 = this.props;\n      var cellLayoutManager = _props4.cellLayoutManager;\n      var onSectionRendered = _props4.onSectionRendered;\n\n\n      this._onSectionRenderedMemoizer({\n        callback: onSectionRendered,\n        indices: {\n          indices: cellLayoutManager.getLastRenderedIndices()\n        }\n      });\n    }\n  }, {\n    key: '_invokeOnScrollMemoizer',\n    value: function _invokeOnScrollMemoizer(_ref2) {\n      var _this4 = this;\n\n      var scrollLeft = _ref2.scrollLeft;\n      var scrollTop = _ref2.scrollTop;\n      var totalHeight = _ref2.totalHeight;\n      var totalWidth = _ref2.totalWidth;\n\n      this._onScrollMemoizer({\n        callback: function callback(_ref3) {\n          var scrollLeft = _ref3.scrollLeft;\n          var scrollTop = _ref3.scrollTop;\n          var _props5 = _this4.props;\n          var height = _props5.height;\n          var onScroll = _props5.onScroll;\n          var width = _props5.width;\n\n\n          onScroll({\n            clientHeight: height,\n            clientWidth: width,\n            scrollHeight: totalHeight,\n            scrollLeft: scrollLeft,\n            scrollTop: scrollTop,\n            scrollWidth: totalWidth\n          });\n        },\n        indices: {\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop\n        }\n      });\n    }\n\n    /**\n     * Updates the state during the next animation frame.\n     * Use this method to avoid multiple renders in a small span of time.\n     * This helps performance for bursty events (like onScroll).\n     */\n\n  }, {\n    key: '_setNextState',\n    value: function _setNextState(state) {\n      var _this5 = this;\n\n      if (this._setNextStateAnimationFrameId) {\n        _raf2.default.cancel(this._setNextStateAnimationFrameId);\n      }\n\n      this._setNextStateAnimationFrameId = (0, _raf2.default)(function () {\n        _this5._setNextStateAnimationFrameId = null;\n        _this5.setState(state);\n      });\n    }\n  }, {\n    key: '_setScrollPosition',\n    value: function _setScrollPosition(_ref4) {\n      var scrollLeft = _ref4.scrollLeft;\n      var scrollTop = _ref4.scrollTop;\n\n      var newState = {\n        scrollPositionChangeReason: SCROLL_POSITION_CHANGE_REASONS.REQUESTED\n      };\n\n      if (scrollLeft >= 0) {\n        newState.scrollLeft = scrollLeft;\n      }\n\n      if (scrollTop >= 0) {\n        newState.scrollTop = scrollTop;\n      }\n\n      if (scrollLeft >= 0 && scrollLeft !== this.state.scrollLeft || scrollTop >= 0 && scrollTop !== this.state.scrollTop) {\n        this.setState(newState);\n      }\n    }\n  }, {\n    key: '_updateScrollPositionForScrollToCell',\n    value: function _updateScrollPositionForScrollToCell() {\n      var _props6 = this.props;\n      var cellLayoutManager = _props6.cellLayoutManager;\n      var height = _props6.height;\n      var scrollToAlignment = _props6.scrollToAlignment;\n      var scrollToCell = _props6.scrollToCell;\n      var width = _props6.width;\n      var _state3 = this.state;\n      var scrollLeft = _state3.scrollLeft;\n      var scrollTop = _state3.scrollTop;\n\n\n      if (scrollToCell >= 0) {\n        var scrollPosition = cellLayoutManager.getScrollPositionForCell({\n          align: scrollToAlignment,\n          cellIndex: scrollToCell,\n          height: height,\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop,\n          width: width\n        });\n\n        if (scrollPosition.scrollLeft !== scrollLeft || scrollPosition.scrollTop !== scrollTop) {\n          this._setScrollPosition(scrollPosition);\n        }\n      }\n    }\n  }, {\n    key: '_onScroll',\n    value: function _onScroll(event) {\n      // In certain edge-cases React dispatches an onScroll event with an invalid target.scrollLeft / target.scrollTop.\n      // This invalid event can be detected by comparing event.target to this component's scrollable DOM element.\n      // See issue #404 for more information.\n      if (event.target !== this._scrollingContainer) {\n        return;\n      }\n\n      // Prevent pointer events from interrupting a smooth scroll\n      this._enablePointerEventsAfterDelay();\n\n      // When this component is shrunk drastically, React dispatches a series of back-to-back scroll events,\n      // Gradually converging on a scrollTop that is within the bounds of the new, smaller height.\n      // This causes a series of rapid renders that is slow for long lists.\n      // We can avoid that by doing some simple bounds checking to ensure that scrollTop never exceeds the total height.\n      var _props7 = this.props;\n      var cellLayoutManager = _props7.cellLayoutManager;\n      var height = _props7.height;\n      var isScrollingChange = _props7.isScrollingChange;\n      var width = _props7.width;\n\n      var scrollbarSize = this._scrollbarSize;\n\n      var _cellLayoutManager$ge3 = cellLayoutManager.getTotalSize();\n\n      var totalHeight = _cellLayoutManager$ge3.height;\n      var totalWidth = _cellLayoutManager$ge3.width;\n\n      var scrollLeft = Math.max(0, Math.min(totalWidth - width + scrollbarSize, event.target.scrollLeft));\n      var scrollTop = Math.max(0, Math.min(totalHeight - height + scrollbarSize, event.target.scrollTop));\n\n      // Certain devices (like Apple touchpad) rapid-fire duplicate events.\n      // Don't force a re-render if this is the case.\n      // The mouse may move faster then the animation frame does.\n      // Use requestAnimationFrame to avoid over-updating.\n      if (this.state.scrollLeft !== scrollLeft || this.state.scrollTop !== scrollTop) {\n        // Browsers with cancelable scroll events (eg. Firefox) interrupt scrolling animations if scrollTop/scrollLeft is set.\n        // Other browsers (eg. Safari) don't scroll as well without the help under certain conditions (DOM or style changes during scrolling).\n        // All things considered, this seems to be the best current work around that I'm aware of.\n        // For more information see https://github.com/bvaughn/react-virtualized/pull/124\n        var scrollPositionChangeReason = event.cancelable ? SCROLL_POSITION_CHANGE_REASONS.OBSERVED : SCROLL_POSITION_CHANGE_REASONS.REQUESTED;\n\n        // Synchronously set :isScrolling the first time (since _setNextState will reschedule its animation frame each time it's called)\n        if (!this.state.isScrolling) {\n          isScrollingChange(true);\n\n          this.setState({\n            isScrolling: true\n          });\n        }\n\n        this._setNextState({\n          isScrolling: true,\n          scrollLeft: scrollLeft,\n          scrollPositionChangeReason: scrollPositionChangeReason,\n          scrollTop: scrollTop\n        });\n      }\n\n      this._invokeOnScrollMemoizer({\n        scrollLeft: scrollLeft,\n        scrollTop: scrollTop,\n        totalWidth: totalWidth,\n        totalHeight: totalHeight\n      });\n    }\n  }]);\n\n  return CollectionView;\n}(_react.Component);\n\nCollectionView.propTypes = {\n  'aria-label': _react.PropTypes.string,\n\n  /**\n   * Removes fixed height from the scrollingContainer so that the total height\n   * of rows can stretch the window. Intended for use with WindowScroller\n   */\n  autoHeight: _react.PropTypes.bool,\n\n  /**\n   * Number of cells in collection.\n   */\n  cellCount: _react.PropTypes.number.isRequired,\n\n  /**\n   * Calculates cell sizes and positions and manages rendering the appropriate cells given a specified window.\n   */\n  cellLayoutManager: _react.PropTypes.object.isRequired,\n\n  /**\n   * Optional custom CSS class name to attach to root Collection element.\n   */\n  className: _react.PropTypes.string,\n\n  /**\n   * Height of Collection; this property determines the number of visible (vs virtualized) rows.\n   */\n  height: _react.PropTypes.number.isRequired,\n\n  /**\n   * Enables the `Collection` to horiontally \"overscan\" its content similar to how `Grid` does.\n   * This can reduce flicker around the edges when a user scrolls quickly.\n   */\n  horizontalOverscanSize: _react.PropTypes.number.isRequired,\n\n  isScrollingChange: _react.PropTypes.func,\n\n  /**\n   * Optional renderer to be used in place of rows when either :rowCount or :cellCount is 0.\n   */\n  noContentRenderer: _react.PropTypes.func.isRequired,\n\n  /**\n   * Callback invoked whenever the scroll offset changes within the inner scrollable region.\n   * This callback can be used to sync scrolling between lists, tables, or grids.\n   * ({ clientHeight, clientWidth, scrollHeight, scrollLeft, scrollTop, scrollWidth }): void\n   */\n  onScroll: _react.PropTypes.func.isRequired,\n\n  /**\n   * Callback invoked with information about the section of the Collection that was just rendered.\n   * This callback is passed a named :indices parameter which is an Array of the most recently rendered section indices.\n   */\n  onSectionRendered: _react.PropTypes.func.isRequired,\n\n  /**\n   * Horizontal offset.\n   */\n  scrollLeft: _react.PropTypes.number,\n\n  /**\n   * Controls scroll-to-cell behavior of the Grid.\n   * The default (\"auto\") scrolls the least amount possible to ensure that the specified cell is fully visible.\n   * Use \"start\" to align cells to the top/left of the Grid and \"end\" to align bottom/right.\n   */\n  scrollToAlignment: _react.PropTypes.oneOf(['auto', 'end', 'start', 'center']).isRequired,\n\n  /**\n   * Cell index to ensure visible (by forcefully scrolling if necessary).\n   */\n  scrollToCell: _react.PropTypes.number,\n\n  /**\n   * Vertical offset.\n   */\n  scrollTop: _react.PropTypes.number,\n\n  /**\n   * Optional custom inline style to attach to root Collection element.\n   */\n  style: _react.PropTypes.object,\n\n  /**\n   * Enables the `Collection` to vertically \"overscan\" its content similar to how `Grid` does.\n   * This can reduce flicker around the edges when a user scrolls quickly.\n   */\n  verticalOverscanSize: _react.PropTypes.number.isRequired,\n\n  /**\n   * Width of Collection; this property determines the number of visible (vs virtualized) columns.\n   */\n  width: _react.PropTypes.number.isRequired\n};\nCollectionView.defaultProps = {\n  'aria-label': 'grid',\n  horizontalOverscanSize: 0,\n  noContentRenderer: function noContentRenderer() {\n    return null;\n  },\n  onScroll: function onScroll() {\n    return null;\n  },\n  onSectionRendered: function onSectionRendered() {\n    return null;\n  },\n  scrollToAlignment: 'auto',\n  style: {},\n  verticalOverscanSize: 0\n};\nexports.default = CollectionView;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * A section of the Window.\n * Window Sections are used to group nearby cells.\n * This enables us to more quickly determine which cells to display in a given region of the Window.\n * Sections have a fixed size and contain 0 to many cells (tracked by their indices).\n */\nvar Section = function () {\n  function Section(_ref) {\n    var height = _ref.height;\n    var width = _ref.width;\n    var x = _ref.x;\n    var y = _ref.y;\n\n    _classCallCheck(this, Section);\n\n    this.height = height;\n    this.width = width;\n    this.x = x;\n    this.y = y;\n\n    this._indexMap = {};\n    this._indices = [];\n  }\n\n  /** Add a cell to this section. */\n\n\n  _createClass(Section, [{\n    key: 'addCellIndex',\n    value: function addCellIndex(_ref2) {\n      var index = _ref2.index;\n\n      if (!this._indexMap[index]) {\n        this._indexMap[index] = true;\n        this._indices.push(index);\n      }\n    }\n\n    /** Get all cell indices that have been added to this section. */\n\n  }, {\n    key: 'getCellIndices',\n    value: function getCellIndices() {\n      return this._indices;\n    }\n\n    /** Intended for debugger/test purposes only */\n\n  }, {\n    key: 'toString',\n    value: function toString() {\n      return this.x + ',' + this.y + ' ' + this.width + 'x' + this.height;\n    }\n  }]);\n\n  return Section;\n}(); /** @rlow */\n\n\nexports.default = Section;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /**\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      * Window Sections are used to group nearby cells.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      * This enables us to more quickly determine which cells to display in a given region of the Window.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      * \n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      */\n\n\nvar _Section = require('./Section');\n\nvar _Section2 = _interopRequireDefault(_Section);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar SECTION_SIZE = 100;\n\n/**\n * Contains 0 to many Sections.\n * Grows (and adds Sections) dynamically as cells are registered.\n * Automatically adds cells to the appropriate Section(s).\n */\nvar SectionManager = function () {\n  function SectionManager() {\n    var sectionSize = arguments.length <= 0 || arguments[0] === undefined ? SECTION_SIZE : arguments[0];\n\n    _classCallCheck(this, SectionManager);\n\n    this._sectionSize = sectionSize;\n\n    this._cellMetadata = [];\n    this._sections = {};\n  }\n\n  /**\n   * Gets all cell indices contained in the specified region.\n   * A region may encompass 1 or more Sections.\n   */\n\n\n  _createClass(SectionManager, [{\n    key: 'getCellIndices',\n    value: function getCellIndices(_ref) {\n      var height = _ref.height;\n      var width = _ref.width;\n      var x = _ref.x;\n      var y = _ref.y;\n\n      var indices = {};\n\n      this.getSections({ height: height, width: width, x: x, y: y }).forEach(function (section) {\n        return section.getCellIndices().forEach(function (index) {\n          indices[index] = index;\n        });\n      });\n\n      // Object keys are strings; this function returns numbers\n      return Object.keys(indices).map(function (index) {\n        return indices[index];\n      });\n    }\n\n    /** Get size and position information for the cell specified. */\n\n  }, {\n    key: 'getCellMetadata',\n    value: function getCellMetadata(_ref2) {\n      var index = _ref2.index;\n\n      return this._cellMetadata[index];\n    }\n\n    /** Get all Sections overlapping the specified region. */\n\n  }, {\n    key: 'getSections',\n    value: function getSections(_ref3) {\n      var height = _ref3.height;\n      var width = _ref3.width;\n      var x = _ref3.x;\n      var y = _ref3.y;\n\n      var sectionXStart = Math.floor(x / this._sectionSize);\n      var sectionXStop = Math.floor((x + width - 1) / this._sectionSize);\n      var sectionYStart = Math.floor(y / this._sectionSize);\n      var sectionYStop = Math.floor((y + height - 1) / this._sectionSize);\n\n      var sections = [];\n\n      for (var sectionX = sectionXStart; sectionX <= sectionXStop; sectionX++) {\n        for (var sectionY = sectionYStart; sectionY <= sectionYStop; sectionY++) {\n          var key = sectionX + '.' + sectionY;\n\n          if (!this._sections[key]) {\n            this._sections[key] = new _Section2.default({\n              height: this._sectionSize,\n              width: this._sectionSize,\n              x: sectionX * this._sectionSize,\n              y: sectionY * this._sectionSize\n            });\n          }\n\n          sections.push(this._sections[key]);\n        }\n      }\n\n      return sections;\n    }\n\n    /** Total number of Sections based on the currently registered cells. */\n\n  }, {\n    key: 'getTotalSectionCount',\n    value: function getTotalSectionCount() {\n      return Object.keys(this._sections).length;\n    }\n\n    /** Intended for debugger/test purposes only */\n\n  }, {\n    key: 'toString',\n    value: function toString() {\n      var _this = this;\n\n      return Object.keys(this._sections).map(function (index) {\n        return _this._sections[index].toString();\n      });\n    }\n\n    /** Adds a cell to the appropriate Sections and registers it metadata for later retrievable. */\n\n  }, {\n    key: 'registerCell',\n    value: function registerCell(_ref4) {\n      var cellMetadatum = _ref4.cellMetadatum;\n      var index = _ref4.index;\n\n      this._cellMetadata[index] = cellMetadatum;\n\n      this.getSections(cellMetadatum).forEach(function (section) {\n        return section.addCellIndex({ index: index });\n      });\n    }\n  }]);\n\n  return SectionManager;\n}();\n\nexports.default = SectionManager;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.Collection = exports.default = undefined;\n\nvar _Collection2 = require('./Collection');\n\nvar _Collection3 = _interopRequireDefault(_Collection2);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = _Collection3.default;\nexports.Collection = _Collection3.default;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = calculateSizeAndPositionData;\n\nvar _SectionManager = require('../SectionManager');\n\nvar _SectionManager2 = _interopRequireDefault(_SectionManager);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction calculateSizeAndPositionData(_ref) {\n  var cellCount = _ref.cellCount;\n  var cellSizeAndPositionGetter = _ref.cellSizeAndPositionGetter;\n  var sectionSize = _ref.sectionSize;\n\n  var cellMetadata = [];\n  var sectionManager = new _SectionManager2.default(sectionSize);\n  var height = 0;\n  var width = 0;\n\n  for (var index = 0; index < cellCount; index++) {\n    var cellMetadatum = cellSizeAndPositionGetter({ index: index });\n\n    if (cellMetadatum.height == null || isNaN(cellMetadatum.height) || cellMetadatum.width == null || isNaN(cellMetadatum.width) || cellMetadatum.x == null || isNaN(cellMetadatum.x) || cellMetadatum.y == null || isNaN(cellMetadatum.y)) {\n      throw Error('Invalid metadata returned for cell ' + index + ':\\n        x:' + cellMetadatum.x + ', y:' + cellMetadatum.y + ', width:' + cellMetadatum.width + ', height:' + cellMetadatum.height);\n    }\n\n    height = Math.max(height, cellMetadatum.y + cellMetadatum.height);\n    width = Math.max(width, cellMetadatum.x + cellMetadatum.width);\n\n    cellMetadata[index] = cellMetadatum;\n    sectionManager.registerCell({\n      cellMetadatum: cellMetadatum,\n      index: index\n    });\n  }\n\n  return {\n    cellMetadata: cellMetadata,\n    height: height,\n    sectionManager: sectionManager,\n    width: width\n  };\n}","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _react = require('react');\n\nvar _reactAddonsShallowCompare = require('react-addons-shallow-compare');\n\nvar _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare);\n\nvar _Grid = require('../Grid');\n\nvar _Grid2 = _interopRequireDefault(_Grid);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/**\n * High-order component that auto-calculates column-widths for `Grid` cells.\n */\nvar ColumnSizer = function (_Component) {\n  _inherits(ColumnSizer, _Component);\n\n  function ColumnSizer(props, context) {\n    _classCallCheck(this, ColumnSizer);\n\n    var _this = _possibleConstructorReturn(this, (ColumnSizer.__proto__ || Object.getPrototypeOf(ColumnSizer)).call(this, props, context));\n\n    _this._registerChild = _this._registerChild.bind(_this);\n    return _this;\n  }\n\n  _createClass(ColumnSizer, [{\n    key: 'componentDidUpdate',\n    value: function componentDidUpdate(prevProps, prevState) {\n      var _props = this.props;\n      var columnMaxWidth = _props.columnMaxWidth;\n      var columnMinWidth = _props.columnMinWidth;\n      var columnCount = _props.columnCount;\n      var width = _props.width;\n\n\n      if (columnMaxWidth !== prevProps.columnMaxWidth || columnMinWidth !== prevProps.columnMinWidth || columnCount !== prevProps.columnCount || width !== prevProps.width) {\n        if (this._registeredChild) {\n          this._registeredChild.recomputeGridSize();\n        }\n      }\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      var _props2 = this.props;\n      var children = _props2.children;\n      var columnMaxWidth = _props2.columnMaxWidth;\n      var columnMinWidth = _props2.columnMinWidth;\n      var columnCount = _props2.columnCount;\n      var width = _props2.width;\n\n\n      var safeColumnMinWidth = columnMinWidth || 1;\n\n      var safeColumnMaxWidth = columnMaxWidth ? Math.min(columnMaxWidth, width) : width;\n\n      var columnWidth = width / columnCount;\n      columnWidth = Math.max(safeColumnMinWidth, columnWidth);\n      columnWidth = Math.min(safeColumnMaxWidth, columnWidth);\n      columnWidth = Math.floor(columnWidth);\n\n      var adjustedWidth = Math.min(width, columnWidth * columnCount);\n\n      return children({\n        adjustedWidth: adjustedWidth,\n        getColumnWidth: function getColumnWidth() {\n          return columnWidth;\n        },\n        registerChild: this._registerChild\n      });\n    }\n  }, {\n    key: 'shouldComponentUpdate',\n    value: function shouldComponentUpdate(nextProps, nextState) {\n      return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState);\n    }\n  }, {\n    key: '_registerChild',\n    value: function _registerChild(child) {\n      if (child !== null && !(child instanceof _Grid2.default)) {\n        throw Error('Unexpected child type registered; only Grid children are supported.');\n      }\n\n      this._registeredChild = child;\n\n      if (this._registeredChild) {\n        this._registeredChild.recomputeGridSize();\n      }\n    }\n  }]);\n\n  return ColumnSizer;\n}(_react.Component);\n\nColumnSizer.propTypes = {\n  /**\n   * Function respondible for rendering a virtualized Grid.\n   * This function should implement the following signature:\n   * ({ adjustedWidth, getColumnWidth, registerChild }) => PropTypes.element\n   *\n   * The specified :getColumnWidth function should be passed to the Grid's :columnWidth property.\n   * The :registerChild should be passed to the Grid's :ref property.\n   * The :adjustedWidth property is optional; it reflects the lesser of the overall width or the width of all columns.\n   */\n  children: _react.PropTypes.func.isRequired,\n\n  /** Optional maximum allowed column width */\n  columnMaxWidth: _react.PropTypes.number,\n\n  /** Optional minimum allowed column width */\n  columnMinWidth: _react.PropTypes.number,\n\n  /** Number of columns in Grid or FlexTable child */\n  columnCount: _react.PropTypes.number.isRequired,\n\n  /** Width of Grid or FlexTable child */\n  width: _react.PropTypes.number.isRequired\n};\nexports.default = ColumnSizer;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.ColumnSizer = exports.default = undefined;\n\nvar _ColumnSizer2 = require('./ColumnSizer');\n\nvar _ColumnSizer3 = _interopRequireDefault(_ColumnSizer2);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = _ColumnSizer3.default;\nexports.ColumnSizer = _ColumnSizer3.default;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _react = require('react');\n\nvar _defaultHeaderRenderer = require('./defaultHeaderRenderer');\n\nvar _defaultHeaderRenderer2 = _interopRequireDefault(_defaultHeaderRenderer);\n\nvar _defaultCellRenderer = require('./defaultCellRenderer');\n\nvar _defaultCellRenderer2 = _interopRequireDefault(_defaultCellRenderer);\n\nvar _defaultCellDataGetter = require('./defaultCellDataGetter');\n\nvar _defaultCellDataGetter2 = _interopRequireDefault(_defaultCellDataGetter);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/**\n * Describes the header and cell contents of a table column.\n */\nvar Column = function (_Component) {\n  _inherits(Column, _Component);\n\n  function Column() {\n    _classCallCheck(this, Column);\n\n    return _possibleConstructorReturn(this, (Column.__proto__ || Object.getPrototypeOf(Column)).apply(this, arguments));\n  }\n\n  return Column;\n}(_react.Component);\n\nColumn.defaultProps = {\n  cellDataGetter: _defaultCellDataGetter2.default,\n  cellRenderer: _defaultCellRenderer2.default,\n  flexGrow: 0,\n  flexShrink: 1,\n  headerRenderer: _defaultHeaderRenderer2.default,\n  style: {}\n};\nColumn.propTypes = {\n  /** Optional aria-label value to set on the column header */\n  'aria-label': _react.PropTypes.string,\n\n  /**\n   * Callback responsible for returning a cell's data, given its :dataKey\n   * ({ columnData: any, dataKey: string, rowData: any }): any\n   */\n  cellDataGetter: _react.PropTypes.func,\n\n  /**\n   * Callback responsible for rendering a cell's contents.\n   * ({ cellData: any, columnData: any, dataKey: string, rowData: any, rowIndex: number }): node\n   */\n  cellRenderer: _react.PropTypes.func,\n\n  /** Optional CSS class to apply to cell */\n  className: _react.PropTypes.string,\n\n  /** Optional additional data passed to this column's :cellDataGetter */\n  columnData: _react.PropTypes.object,\n\n  /** Uniquely identifies the row-data attribute correspnding to this cell */\n  dataKey: _react.PropTypes.any.isRequired,\n\n  /** If sort is enabled for the table at large, disable it for this column */\n  disableSort: _react.PropTypes.bool,\n\n  /** Flex grow style; defaults to 0 */\n  flexGrow: _react.PropTypes.number,\n\n  /** Flex shrink style; defaults to 1 */\n  flexShrink: _react.PropTypes.number,\n\n  /** Optional CSS class to apply to this column's header */\n  headerClassName: _react.PropTypes.string,\n\n  /**\n   * Optional callback responsible for rendering a column header contents.\n   * ({ columnData: object, dataKey: string, disableSort: boolean, label: string, sortBy: string, sortDirection: string }): PropTypes.node\n   */\n  headerRenderer: _react.PropTypes.func.isRequired,\n\n  /** Header label for this column */\n  label: _react.PropTypes.string,\n\n  /** Maximum width of column; this property will only be used if :flexGrow is > 0. */\n  maxWidth: _react.PropTypes.number,\n\n  /** Minimum width of column. */\n  minWidth: _react.PropTypes.number,\n\n  /** Optional inline style to apply to cell */\n  style: _react.PropTypes.object,\n\n  /** Flex basis (width) for this column; This value can grow or shrink based on :flexGrow and :flexShrink properties. */\n  width: _react.PropTypes.number.isRequired\n};\nexports.default = Column;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _classnames = require('classnames');\n\nvar _classnames2 = _interopRequireDefault(_classnames);\n\nvar _FlexColumn = require('./FlexColumn');\n\nvar _FlexColumn2 = _interopRequireDefault(_FlexColumn);\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _reactDom = require('react-dom');\n\nvar _reactAddonsShallowCompare = require('react-addons-shallow-compare');\n\nvar _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare);\n\nvar _Grid = require('../Grid');\n\nvar _Grid2 = _interopRequireDefault(_Grid);\n\nvar _defaultRowRenderer = require('./defaultRowRenderer');\n\nvar _defaultRowRenderer2 = _interopRequireDefault(_defaultRowRenderer);\n\nvar _SortDirection = require('./SortDirection');\n\nvar _SortDirection2 = _interopRequireDefault(_SortDirection);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/**\n * Table component with fixed headers and virtualized rows for improved performance with large data sets.\n * This component expects explicit width, height, and padding parameters.\n */\nvar FlexTable = function (_Component) {\n  _inherits(FlexTable, _Component);\n\n  function FlexTable(props) {\n    _classCallCheck(this, FlexTable);\n\n    var _this = _possibleConstructorReturn(this, (FlexTable.__proto__ || Object.getPrototypeOf(FlexTable)).call(this, props));\n\n    _this.state = {\n      scrollbarWidth: 0\n    };\n\n    _this._cellClassName = _this._cellClassName.bind(_this);\n    _this._cellStyle = _this._cellStyle.bind(_this);\n    _this._createColumn = _this._createColumn.bind(_this);\n    _this._createRow = _this._createRow.bind(_this);\n    _this._onScroll = _this._onScroll.bind(_this);\n    _this._onSectionRendered = _this._onSectionRendered.bind(_this);\n    return _this;\n  }\n\n  _createClass(FlexTable, [{\n    key: 'forceUpdateGrid',\n    value: function forceUpdateGrid() {\n      this.Grid.forceUpdate();\n    }\n\n    /** See Grid#measureAllCells */\n\n  }, {\n    key: 'measureAllRows',\n    value: function measureAllRows() {\n      this.Grid.measureAllCells();\n    }\n\n    /** See Grid#recomputeGridSize */\n\n  }, {\n    key: 'recomputeRowHeights',\n    value: function recomputeRowHeights() {\n      var index = arguments.length <= 0 || arguments[0] === undefined ? 0 : arguments[0];\n\n      this.Grid.recomputeGridSize({\n        rowIndex: index\n      });\n      this.forceUpdateGrid();\n    }\n  }, {\n    key: 'componentDidMount',\n    value: function componentDidMount() {\n      this._setScrollbarWidth();\n    }\n  }, {\n    key: 'componentDidUpdate',\n    value: function componentDidUpdate() {\n      this._setScrollbarWidth();\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      var _this2 = this;\n\n      var _props = this.props;\n      var children = _props.children;\n      var className = _props.className;\n      var disableHeader = _props.disableHeader;\n      var gridClassName = _props.gridClassName;\n      var gridStyle = _props.gridStyle;\n      var headerHeight = _props.headerHeight;\n      var height = _props.height;\n      var noRowsRenderer = _props.noRowsRenderer;\n      var rowClassName = _props.rowClassName;\n      var rowStyle = _props.rowStyle;\n      var scrollToIndex = _props.scrollToIndex;\n      var style = _props.style;\n      var width = _props.width;\n      var scrollbarWidth = this.state.scrollbarWidth;\n\n\n      var availableRowsHeight = height - headerHeight;\n\n      var rowClass = rowClassName instanceof Function ? rowClassName({ index: -1 }) : rowClassName;\n      var rowStyleObject = rowStyle instanceof Function ? rowStyle({ index: -1 }) : rowStyle;\n\n      // Precompute and cache column styles before rendering rows and columns to speed things up\n      this._cachedColumnStyles = [];\n      _react2.default.Children.toArray(children).forEach(function (column, index) {\n        _this2._cachedColumnStyles[index] = _this2._getFlexStyleForColumn(column, column.props.style);\n      });\n\n      // Note that we specify :numChildren, :scrollbarWidth, :sortBy, and :sortDirection as properties on Grid even though these have nothing to do with Grid.\n      // This is done because Grid is a pure component and won't update unless its properties or state has changed.\n      // Any property that should trigger a re-render of Grid then is specified here to avoid a stale display.\n      return _react2.default.createElement(\n        'div',\n        {\n          className: (0, _classnames2.default)('FlexTable', className),\n          style: style\n        },\n        !disableHeader && _react2.default.createElement(\n          'div',\n          {\n            className: (0, _classnames2.default)('FlexTable__headerRow', rowClass),\n            style: _extends({}, rowStyleObject, {\n              height: headerHeight,\n              paddingRight: scrollbarWidth,\n              width: width\n            })\n          },\n          this._getRenderedHeaderRow()\n        ),\n        _react2.default.createElement(_Grid2.default, _extends({}, this.props, {\n          autoContainerWidth: true,\n          className: (0, _classnames2.default)('FlexTable__Grid', gridClassName),\n          cellClassName: this._cellClassName,\n          cellRenderer: this._createRow,\n          cellStyle: this._cellStyle,\n          columnWidth: width,\n          columnCount: 1,\n          height: availableRowsHeight,\n          noContentRenderer: noRowsRenderer,\n          onScroll: this._onScroll,\n          onSectionRendered: this._onSectionRendered,\n          ref: function ref(_ref) {\n            _this2.Grid = _ref;\n          },\n          scrollbarWidth: scrollbarWidth,\n          scrollToRow: scrollToIndex,\n          style: gridStyle\n        }))\n      );\n    }\n  }, {\n    key: 'shouldComponentUpdate',\n    value: function shouldComponentUpdate(nextProps, nextState) {\n      return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState);\n    }\n  }, {\n    key: '_cellClassName',\n    value: function _cellClassName(_ref2) {\n      var rowIndex = _ref2.rowIndex;\n      var rowWrapperClassName = this.props.rowWrapperClassName;\n\n\n      return rowWrapperClassName instanceof Function ? rowWrapperClassName({ index: rowIndex - 1 }) : rowWrapperClassName;\n    }\n  }, {\n    key: '_cellStyle',\n    value: function _cellStyle(_ref3) {\n      var rowIndex = _ref3.rowIndex;\n      var rowWrapperStyle = this.props.rowWrapperStyle;\n\n\n      return rowWrapperStyle instanceof Function ? rowWrapperStyle({ index: rowIndex - 1 }) : rowWrapperStyle;\n    }\n  }, {\n    key: '_createColumn',\n    value: function _createColumn(_ref4) {\n      var column = _ref4.column;\n      var columnIndex = _ref4.columnIndex;\n      var isScrolling = _ref4.isScrolling;\n      var rowData = _ref4.rowData;\n      var rowIndex = _ref4.rowIndex;\n      var _column$props = column.props;\n      var cellDataGetter = _column$props.cellDataGetter;\n      var cellRenderer = _column$props.cellRenderer;\n      var className = _column$props.className;\n      var columnData = _column$props.columnData;\n      var dataKey = _column$props.dataKey;\n\n\n      var cellData = cellDataGetter({ columnData: columnData, dataKey: dataKey, rowData: rowData });\n      var renderedCell = cellRenderer({ cellData: cellData, columnData: columnData, dataKey: dataKey, isScrolling: isScrolling, rowData: rowData, rowIndex: rowIndex });\n\n      var style = this._cachedColumnStyles[columnIndex];\n\n      var title = typeof renderedCell === 'string' ? renderedCell : null;\n\n      return _react2.default.createElement(\n        'div',\n        {\n          key: 'Row' + rowIndex + '-Col' + columnIndex,\n          className: (0, _classnames2.default)('FlexTable__rowColumn', className),\n          style: style,\n          title: title\n        },\n        renderedCell\n      );\n    }\n  }, {\n    key: '_createHeader',\n    value: function _createHeader(_ref5) {\n      var column = _ref5.column;\n      var index = _ref5.index;\n      var _props2 = this.props;\n      var headerClassName = _props2.headerClassName;\n      var headerStyle = _props2.headerStyle;\n      var onHeaderClick = _props2.onHeaderClick;\n      var sort = _props2.sort;\n      var sortBy = _props2.sortBy;\n      var sortDirection = _props2.sortDirection;\n      var _column$props2 = column.props;\n      var dataKey = _column$props2.dataKey;\n      var disableSort = _column$props2.disableSort;\n      var headerRenderer = _column$props2.headerRenderer;\n      var label = _column$props2.label;\n      var columnData = _column$props2.columnData;\n\n      var sortEnabled = !disableSort && sort;\n\n      var classNames = (0, _classnames2.default)('FlexTable__headerColumn', headerClassName, column.props.headerClassName, {\n        'FlexTable__sortableHeaderColumn': sortEnabled\n      });\n      var style = this._getFlexStyleForColumn(column, headerStyle);\n\n      var renderedHeader = headerRenderer({\n        columnData: columnData,\n        dataKey: dataKey,\n        disableSort: disableSort,\n        label: label,\n        sortBy: sortBy,\n        sortDirection: sortDirection\n      });\n\n      var a11yProps = {};\n\n      if (sortEnabled || onHeaderClick) {\n        (function () {\n          // If this is a sortable header, clicking it should update the table data's sorting.\n          var newSortDirection = sortBy !== dataKey || sortDirection === _SortDirection2.default.DESC ? _SortDirection2.default.ASC : _SortDirection2.default.DESC;\n\n          var onClick = function onClick() {\n            sortEnabled && sort({\n              sortBy: dataKey,\n              sortDirection: newSortDirection\n            });\n            onHeaderClick && onHeaderClick({ columnData: columnData, dataKey: dataKey });\n          };\n\n          var onKeyDown = function onKeyDown(event) {\n            if (event.key === 'Enter' || event.key === ' ') {\n              onClick();\n            }\n          };\n\n          a11yProps['aria-label'] = column.props['aria-label'] || label || dataKey;\n          a11yProps.role = 'rowheader';\n          a11yProps.tabIndex = 0;\n          a11yProps.onClick = onClick;\n          a11yProps.onKeyDown = onKeyDown;\n        })();\n      }\n\n      return _react2.default.createElement(\n        'div',\n        _extends({}, a11yProps, {\n          key: 'Header-Col' + index,\n          className: classNames,\n          style: style\n        }),\n        renderedHeader\n      );\n    }\n  }, {\n    key: '_createRow',\n    value: function _createRow(_ref6) {\n      var _this3 = this;\n\n      var index = _ref6.rowIndex;\n      var isScrolling = _ref6.isScrolling;\n      var _props3 = this.props;\n      var children = _props3.children;\n      var onRowClick = _props3.onRowClick;\n      var onRowDoubleClick = _props3.onRowDoubleClick;\n      var onRowMouseOver = _props3.onRowMouseOver;\n      var onRowMouseOut = _props3.onRowMouseOut;\n      var rowClassName = _props3.rowClassName;\n      var rowGetter = _props3.rowGetter;\n      var rowRenderer = _props3.rowRenderer;\n      var rowStyle = _props3.rowStyle;\n      var scrollbarWidth = this.state.scrollbarWidth;\n\n\n      var rowClass = rowClassName instanceof Function ? rowClassName({ index: index }) : rowClassName;\n      var rowStyleObject = rowStyle instanceof Function ? rowStyle({ index: index }) : rowStyle;\n      var rowData = rowGetter({ index: index });\n\n      var columns = _react2.default.Children.toArray(children).map(function (column, columnIndex) {\n        return _this3._createColumn({\n          column: column,\n          columnIndex: columnIndex,\n          isScrolling: isScrolling,\n          rowData: rowData,\n          rowIndex: index,\n          scrollbarWidth: scrollbarWidth\n        });\n      });\n\n      var className = (0, _classnames2.default)('FlexTable__row', rowClass);\n      var style = _extends({}, rowStyleObject, {\n        height: this._getRowHeight(index),\n        paddingRight: scrollbarWidth\n      });\n\n      return rowRenderer({\n        className: className,\n        columns: columns,\n        index: index,\n        isScrolling: isScrolling,\n        onRowClick: onRowClick,\n        onRowDoubleClick: onRowDoubleClick,\n        onRowMouseOver: onRowMouseOver,\n        onRowMouseOut: onRowMouseOut,\n        rowData: rowData,\n        style: style\n      });\n    }\n\n    /**\n     * Determines the flex-shrink, flex-grow, and width values for a cell (header or column).\n     */\n\n  }, {\n    key: '_getFlexStyleForColumn',\n    value: function _getFlexStyleForColumn(column) {\n      var customStyle = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];\n\n      var flexValue = column.props.flexGrow + ' ' + column.props.flexShrink + ' ' + column.props.width + 'px';\n\n      var style = _extends({}, customStyle, {\n        flex: flexValue,\n        msFlex: flexValue,\n        WebkitFlex: flexValue\n      });\n\n      if (column.props.maxWidth) {\n        style.maxWidth = column.props.maxWidth;\n      }\n\n      if (column.props.minWidth) {\n        style.minWidth = column.props.minWidth;\n      }\n\n      return style;\n    }\n  }, {\n    key: '_getRenderedHeaderRow',\n    value: function _getRenderedHeaderRow() {\n      var _this4 = this;\n\n      var _props4 = this.props;\n      var children = _props4.children;\n      var disableHeader = _props4.disableHeader;\n\n      var items = disableHeader ? [] : _react2.default.Children.toArray(children);\n\n      return items.map(function (column, index) {\n        return _this4._createHeader({ column: column, index: index });\n      });\n    }\n  }, {\n    key: '_getRowHeight',\n    value: function _getRowHeight(rowIndex) {\n      var rowHeight = this.props.rowHeight;\n\n\n      return rowHeight instanceof Function ? rowHeight({ index: rowIndex }) : rowHeight;\n    }\n  }, {\n    key: '_onScroll',\n    value: function _onScroll(_ref7) {\n      var clientHeight = _ref7.clientHeight;\n      var scrollHeight = _ref7.scrollHeight;\n      var scrollTop = _ref7.scrollTop;\n      var onScroll = this.props.onScroll;\n\n\n      onScroll({ clientHeight: clientHeight, scrollHeight: scrollHeight, scrollTop: scrollTop });\n    }\n  }, {\n    key: '_onSectionRendered',\n    value: function _onSectionRendered(_ref8) {\n      var rowOverscanStartIndex = _ref8.rowOverscanStartIndex;\n      var rowOverscanStopIndex = _ref8.rowOverscanStopIndex;\n      var rowStartIndex = _ref8.rowStartIndex;\n      var rowStopIndex = _ref8.rowStopIndex;\n      var onRowsRendered = this.props.onRowsRendered;\n\n\n      onRowsRendered({\n        overscanStartIndex: rowOverscanStartIndex,\n        overscanStopIndex: rowOverscanStopIndex,\n        startIndex: rowStartIndex,\n        stopIndex: rowStopIndex\n      });\n    }\n  }, {\n    key: '_setScrollbarWidth',\n    value: function _setScrollbarWidth() {\n      var Grid = (0, _reactDom.findDOMNode)(this.Grid);\n      var clientWidth = Grid.clientWidth || 0;\n      var offsetWidth = Grid.offsetWidth || 0;\n      var scrollbarWidth = offsetWidth - clientWidth;\n\n      this.setState({ scrollbarWidth: scrollbarWidth });\n    }\n  }]);\n\n  return FlexTable;\n}(_react.Component);\n\nFlexTable.propTypes = {\n  'aria-label': _react.PropTypes.string,\n\n  /**\n   * Removes fixed height from the scrollingContainer so that the total height\n   * of rows can stretch the window. Intended for use with WindowScroller\n   */\n  autoHeight: _react.PropTypes.bool,\n\n  /** One or more FlexColumns describing the data displayed in this row */\n  children: function children(props, propName, componentName) {\n    var children = _react2.default.Children.toArray(props.children);\n    for (var i = 0; i < children.length; i++) {\n      if (children[i].type !== _FlexColumn2.default) {\n        return new Error('FlexTable only accepts children of type FlexColumn');\n      }\n    }\n  },\n\n  /** Optional CSS class name */\n  className: _react.PropTypes.string,\n\n  /** Disable rendering the header at all */\n  disableHeader: _react.PropTypes.bool,\n\n  /**\n   * Used to estimate the total height of a FlexTable before all of its rows have actually been measured.\n   * The estimated total height is adjusted as rows are rendered.\n   */\n  estimatedRowSize: _react.PropTypes.number.isRequired,\n\n  /** Optional custom CSS class name to attach to inner Grid element. */\n  gridClassName: _react.PropTypes.string,\n\n  /** Optional inline style to attach to inner Grid element. */\n  gridStyle: _react.PropTypes.object,\n\n  /** Optional CSS class to apply to all column headers */\n  headerClassName: _react.PropTypes.string,\n\n  /** Fixed height of header row */\n  headerHeight: _react.PropTypes.number.isRequired,\n\n  /** Fixed/available height for out DOM element */\n  height: _react.PropTypes.number.isRequired,\n\n  /** Optional renderer to be used in place of table body rows when rowCount is 0 */\n  noRowsRenderer: _react.PropTypes.func,\n\n  /**\n  * Optional callback when a column's header is clicked.\n  * ({ columnData: any, dataKey: string }): void\n  */\n  onHeaderClick: _react.PropTypes.func,\n\n  /** Optional custom inline style to attach to table header columns. */\n  headerStyle: _react.PropTypes.object,\n\n  /**\n   * Callback invoked when a user clicks on a table row.\n   * ({ index: number }): void\n   */\n  onRowClick: _react.PropTypes.func,\n\n  /**\n   * Callback invoked when a user double-clicks on a table row.\n   * ({ index: number }): void\n   */\n  onRowDoubleClick: _react.PropTypes.func,\n\n  /**\n   * Callback invoked when the mouse leaves a table row.\n   * ({ index: number }): void\n   */\n  onRowMouseOut: _react.PropTypes.func,\n\n  /**\n   * Callback invoked when a user moves the mouse over a table row.\n   * ({ index: number }): void\n   */\n  onRowMouseOver: _react.PropTypes.func,\n\n  /**\n   * Callback invoked with information about the slice of rows that were just rendered.\n   * ({ startIndex, stopIndex }): void\n   */\n  onRowsRendered: _react.PropTypes.func,\n\n  /**\n   * Callback invoked whenever the scroll offset changes within the inner scrollable region.\n   * This callback can be used to sync scrolling between lists, tables, or grids.\n   * ({ clientHeight, scrollHeight, scrollTop }): void\n   */\n  onScroll: _react.PropTypes.func.isRequired,\n\n  /**\n   * Number of rows to render above/below the visible bounds of the list.\n   * These rows can help for smoother scrolling on touch devices.\n   */\n  overscanRowCount: _react.PropTypes.number.isRequired,\n\n  /**\n   * Optional CSS class to apply to all table rows (including the header row).\n   * This property can be a CSS class name (string) or a function that returns a class name.\n   * If a function is provided its signature should be: ({ index: number }): string\n   */\n  rowClassName: _react.PropTypes.oneOfType([_react.PropTypes.string, _react.PropTypes.func]),\n\n  /**\n   * Callback responsible for returning a data row given an index.\n   * ({ index: number }): any\n   */\n  rowGetter: _react.PropTypes.func.isRequired,\n\n  /**\n   * Either a fixed row height (number) or a function that returns the height of a row given its index.\n   * ({ index: number }): number\n   */\n  rowHeight: _react.PropTypes.oneOfType([_react.PropTypes.number, _react.PropTypes.func]).isRequired,\n\n  /** Number of rows in table. */\n  rowCount: _react.PropTypes.number.isRequired,\n\n  /**\n   * Responsible for rendering a table row given an array of columns:\n   * Should implement the following interface: ({\n   *   className: string,\n   *   columns: Array,\n   *   index: number,\n   *   isScrolling: boolean,\n   *   onRowClick: ?Function,\n   *   onRowDoubleClick: ?Function,\n   *   onRowMouseOver: ?Function,\n   *   onRowMouseOut: ?Function,\n   *   rowData: any,\n   *   style: any\n   * }): PropTypes.node\n   */\n  rowRenderer: _react.PropTypes.func,\n\n  /** Optional custom inline style to attach to table rows. */\n  rowStyle: _react.PropTypes.oneOfType([_react.PropTypes.object, _react.PropTypes.func]).isRequired,\n\n  /** Optional custom CSS class for individual rows */\n  rowWrapperClassName: _react.PropTypes.oneOfType([_react.PropTypes.string, _react.PropTypes.func]),\n\n  /** Optional custom CSS class for individual rows */\n  rowWrapperStyle: _react.PropTypes.oneOfType([_react.PropTypes.object, _react.PropTypes.func]),\n\n  /** See Grid#scrollToAlignment */\n  scrollToAlignment: _react.PropTypes.oneOf(['auto', 'end', 'start', 'center']).isRequired,\n\n  /** Row index to ensure visible (by forcefully scrolling if necessary) */\n  scrollToIndex: _react.PropTypes.number,\n\n  /** Vertical offset. */\n  scrollTop: _react.PropTypes.number,\n\n  /**\n   * Sort function to be called if a sortable header is clicked.\n   * ({ sortBy: string, sortDirection: SortDirection }): void\n   */\n  sort: _react.PropTypes.func,\n\n  /** FlexTable data is currently sorted by this :dataKey (if it is sorted at all) */\n  sortBy: _react.PropTypes.string,\n\n  /** FlexTable data is currently sorted in this direction (if it is sorted at all) */\n  sortDirection: _react.PropTypes.oneOf([_SortDirection2.default.ASC, _SortDirection2.default.DESC]),\n\n  /** Optional inline style */\n  style: _react.PropTypes.object,\n\n  /** Tab index for focus */\n  tabIndex: _react.PropTypes.number,\n\n  /** Width of list */\n  width: _react.PropTypes.number.isRequired\n};\nFlexTable.defaultProps = {\n  disableHeader: false,\n  estimatedRowSize: 30,\n  headerHeight: 0,\n  headerStyle: {},\n  noRowsRenderer: function noRowsRenderer() {\n    return null;\n  },\n  onRowsRendered: function onRowsRendered() {\n    return null;\n  },\n  onScroll: function onScroll() {\n    return null;\n  },\n  overscanRowCount: 10,\n  rowRenderer: _defaultRowRenderer2.default,\n  rowStyle: {},\n  scrollToAlignment: 'auto',\n  style: {}\n};\nexports.default = FlexTable;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nvar SortDirection = {\n  /**\n   * Sort items in ascending order.\n   * This means arranging from the lowest value to the highest (e.g. a-z, 0-9).\n   */\n  ASC: 'ASC',\n\n  /**\n   * Sort items in descending order.\n   * This means arranging from the highest value to the lowest (e.g. z-a, 9-0).\n   */\n  DESC: 'DESC'\n};\n\nexports.default = SortDirection;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = SortIndicator;\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _classnames = require('classnames');\n\nvar _classnames2 = _interopRequireDefault(_classnames);\n\nvar _SortDirection = require('./SortDirection');\n\nvar _SortDirection2 = _interopRequireDefault(_SortDirection);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * Displayed beside a header to indicate that a FlexTable is currently sorted by this column.\n */\nfunction SortIndicator(_ref) {\n  var sortDirection = _ref.sortDirection;\n\n  var classNames = (0, _classnames2.default)('FlexTable__sortableHeaderIcon', {\n    'FlexTable__sortableHeaderIcon--ASC': sortDirection === _SortDirection2.default.ASC,\n    'FlexTable__sortableHeaderIcon--DESC': sortDirection === _SortDirection2.default.DESC\n  });\n\n  return _react2.default.createElement(\n    'svg',\n    {\n      className: classNames,\n      width: 18,\n      height: 18,\n      viewBox: '0 0 24 24'\n    },\n    sortDirection === _SortDirection2.default.ASC ? _react2.default.createElement('path', { d: 'M7 14l5-5 5 5z' }) : _react2.default.createElement('path', { d: 'M7 10l5 5 5-5z' }),\n    _react2.default.createElement('path', { d: 'M0 0h24v24H0z', fill: 'none' })\n  );\n}\nSortIndicator.propTypes = {\n  sortDirection: _react.PropTypes.oneOf([_SortDirection2.default.ASC, _SortDirection2.default.DESC])\n};","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = defaultCellDataGetter;\n\n\n/**\n * Default accessor for returning a cell value for a given attribute.\n * This function expects to operate on either a vanilla Object or an Immutable Map.\n * You should override the column's cellDataGetter if your data is some other type of object.\n */\nfunction defaultCellDataGetter(_ref) {\n  var columnData = _ref.columnData;\n  var dataKey = _ref.dataKey;\n  var rowData = _ref.rowData;\n\n  if (rowData.get instanceof Function) {\n    return rowData.get(dataKey);\n  } else {\n    return rowData[dataKey];\n  }\n}","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = defaultCellRenderer;\n\n\n/**\n * Default cell renderer that displays an attribute as a simple string\n * You should override the column's cellRenderer if your data is some other type of object.\n */\nfunction defaultCellRenderer(_ref) {\n  var cellData = _ref.cellData;\n  var cellDataKey = _ref.cellDataKey;\n  var columnData = _ref.columnData;\n  var rowData = _ref.rowData;\n  var rowIndex = _ref.rowIndex;\n\n  if (cellData == null) {\n    return '';\n  } else {\n    return String(cellData);\n  }\n}","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = defaultHeaderRenderer;\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _SortIndicator = require('./SortIndicator');\n\nvar _SortIndicator2 = _interopRequireDefault(_SortIndicator);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * Default table header renderer.\n */\nfunction defaultHeaderRenderer(_ref) {\n  var columnData = _ref.columnData;\n  var dataKey = _ref.dataKey;\n  var disableSort = _ref.disableSort;\n  var label = _ref.label;\n  var sortBy = _ref.sortBy;\n  var sortDirection = _ref.sortDirection;\n\n  var showSortIndicator = sortBy === dataKey;\n  var children = [_react2.default.createElement(\n    'span',\n    {\n      className: 'FlexTable__headerTruncatedText',\n      key: 'label',\n      title: label\n    },\n    label\n  )];\n\n  if (showSortIndicator) {\n    children.push(_react2.default.createElement(_SortIndicator2.default, {\n      key: 'SortIndicator',\n      sortDirection: sortDirection\n    }));\n  }\n\n  return children;\n}","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nexports.default = defaultRowRenderer;\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * Default row renderer for FlexTable.\n */\nfunction defaultRowRenderer(_ref) {\n  var className = _ref.className;\n  var columns = _ref.columns;\n  var index = _ref.index;\n  var isScrolling = _ref.isScrolling;\n  var onRowClick = _ref.onRowClick;\n  var onRowDoubleClick = _ref.onRowDoubleClick;\n  var onRowMouseOver = _ref.onRowMouseOver;\n  var onRowMouseOut = _ref.onRowMouseOut;\n  var rowData = _ref.rowData;\n  var style = _ref.style;\n\n  var a11yProps = {};\n\n  if (onRowClick || onRowDoubleClick || onRowMouseOver || onRowMouseOut) {\n    a11yProps['aria-label'] = 'row';\n    a11yProps.role = 'row';\n    a11yProps.tabIndex = 0;\n\n    if (onRowClick) {\n      a11yProps.onClick = function () {\n        return onRowClick({ index: index });\n      };\n    }\n    if (onRowDoubleClick) {\n      a11yProps.onDoubleClick = function () {\n        return onRowDoubleClick({ index: index });\n      };\n    }\n    if (onRowMouseOut) {\n      a11yProps.onMouseOut = function () {\n        return onRowMouseOut({ index: index });\n      };\n    }\n    if (onRowMouseOver) {\n      a11yProps.onMouseOver = function () {\n        return onRowMouseOver({ index: index });\n      };\n    }\n  }\n\n  return _react2.default.createElement(\n    'div',\n    _extends({}, a11yProps, {\n      className: className,\n      style: style\n    }),\n    columns\n  );\n}","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.SortIndicator = exports.SortDirection = exports.FlexColumn = exports.FlexTable = exports.defaultRowRenderer = exports.defaultHeaderRenderer = exports.defaultCellRenderer = exports.defaultCellDataGetter = exports.default = undefined;\n\nvar _FlexTable2 = require('./FlexTable');\n\nvar _FlexTable3 = _interopRequireDefault(_FlexTable2);\n\nvar _defaultCellDataGetter2 = require('./defaultCellDataGetter');\n\nvar _defaultCellDataGetter3 = _interopRequireDefault(_defaultCellDataGetter2);\n\nvar _defaultCellRenderer2 = require('./defaultCellRenderer');\n\nvar _defaultCellRenderer3 = _interopRequireDefault(_defaultCellRenderer2);\n\nvar _defaultHeaderRenderer2 = require('./defaultHeaderRenderer');\n\nvar _defaultHeaderRenderer3 = _interopRequireDefault(_defaultHeaderRenderer2);\n\nvar _defaultRowRenderer2 = require('./defaultRowRenderer');\n\nvar _defaultRowRenderer3 = _interopRequireDefault(_defaultRowRenderer2);\n\nvar _FlexColumn2 = require('./FlexColumn');\n\nvar _FlexColumn3 = _interopRequireDefault(_FlexColumn2);\n\nvar _SortDirection2 = require('./SortDirection');\n\nvar _SortDirection3 = _interopRequireDefault(_SortDirection2);\n\nvar _SortIndicator2 = require('./SortIndicator');\n\nvar _SortIndicator3 = _interopRequireDefault(_SortIndicator2);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = _FlexTable3.default;\nexports.defaultCellDataGetter = _defaultCellDataGetter3.default;\nexports.defaultCellRenderer = _defaultCellRenderer3.default;\nexports.defaultHeaderRenderer = _defaultHeaderRenderer3.default;\nexports.defaultRowRenderer = _defaultRowRenderer3.default;\nexports.FlexTable = _FlexTable3.default;\nexports.FlexColumn = _FlexColumn3.default;\nexports.SortDirection = _SortDirection3.default;\nexports.SortIndicator = _SortIndicator3.default;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.DEFAULT_SCROLLING_RESET_TIME_INTERVAL = undefined;\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _classnames = require('classnames');\n\nvar _classnames2 = _interopRequireDefault(_classnames);\n\nvar _calculateSizeAndPositionDataAndUpdateScrollOffset = require('./utils/calculateSizeAndPositionDataAndUpdateScrollOffset');\n\nvar _calculateSizeAndPositionDataAndUpdateScrollOffset2 = _interopRequireDefault(_calculateSizeAndPositionDataAndUpdateScrollOffset);\n\nvar _ScalingCellSizeAndPositionManager = require('./utils/ScalingCellSizeAndPositionManager');\n\nvar _ScalingCellSizeAndPositionManager2 = _interopRequireDefault(_ScalingCellSizeAndPositionManager);\n\nvar _createCallbackMemoizer = require('../utils/createCallbackMemoizer');\n\nvar _createCallbackMemoizer2 = _interopRequireDefault(_createCallbackMemoizer);\n\nvar _getOverscanIndices = require('./utils/getOverscanIndices');\n\nvar _getOverscanIndices2 = _interopRequireDefault(_getOverscanIndices);\n\nvar _scrollbarSize = require('dom-helpers/util/scrollbarSize');\n\nvar _scrollbarSize2 = _interopRequireDefault(_scrollbarSize);\n\nvar _raf = require('raf');\n\nvar _raf2 = _interopRequireDefault(_raf);\n\nvar _reactAddonsShallowCompare = require('react-addons-shallow-compare');\n\nvar _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare);\n\nvar _updateScrollIndexHelper = require('./utils/updateScrollIndexHelper');\n\nvar _updateScrollIndexHelper2 = _interopRequireDefault(_updateScrollIndexHelper);\n\nvar _defaultCellRangeRenderer = require('./defaultCellRangeRenderer');\n\nvar _defaultCellRangeRenderer2 = _interopRequireDefault(_defaultCellRangeRenderer);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/**\n * Specifies the number of miliseconds during which to disable pointer events while a scroll is in progress.\n * This improves performance and makes scrolling smoother.\n */\nvar DEFAULT_SCROLLING_RESET_TIME_INTERVAL = exports.DEFAULT_SCROLLING_RESET_TIME_INTERVAL = 150;\n\n/**\n * Controls whether the Grid updates the DOM element's scrollLeft/scrollTop based on the current state or just observes it.\n * This prevents Grid from interrupting mouse-wheel animations (see issue #2).\n */\nvar SCROLL_POSITION_CHANGE_REASONS = {\n  OBSERVED: 'observed',\n  REQUESTED: 'requested'\n};\n\n/**\n * Renders tabular data with virtualization along the vertical and horizontal axes.\n * Row heights and column widths must be known ahead of time and specified as properties.\n */\n\nvar Grid = function (_Component) {\n  _inherits(Grid, _Component);\n\n  function Grid(props, context) {\n    _classCallCheck(this, Grid);\n\n    var _this = _possibleConstructorReturn(this, (Grid.__proto__ || Object.getPrototypeOf(Grid)).call(this, props, context));\n\n    _this.state = {\n      isScrolling: false,\n      scrollDirectionHorizontal: _getOverscanIndices.SCROLL_DIRECTION_FIXED,\n      scrollDirectionVertical: _getOverscanIndices.SCROLL_DIRECTION_FIXED,\n      scrollLeft: 0,\n      scrollTop: 0\n    };\n\n    // Invokes onSectionRendered callback only when start/stop row or column indices change\n    _this._onGridRenderedMemoizer = (0, _createCallbackMemoizer2.default)();\n    _this._onScrollMemoizer = (0, _createCallbackMemoizer2.default)(false);\n\n    // Bind functions to instance so they don't lose context when passed around\n    _this._enablePointerEventsAfterDelayCallback = _this._enablePointerEventsAfterDelayCallback.bind(_this);\n    _this._invokeOnGridRenderedHelper = _this._invokeOnGridRenderedHelper.bind(_this);\n    _this._onScroll = _this._onScroll.bind(_this);\n    _this._setNextStateCallback = _this._setNextStateCallback.bind(_this);\n    _this._updateScrollLeftForScrollToColumn = _this._updateScrollLeftForScrollToColumn.bind(_this);\n    _this._updateScrollTopForScrollToRow = _this._updateScrollTopForScrollToRow.bind(_this);\n\n    _this._columnWidthGetter = _this._wrapSizeGetter(props.columnWidth);\n    _this._rowHeightGetter = _this._wrapSizeGetter(props.rowHeight);\n\n    _this._columnSizeAndPositionManager = new _ScalingCellSizeAndPositionManager2.default({\n      cellCount: props.columnCount,\n      cellSizeGetter: function cellSizeGetter(index) {\n        return _this._columnWidthGetter(index);\n      },\n      estimatedCellSize: _this._getEstimatedColumnSize(props)\n    });\n    _this._rowSizeAndPositionManager = new _ScalingCellSizeAndPositionManager2.default({\n      cellCount: props.rowCount,\n      cellSizeGetter: function cellSizeGetter(index) {\n        return _this._rowHeightGetter(index);\n      },\n      estimatedCellSize: _this._getEstimatedRowSize(props)\n    });\n\n    // See defaultCellRangeRenderer() for more information on the usage of this cache\n    _this._cellCache = {};\n    return _this;\n  }\n\n  /**\n   * Pre-measure all columns and rows in a Grid.\n   * Typically cells are only measured as needed and estimated sizes are used for cells that have not yet been measured.\n   * This method ensures that the next call to getTotalSize() returns an exact size (as opposed to just an estimated one).\n   */\n\n\n  _createClass(Grid, [{\n    key: 'measureAllCells',\n    value: function measureAllCells() {\n      var _props = this.props;\n      var columnCount = _props.columnCount;\n      var rowCount = _props.rowCount;\n\n\n      this._columnSizeAndPositionManager.getSizeAndPositionOfCell(columnCount - 1);\n      this._rowSizeAndPositionManager.getSizeAndPositionOfCell(rowCount - 1);\n    }\n\n    /**\n     * Forced recompute of row heights and column widths.\n     * This function should be called if dynamic column or row sizes have changed but nothing else has.\n     * Since Grid only receives :columnCount and :rowCount it has no way of detecting when the underlying data changes.\n     */\n\n  }, {\n    key: 'recomputeGridSize',\n    value: function recomputeGridSize() {\n      var _ref = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n\n      var _ref$columnIndex = _ref.columnIndex;\n      var columnIndex = _ref$columnIndex === undefined ? 0 : _ref$columnIndex;\n      var _ref$rowIndex = _ref.rowIndex;\n      var rowIndex = _ref$rowIndex === undefined ? 0 : _ref$rowIndex;\n\n      this._columnSizeAndPositionManager.resetCell(columnIndex);\n      this._rowSizeAndPositionManager.resetCell(rowIndex);\n\n      // Clear cell cache in case we are scrolling;\n      // Invalid row heights likely mean invalid cached content as well.\n      this._cellCache = {};\n\n      this.forceUpdate();\n    }\n  }, {\n    key: 'componentDidMount',\n    value: function componentDidMount() {\n      var _props2 = this.props;\n      var scrollLeft = _props2.scrollLeft;\n      var scrollToColumn = _props2.scrollToColumn;\n      var scrollTop = _props2.scrollTop;\n      var scrollToRow = _props2.scrollToRow;\n\n      // If this component was first rendered server-side, scrollbar size will be undefined.\n      // In that event we need to remeasure.\n\n      if (!this._scrollbarSizeMeasured) {\n        this._scrollbarSize = (0, _scrollbarSize2.default)();\n        this._scrollbarSizeMeasured = true;\n        this.setState({});\n      }\n\n      if (scrollLeft >= 0 || scrollTop >= 0) {\n        this._setScrollPosition({ scrollLeft: scrollLeft, scrollTop: scrollTop });\n      }\n\n      if (scrollToColumn >= 0 || scrollToRow >= 0) {\n        this._updateScrollLeftForScrollToColumn();\n        this._updateScrollTopForScrollToRow();\n      }\n\n      // Update onRowsRendered callback\n      this._invokeOnGridRenderedHelper();\n\n      // Initialize onScroll callback\n      this._invokeOnScrollMemoizer({\n        scrollLeft: scrollLeft || 0,\n        scrollTop: scrollTop || 0,\n        totalColumnsWidth: this._columnSizeAndPositionManager.getTotalSize(),\n        totalRowsHeight: this._rowSizeAndPositionManager.getTotalSize()\n      });\n    }\n\n    /**\n     * @private\n     * This method updates scrollLeft/scrollTop in state for the following conditions:\n     * 1) New scroll-to-cell props have been set\n     */\n\n  }, {\n    key: 'componentDidUpdate',\n    value: function componentDidUpdate(prevProps, prevState) {\n      var _this2 = this;\n\n      var _props3 = this.props;\n      var autoHeight = _props3.autoHeight;\n      var columnCount = _props3.columnCount;\n      var height = _props3.height;\n      var rowCount = _props3.rowCount;\n      var scrollToAlignment = _props3.scrollToAlignment;\n      var scrollToColumn = _props3.scrollToColumn;\n      var scrollToRow = _props3.scrollToRow;\n      var width = _props3.width;\n      var _state = this.state;\n      var scrollLeft = _state.scrollLeft;\n      var scrollPositionChangeReason = _state.scrollPositionChangeReason;\n      var scrollTop = _state.scrollTop;\n\n      // Handle edge case where column or row count has only just increased over 0.\n      // In this case we may have to restore a previously-specified scroll offset.\n      // For more info see bvaughn/react-virtualized/issues/218\n\n      var columnOrRowCountJustIncreasedFromZero = columnCount > 0 && prevProps.columnCount === 0 || rowCount > 0 && prevProps.rowCount === 0;\n\n      // Make sure requested changes to :scrollLeft or :scrollTop get applied.\n      // Assigning to scrollLeft/scrollTop tells the browser to interrupt any running scroll animations,\n      // And to discard any pending async changes to the scroll position that may have happened in the meantime (e.g. on a separate scrolling thread).\n      // So we only set these when we require an adjustment of the scroll position.\n      // See issue #2 for more information.\n      if (scrollPositionChangeReason === SCROLL_POSITION_CHANGE_REASONS.REQUESTED) {\n        if (scrollLeft >= 0 && (scrollLeft !== prevState.scrollLeft && scrollLeft !== this._scrollingContainer.scrollLeft || columnOrRowCountJustIncreasedFromZero)) {\n          this._scrollingContainer.scrollLeft = scrollLeft;\n        }\n\n        // @TRICKY :autoHeight property instructs Grid to leave :scrollTop management to an external HOC (eg WindowScroller).\n        // In this case we should avoid checking scrollingContainer.scrollTop since it forces layout/flow.\n        if (!autoHeight && scrollTop >= 0 && (scrollTop !== prevState.scrollTop && scrollTop !== this._scrollingContainer.scrollTop || columnOrRowCountJustIncreasedFromZero)) {\n          this._scrollingContainer.scrollTop = scrollTop;\n        }\n      }\n\n      // Update scroll offsets if the current :scrollToColumn or :scrollToRow values requires it\n      // @TODO Do we also need this check or can the one in componentWillUpdate() suffice?\n      (0, _updateScrollIndexHelper2.default)({\n        cellSizeAndPositionManager: this._columnSizeAndPositionManager,\n        previousCellsCount: prevProps.columnCount,\n        previousCellSize: prevProps.columnWidth,\n        previousScrollToAlignment: prevProps.scrollToAlignment,\n        previousScrollToIndex: prevProps.scrollToColumn,\n        previousSize: prevProps.width,\n        scrollOffset: scrollLeft,\n        scrollToAlignment: scrollToAlignment,\n        scrollToIndex: scrollToColumn,\n        size: width,\n        updateScrollIndexCallback: function updateScrollIndexCallback(scrollToColumn) {\n          return _this2._updateScrollLeftForScrollToColumn(_extends({}, _this2.props, { scrollToColumn: scrollToColumn }));\n        }\n      });\n      (0, _updateScrollIndexHelper2.default)({\n        cellSizeAndPositionManager: this._rowSizeAndPositionManager,\n        previousCellsCount: prevProps.rowCount,\n        previousCellSize: prevProps.rowHeight,\n        previousScrollToAlignment: prevProps.scrollToAlignment,\n        previousScrollToIndex: prevProps.scrollToRow,\n        previousSize: prevProps.height,\n        scrollOffset: scrollTop,\n        scrollToAlignment: scrollToAlignment,\n        scrollToIndex: scrollToRow,\n        size: height,\n        updateScrollIndexCallback: function updateScrollIndexCallback(scrollToRow) {\n          return _this2._updateScrollTopForScrollToRow(_extends({}, _this2.props, { scrollToRow: scrollToRow }));\n        }\n      });\n\n      // Update onRowsRendered callback if start/stop indices have changed\n      this._invokeOnGridRenderedHelper();\n    }\n  }, {\n    key: 'componentWillMount',\n    value: function componentWillMount() {\n      // If this component is being rendered server-side, getScrollbarSize() will return undefined.\n      // We handle this case in componentDidMount()\n      this._scrollbarSize = (0, _scrollbarSize2.default)();\n      if (this._scrollbarSize === undefined) {\n        this._scrollbarSizeMeasured = false;\n        this._scrollbarSize = 0;\n      } else {\n        this._scrollbarSizeMeasured = true;\n      }\n\n      this._calculateChildrenToRender();\n    }\n  }, {\n    key: 'componentWillUnmount',\n    value: function componentWillUnmount() {\n      if (this._disablePointerEventsTimeoutId) {\n        clearTimeout(this._disablePointerEventsTimeoutId);\n      }\n\n      if (this._setNextStateAnimationFrameId) {\n        _raf2.default.cancel(this._setNextStateAnimationFrameId);\n      }\n    }\n\n    /**\n     * @private\n     * This method updates scrollLeft/scrollTop in state for the following conditions:\n     * 1) Empty content (0 rows or columns)\n     * 2) New scroll props overriding the current state\n     * 3) Cells-count or cells-size has changed, making previous scroll offsets invalid\n     */\n\n  }, {\n    key: 'componentWillUpdate',\n    value: function componentWillUpdate(nextProps, nextState) {\n      var _this3 = this;\n\n      if (nextProps.columnCount === 0 && nextState.scrollLeft !== 0 || nextProps.rowCount === 0 && nextState.scrollTop !== 0) {\n        this._setScrollPosition({\n          scrollLeft: 0,\n          scrollTop: 0\n        });\n      } else if (nextProps.scrollLeft !== this.props.scrollLeft || nextProps.scrollTop !== this.props.scrollTop) {\n        this._setScrollPosition({\n          scrollLeft: nextProps.scrollLeft,\n          scrollTop: nextProps.scrollTop\n        });\n      }\n\n      this._columnWidthGetter = this._wrapSizeGetter(nextProps.columnWidth);\n      this._rowHeightGetter = this._wrapSizeGetter(nextProps.rowHeight);\n\n      this._columnSizeAndPositionManager.configure({\n        cellCount: nextProps.columnCount,\n        estimatedCellSize: this._getEstimatedColumnSize(nextProps)\n      });\n      this._rowSizeAndPositionManager.configure({\n        cellCount: nextProps.rowCount,\n        estimatedCellSize: this._getEstimatedRowSize(nextProps)\n      });\n\n      // Update scroll offsets if the size or number of cells have changed, invalidating the previous value\n      (0, _calculateSizeAndPositionDataAndUpdateScrollOffset2.default)({\n        cellCount: this.props.columnCount,\n        cellSize: this.props.columnWidth,\n        computeMetadataCallback: function computeMetadataCallback() {\n          return _this3._columnSizeAndPositionManager.resetCell(0);\n        },\n        computeMetadataCallbackProps: nextProps,\n        nextCellsCount: nextProps.columnCount,\n        nextCellSize: nextProps.columnWidth,\n        nextScrollToIndex: nextProps.scrollToColumn,\n        scrollToIndex: this.props.scrollToColumn,\n        updateScrollOffsetForScrollToIndex: function updateScrollOffsetForScrollToIndex() {\n          return _this3._updateScrollLeftForScrollToColumn(nextProps, nextState);\n        }\n      });\n      (0, _calculateSizeAndPositionDataAndUpdateScrollOffset2.default)({\n        cellCount: this.props.rowCount,\n        cellSize: this.props.rowHeight,\n        computeMetadataCallback: function computeMetadataCallback() {\n          return _this3._rowSizeAndPositionManager.resetCell(0);\n        },\n        computeMetadataCallbackProps: nextProps,\n        nextCellsCount: nextProps.rowCount,\n        nextCellSize: nextProps.rowHeight,\n        nextScrollToIndex: nextProps.scrollToRow,\n        scrollToIndex: this.props.scrollToRow,\n        updateScrollOffsetForScrollToIndex: function updateScrollOffsetForScrollToIndex() {\n          return _this3._updateScrollTopForScrollToRow(nextProps, nextState);\n        }\n      });\n\n      this._calculateChildrenToRender(nextProps, nextState);\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      var _this4 = this;\n\n      var _props4 = this.props;\n      var autoContainerWidth = _props4.autoContainerWidth;\n      var autoHeight = _props4.autoHeight;\n      var className = _props4.className;\n      var height = _props4.height;\n      var noContentRenderer = _props4.noContentRenderer;\n      var style = _props4.style;\n      var tabIndex = _props4.tabIndex;\n      var width = _props4.width;\n      var isScrolling = this.state.isScrolling;\n\n\n      var gridStyle = {\n        height: autoHeight ? 'auto' : height,\n        width: width\n      };\n\n      var totalColumnsWidth = this._columnSizeAndPositionManager.getTotalSize();\n      var totalRowsHeight = this._rowSizeAndPositionManager.getTotalSize();\n\n      // Force browser to hide scrollbars when we know they aren't necessary.\n      // Otherwise once scrollbars appear they may not disappear again.\n      // For more info see issue #116\n      var verticalScrollBarSize = totalRowsHeight > height ? this._scrollbarSize : 0;\n      var horizontalScrollBarSize = totalColumnsWidth > width ? this._scrollbarSize : 0;\n\n      // Also explicitly init styles to 'auto' if scrollbars are required.\n      // This works around an obscure edge case where external CSS styles have not yet been loaded,\n      // But an initial scroll index of offset is set as an external prop.\n      // Without this style, Grid would render the correct range of cells but would NOT update its internal offset.\n      // This was originally reported via clauderic/react-infinite-calendar/issues/23\n      gridStyle.overflowX = totalColumnsWidth + verticalScrollBarSize <= width ? 'hidden' : 'auto';\n      gridStyle.overflowY = totalRowsHeight + horizontalScrollBarSize <= height ? 'hidden' : 'auto';\n\n      var childrenToDisplay = this._childrenToDisplay;\n\n      var showNoContentRenderer = childrenToDisplay.length === 0 && height > 0 && width > 0;\n\n      return _react2.default.createElement(\n        'div',\n        {\n          ref: function ref(_ref2) {\n            _this4._scrollingContainer = _ref2;\n          },\n          'aria-label': this.props['aria-label'],\n          className: (0, _classnames2.default)('Grid', className),\n          onScroll: this._onScroll,\n          role: 'grid',\n          style: _extends({}, gridStyle, style),\n          tabIndex: tabIndex\n        },\n        childrenToDisplay.length > 0 && _react2.default.createElement(\n          'div',\n          {\n            className: 'Grid__innerScrollContainer',\n            style: {\n              width: autoContainerWidth ? 'auto' : totalColumnsWidth,\n              height: totalRowsHeight,\n              maxWidth: totalColumnsWidth,\n              maxHeight: totalRowsHeight,\n              pointerEvents: isScrolling ? 'none' : ''\n            }\n          },\n          childrenToDisplay\n        ),\n        showNoContentRenderer && noContentRenderer()\n      );\n    }\n  }, {\n    key: 'shouldComponentUpdate',\n    value: function shouldComponentUpdate(nextProps, nextState) {\n      return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState);\n    }\n\n    /* ---------------------------- Helper methods ---------------------------- */\n\n  }, {\n    key: '_calculateChildrenToRender',\n    value: function _calculateChildrenToRender() {\n      var props = arguments.length <= 0 || arguments[0] === undefined ? this.props : arguments[0];\n      var state = arguments.length <= 1 || arguments[1] === undefined ? this.state : arguments[1];\n      var cellClassName = props.cellClassName;\n      var cellRenderer = props.cellRenderer;\n      var cellRangeRenderer = props.cellRangeRenderer;\n      var cellStyle = props.cellStyle;\n      var columnCount = props.columnCount;\n      var height = props.height;\n      var overscanColumnCount = props.overscanColumnCount;\n      var overscanRowCount = props.overscanRowCount;\n      var rowCount = props.rowCount;\n      var width = props.width;\n      var isScrolling = state.isScrolling;\n      var scrollDirectionHorizontal = state.scrollDirectionHorizontal;\n      var scrollDirectionVertical = state.scrollDirectionVertical;\n      var scrollLeft = state.scrollLeft;\n      var scrollTop = state.scrollTop;\n\n\n      this._childrenToDisplay = [];\n\n      // Render only enough columns and rows to cover the visible area of the grid.\n      if (height > 0 && width > 0) {\n        var visibleColumnIndices = this._columnSizeAndPositionManager.getVisibleCellRange({\n          containerSize: width,\n          offset: scrollLeft\n        });\n        var visibleRowIndices = this._rowSizeAndPositionManager.getVisibleCellRange({\n          containerSize: height,\n          offset: scrollTop\n        });\n\n        var horizontalOffsetAdjustment = this._columnSizeAndPositionManager.getOffsetAdjustment({\n          containerSize: width,\n          offset: scrollLeft\n        });\n        var verticalOffsetAdjustment = this._rowSizeAndPositionManager.getOffsetAdjustment({\n          containerSize: height,\n          offset: scrollTop\n        });\n\n        // Store for _invokeOnGridRenderedHelper()\n        this._renderedColumnStartIndex = visibleColumnIndices.start;\n        this._renderedColumnStopIndex = visibleColumnIndices.stop;\n        this._renderedRowStartIndex = visibleRowIndices.start;\n        this._renderedRowStopIndex = visibleRowIndices.stop;\n\n        var overscanColumnIndices = (0, _getOverscanIndices2.default)({\n          cellCount: columnCount,\n          overscanCellsCount: overscanColumnCount,\n          scrollDirection: scrollDirectionHorizontal,\n          startIndex: this._renderedColumnStartIndex,\n          stopIndex: this._renderedColumnStopIndex\n        });\n\n        var overscanRowIndices = (0, _getOverscanIndices2.default)({\n          cellCount: rowCount,\n          overscanCellsCount: overscanRowCount,\n          scrollDirection: scrollDirectionVertical,\n          startIndex: this._renderedRowStartIndex,\n          stopIndex: this._renderedRowStopIndex\n        });\n\n        // Store for _invokeOnGridRenderedHelper()\n        this._columnStartIndex = overscanColumnIndices.overscanStartIndex;\n        this._columnStopIndex = overscanColumnIndices.overscanStopIndex;\n        this._rowStartIndex = overscanRowIndices.overscanStartIndex;\n        this._rowStopIndex = overscanRowIndices.overscanStopIndex;\n\n        this._childrenToDisplay = cellRangeRenderer({\n          cellCache: this._cellCache,\n          cellClassName: this._wrapCellClassNameGetter(cellClassName),\n          cellRenderer: cellRenderer,\n          cellStyle: this._wrapCellStyleGetter(cellStyle),\n          columnSizeAndPositionManager: this._columnSizeAndPositionManager,\n          columnStartIndex: this._columnStartIndex,\n          columnStopIndex: this._columnStopIndex,\n          horizontalOffsetAdjustment: horizontalOffsetAdjustment,\n          isScrolling: isScrolling,\n          rowSizeAndPositionManager: this._rowSizeAndPositionManager,\n          rowStartIndex: this._rowStartIndex,\n          rowStopIndex: this._rowStopIndex,\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop,\n          verticalOffsetAdjustment: verticalOffsetAdjustment\n        });\n      }\n    }\n\n    /**\n     * Sets an :isScrolling flag for a small window of time.\n     * This flag is used to disable pointer events on the scrollable portion of the Grid.\n     * This prevents jerky/stuttery mouse-wheel scrolling.\n     */\n\n  }, {\n    key: '_enablePointerEventsAfterDelay',\n    value: function _enablePointerEventsAfterDelay() {\n      var scrollingResetTimeInterval = this.props.scrollingResetTimeInterval;\n\n\n      if (this._disablePointerEventsTimeoutId) {\n        clearTimeout(this._disablePointerEventsTimeoutId);\n      }\n\n      this._disablePointerEventsTimeoutId = setTimeout(this._enablePointerEventsAfterDelayCallback, scrollingResetTimeInterval);\n    }\n  }, {\n    key: '_enablePointerEventsAfterDelayCallback',\n    value: function _enablePointerEventsAfterDelayCallback() {\n      this._disablePointerEventsTimeoutId = null;\n\n      // Throw away cell cache once scrolling is complete\n      this._cellCache = {};\n\n      this.setState({\n        isScrolling: false,\n        scrollDirectionHorizontal: _getOverscanIndices.SCROLL_DIRECTION_FIXED,\n        scrollDirectionVertical: _getOverscanIndices.SCROLL_DIRECTION_FIXED\n      });\n    }\n  }, {\n    key: '_getEstimatedColumnSize',\n    value: function _getEstimatedColumnSize(props) {\n      return typeof props.columnWidth === 'number' ? props.columnWidth : props.estimatedColumnSize;\n    }\n  }, {\n    key: '_getEstimatedRowSize',\n    value: function _getEstimatedRowSize(props) {\n      return typeof props.rowHeight === 'number' ? props.rowHeight : props.estimatedRowSize;\n    }\n  }, {\n    key: '_invokeOnGridRenderedHelper',\n    value: function _invokeOnGridRenderedHelper() {\n      var onSectionRendered = this.props.onSectionRendered;\n\n\n      this._onGridRenderedMemoizer({\n        callback: onSectionRendered,\n        indices: {\n          columnOverscanStartIndex: this._columnStartIndex,\n          columnOverscanStopIndex: this._columnStopIndex,\n          columnStartIndex: this._renderedColumnStartIndex,\n          columnStopIndex: this._renderedColumnStopIndex,\n          rowOverscanStartIndex: this._rowStartIndex,\n          rowOverscanStopIndex: this._rowStopIndex,\n          rowStartIndex: this._renderedRowStartIndex,\n          rowStopIndex: this._renderedRowStopIndex\n        }\n      });\n    }\n  }, {\n    key: '_invokeOnScrollMemoizer',\n    value: function _invokeOnScrollMemoizer(_ref3) {\n      var _this5 = this;\n\n      var scrollLeft = _ref3.scrollLeft;\n      var scrollTop = _ref3.scrollTop;\n      var totalColumnsWidth = _ref3.totalColumnsWidth;\n      var totalRowsHeight = _ref3.totalRowsHeight;\n\n      this._onScrollMemoizer({\n        callback: function callback(_ref4) {\n          var scrollLeft = _ref4.scrollLeft;\n          var scrollTop = _ref4.scrollTop;\n          var _props5 = _this5.props;\n          var height = _props5.height;\n          var onScroll = _props5.onScroll;\n          var width = _props5.width;\n\n\n          onScroll({\n            clientHeight: height,\n            clientWidth: width,\n            scrollHeight: totalRowsHeight,\n            scrollLeft: scrollLeft,\n            scrollTop: scrollTop,\n            scrollWidth: totalColumnsWidth\n          });\n        },\n        indices: {\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop\n        }\n      });\n    }\n\n    /**\n     * Updates the state during the next animation frame.\n     * Use this method to avoid multiple renders in a small span of time.\n     * This helps performance for bursty events (like onScroll).\n     */\n\n  }, {\n    key: '_setNextState',\n    value: function _setNextState(state) {\n      this._nextState = state;\n\n      if (!this._setNextStateAnimationFrameId) {\n        this._setNextStateAnimationFrameId = (0, _raf2.default)(this._setNextStateCallback);\n      }\n    }\n  }, {\n    key: '_setNextStateCallback',\n    value: function _setNextStateCallback() {\n      var state = this._nextState;\n\n      this._setNextStateAnimationFrameId = null;\n      this._nextState = null;\n\n      this.setState(state);\n    }\n  }, {\n    key: '_setScrollPosition',\n    value: function _setScrollPosition(_ref5) {\n      var scrollLeft = _ref5.scrollLeft;\n      var scrollTop = _ref5.scrollTop;\n\n      var newState = {\n        scrollPositionChangeReason: SCROLL_POSITION_CHANGE_REASONS.REQUESTED\n      };\n\n      if (scrollLeft >= 0) {\n        newState.scrollLeft = scrollLeft;\n      }\n\n      if (scrollTop >= 0) {\n        newState.scrollTop = scrollTop;\n      }\n\n      if (scrollLeft >= 0 && scrollLeft !== this.state.scrollLeft || scrollTop >= 0 && scrollTop !== this.state.scrollTop) {\n        this.setState(newState);\n      }\n    }\n  }, {\n    key: '_wrapCellClassNameGetter',\n    value: function _wrapCellClassNameGetter(className) {\n      return this._wrapPropertyGetter(className);\n    }\n  }, {\n    key: '_wrapCellStyleGetter',\n    value: function _wrapCellStyleGetter(style) {\n      return this._wrapPropertyGetter(style);\n    }\n  }, {\n    key: '_wrapPropertyGetter',\n    value: function _wrapPropertyGetter(value) {\n      return value instanceof Function ? value : function () {\n        return value;\n      };\n    }\n  }, {\n    key: '_wrapSizeGetter',\n    value: function _wrapSizeGetter(size) {\n      return this._wrapPropertyGetter(size);\n    }\n  }, {\n    key: '_updateScrollLeftForScrollToColumn',\n    value: function _updateScrollLeftForScrollToColumn() {\n      var props = arguments.length <= 0 || arguments[0] === undefined ? this.props : arguments[0];\n      var state = arguments.length <= 1 || arguments[1] === undefined ? this.state : arguments[1];\n      var columnCount = props.columnCount;\n      var scrollToAlignment = props.scrollToAlignment;\n      var scrollToColumn = props.scrollToColumn;\n      var width = props.width;\n      var scrollLeft = state.scrollLeft;\n\n\n      if (scrollToColumn >= 0 && columnCount > 0) {\n        var targetIndex = Math.max(0, Math.min(columnCount - 1, scrollToColumn));\n\n        var calculatedScrollLeft = this._columnSizeAndPositionManager.getUpdatedOffsetForIndex({\n          align: scrollToAlignment,\n          containerSize: width,\n          currentOffset: scrollLeft,\n          targetIndex: targetIndex\n        });\n\n        if (scrollLeft !== calculatedScrollLeft) {\n          this._setScrollPosition({\n            scrollLeft: calculatedScrollLeft\n          });\n        }\n      }\n    }\n  }, {\n    key: '_updateScrollTopForScrollToRow',\n    value: function _updateScrollTopForScrollToRow() {\n      var props = arguments.length <= 0 || arguments[0] === undefined ? this.props : arguments[0];\n      var state = arguments.length <= 1 || arguments[1] === undefined ? this.state : arguments[1];\n      var height = props.height;\n      var rowCount = props.rowCount;\n      var scrollToAlignment = props.scrollToAlignment;\n      var scrollToRow = props.scrollToRow;\n      var scrollTop = state.scrollTop;\n\n\n      if (scrollToRow >= 0 && rowCount > 0) {\n        var targetIndex = Math.max(0, Math.min(rowCount - 1, scrollToRow));\n\n        var calculatedScrollTop = this._rowSizeAndPositionManager.getUpdatedOffsetForIndex({\n          align: scrollToAlignment,\n          containerSize: height,\n          currentOffset: scrollTop,\n          targetIndex: targetIndex\n        });\n\n        if (scrollTop !== calculatedScrollTop) {\n          this._setScrollPosition({\n            scrollTop: calculatedScrollTop\n          });\n        }\n      }\n    }\n  }, {\n    key: '_onScroll',\n    value: function _onScroll(event) {\n      // In certain edge-cases React dispatches an onScroll event with an invalid target.scrollLeft / target.scrollTop.\n      // This invalid event can be detected by comparing event.target to this component's scrollable DOM element.\n      // See issue #404 for more information.\n      if (event.target !== this._scrollingContainer) {\n        return;\n      }\n\n      // Prevent pointer events from interrupting a smooth scroll\n      this._enablePointerEventsAfterDelay();\n\n      // When this component is shrunk drastically, React dispatches a series of back-to-back scroll events,\n      // Gradually converging on a scrollTop that is within the bounds of the new, smaller height.\n      // This causes a series of rapid renders that is slow for long lists.\n      // We can avoid that by doing some simple bounds checking to ensure that scrollTop never exceeds the total height.\n      var _props6 = this.props;\n      var height = _props6.height;\n      var width = _props6.width;\n\n      var scrollbarSize = this._scrollbarSize;\n      var totalRowsHeight = this._rowSizeAndPositionManager.getTotalSize();\n      var totalColumnsWidth = this._columnSizeAndPositionManager.getTotalSize();\n      var scrollLeft = Math.min(Math.max(0, totalColumnsWidth - width + scrollbarSize), event.target.scrollLeft);\n      var scrollTop = Math.min(Math.max(0, totalRowsHeight - height + scrollbarSize), event.target.scrollTop);\n\n      // Certain devices (like Apple touchpad) rapid-fire duplicate events.\n      // Don't force a re-render if this is the case.\n      // The mouse may move faster then the animation frame does.\n      // Use requestAnimationFrame to avoid over-updating.\n      if (this.state.scrollLeft !== scrollLeft || this.state.scrollTop !== scrollTop) {\n        // Browsers with cancelable scroll events (eg. Firefox) interrupt scrolling animations if scrollTop/scrollLeft is set.\n        // Other browsers (eg. Safari) don't scroll as well without the help under certain conditions (DOM or style changes during scrolling).\n        // All things considered, this seems to be the best current work around that I'm aware of.\n        // For more information see https://github.com/bvaughn/react-virtualized/pull/124\n        var scrollPositionChangeReason = event.cancelable ? SCROLL_POSITION_CHANGE_REASONS.OBSERVED : SCROLL_POSITION_CHANGE_REASONS.REQUESTED;\n\n        // Track scrolling direction so we can more efficiently overscan rows to reduce empty space around the edges while scrolling.\n        var scrollDirectionVertical = scrollTop > this.state.scrollTop ? _getOverscanIndices.SCROLL_DIRECTION_FORWARD : _getOverscanIndices.SCROLL_DIRECTION_BACKWARD;\n        var scrollDirectionHorizontal = scrollLeft > this.state.scrollLeft ? _getOverscanIndices.SCROLL_DIRECTION_FORWARD : _getOverscanIndices.SCROLL_DIRECTION_BACKWARD;\n\n        if (!this.state.isScrolling) {\n          this.setState({\n            isScrolling: true\n          });\n        }\n\n        this._setNextState({\n          isScrolling: true,\n          scrollDirectionHorizontal: scrollDirectionHorizontal,\n          scrollDirectionVertical: scrollDirectionVertical,\n          scrollLeft: scrollLeft,\n          scrollPositionChangeReason: scrollPositionChangeReason,\n          scrollTop: scrollTop\n        });\n      }\n\n      this._invokeOnScrollMemoizer({ scrollLeft: scrollLeft, scrollTop: scrollTop, totalColumnsWidth: totalColumnsWidth, totalRowsHeight: totalRowsHeight });\n    }\n  }]);\n\n  return Grid;\n}(_react.Component);\n\nGrid.propTypes = {\n  'aria-label': _react.PropTypes.string,\n\n  /**\n   * Set the width of the inner scrollable container to 'auto'.\n   * This is useful for single-column Grids to ensure that the column doesn't extend below a vertical scrollbar.\n   */\n  autoContainerWidth: _react.PropTypes.bool,\n\n  /**\n   * Removes fixed height from the scrollingContainer so that the total height\n   * of rows can stretch the window. Intended for use with WindowScroller\n   */\n  autoHeight: _react.PropTypes.bool,\n\n  /** Optional custom CSS class for individual cells */\n  cellClassName: _react.PropTypes.oneOfType([_react.PropTypes.string, _react.PropTypes.func]),\n\n  /** Optional custom styles for individual cells */\n  cellStyle: _react.PropTypes.oneOfType([_react.PropTypes.object, _react.PropTypes.func]),\n\n  /**\n   * Responsible for rendering a cell given an row and column index.\n   * Should implement the following interface: ({ columnIndex: number, rowIndex: number }): PropTypes.node\n   */\n  cellRenderer: _react.PropTypes.func.isRequired,\n\n  /**\n   * Responsible for rendering a group of cells given their index ranges.\n   * Should implement the following interface: ({\n   *   cellCache: Map,\n   *   cellRenderer: Function,\n   *   columnSizeAndPositionManager: CellSizeAndPositionManager,\n   *   columnStartIndex: number,\n   *   columnStopIndex: number,\n   *   isScrolling: boolean,\n   *   rowSizeAndPositionManager: CellSizeAndPositionManager,\n   *   rowStartIndex: number,\n   *   rowStopIndex: number,\n   *   scrollLeft: number,\n   *   scrollTop: number\n   * }): Array<PropTypes.node>\n   */\n  cellRangeRenderer: _react.PropTypes.func.isRequired,\n\n  /**\n   * Optional custom CSS class name to attach to root Grid element.\n   */\n  className: _react.PropTypes.string,\n\n  /**\n   * Number of columns in grid.\n   */\n  columnCount: _react.PropTypes.number.isRequired,\n\n  /**\n   * Either a fixed column width (number) or a function that returns the width of a column given its index.\n   * Should implement the following interface: (index: number): number\n   */\n  columnWidth: _react.PropTypes.oneOfType([_react.PropTypes.number, _react.PropTypes.func]).isRequired,\n\n  /**\n   * Used to estimate the total width of a Grid before all of its columns have actually been measured.\n   * The estimated total width is adjusted as columns are rendered.\n   */\n  estimatedColumnSize: _react.PropTypes.number.isRequired,\n\n  /**\n   * Used to estimate the total height of a Grid before all of its rows have actually been measured.\n   * The estimated total height is adjusted as rows are rendered.\n   */\n  estimatedRowSize: _react.PropTypes.number.isRequired,\n\n  /**\n   * Height of Grid; this property determines the number of visible (vs virtualized) rows.\n   */\n  height: _react.PropTypes.number.isRequired,\n\n  /**\n   * Optional renderer to be used in place of rows when either :rowCount or :columnCount is 0.\n   */\n  noContentRenderer: _react.PropTypes.func.isRequired,\n\n  /**\n   * Callback invoked whenever the scroll offset changes within the inner scrollable region.\n   * This callback can be used to sync scrolling between lists, tables, or grids.\n   * ({ clientHeight, clientWidth, scrollHeight, scrollLeft, scrollTop, scrollWidth }): void\n   */\n  onScroll: _react.PropTypes.func.isRequired,\n\n  /**\n   * Callback invoked with information about the section of the Grid that was just rendered.\n   * ({ columnStartIndex, columnStopIndex, rowStartIndex, rowStopIndex }): void\n   */\n  onSectionRendered: _react.PropTypes.func.isRequired,\n\n  /**\n   * Number of columns to render before/after the visible section of the grid.\n   * These columns can help for smoother scrolling on touch devices or browsers that send scroll events infrequently.\n   */\n  overscanColumnCount: _react.PropTypes.number.isRequired,\n\n  /**\n   * Number of rows to render above/below the visible section of the grid.\n   * These rows can help for smoother scrolling on touch devices or browsers that send scroll events infrequently.\n   */\n  overscanRowCount: _react.PropTypes.number.isRequired,\n\n  /**\n   * Either a fixed row height (number) or a function that returns the height of a row given its index.\n   * Should implement the following interface: ({ index: number }): number\n   */\n  rowHeight: _react.PropTypes.oneOfType([_react.PropTypes.number, _react.PropTypes.func]).isRequired,\n\n  /**\n   * Number of rows in grid.\n   */\n  rowCount: _react.PropTypes.number.isRequired,\n\n  /** Wait this amount of time after the last scroll event before resetting Grid `pointer-events`. */\n  scrollingResetTimeInterval: _react.PropTypes.number,\n\n  /** Horizontal offset. */\n  scrollLeft: _react.PropTypes.number,\n\n  /**\n   * Controls scroll-to-cell behavior of the Grid.\n   * The default (\"auto\") scrolls the least amount possible to ensure that the specified cell is fully visible.\n   * Use \"start\" to align cells to the top/left of the Grid and \"end\" to align bottom/right.\n   */\n  scrollToAlignment: _react.PropTypes.oneOf(['auto', 'end', 'start', 'center']).isRequired,\n\n  /**\n   * Column index to ensure visible (by forcefully scrolling if necessary)\n   */\n  scrollToColumn: _react.PropTypes.number,\n\n  /** Vertical offset. */\n  scrollTop: _react.PropTypes.number,\n\n  /**\n   * Row index to ensure visible (by forcefully scrolling if necessary)\n   */\n  scrollToRow: _react.PropTypes.number,\n\n  /** Optional inline style */\n  style: _react.PropTypes.object,\n\n  /** Tab index for focus */\n  tabIndex: _react.PropTypes.number,\n\n  /**\n   * Width of Grid; this property determines the number of visible (vs virtualized) columns.\n   */\n  width: _react.PropTypes.number.isRequired\n};\nGrid.defaultProps = {\n  'aria-label': 'grid',\n  cellStyle: {},\n  cellRangeRenderer: _defaultCellRangeRenderer2.default,\n  estimatedColumnSize: 100,\n  estimatedRowSize: 30,\n  noContentRenderer: function noContentRenderer() {\n    return null;\n  },\n  onScroll: function onScroll() {\n    return null;\n  },\n  onSectionRendered: function onSectionRendered() {\n    return null;\n  },\n  overscanColumnCount: 0,\n  overscanRowCount: 10,\n  scrollingResetTimeInterval: DEFAULT_SCROLLING_RESET_TIME_INTERVAL,\n  scrollToAlignment: 'auto',\n  style: {},\n  tabIndex: 0\n};\nexports.default = Grid;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nexports.default = defaultCellRangeRenderer;\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _classnames = require('classnames');\n\nvar _classnames2 = _interopRequireDefault(_classnames);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * Default implementation of cellRangeRenderer used by Grid.\n * This renderer supports cell-caching while the user is scrolling.\n */\nfunction defaultCellRangeRenderer(_ref) {\n  var cellCache = _ref.cellCache;\n  var cellClassName = _ref.cellClassName;\n  var cellRenderer = _ref.cellRenderer;\n  var cellStyle = _ref.cellStyle;\n  var columnSizeAndPositionManager = _ref.columnSizeAndPositionManager;\n  var columnStartIndex = _ref.columnStartIndex;\n  var columnStopIndex = _ref.columnStopIndex;\n  var horizontalOffsetAdjustment = _ref.horizontalOffsetAdjustment;\n  var isScrolling = _ref.isScrolling;\n  var rowSizeAndPositionManager = _ref.rowSizeAndPositionManager;\n  var rowStartIndex = _ref.rowStartIndex;\n  var rowStopIndex = _ref.rowStopIndex;\n  var scrollLeft = _ref.scrollLeft;\n  var scrollTop = _ref.scrollTop;\n  var verticalOffsetAdjustment = _ref.verticalOffsetAdjustment;\n\n  var renderedCells = [];\n\n  for (var rowIndex = rowStartIndex; rowIndex <= rowStopIndex; rowIndex++) {\n    var rowDatum = rowSizeAndPositionManager.getSizeAndPositionOfCell(rowIndex);\n\n    for (var columnIndex = columnStartIndex; columnIndex <= columnStopIndex; columnIndex++) {\n      var columnDatum = columnSizeAndPositionManager.getSizeAndPositionOfCell(columnIndex);\n      var key = rowIndex + '-' + columnIndex;\n      var cellStyleObject = cellStyle({ rowIndex: rowIndex, columnIndex: columnIndex });\n      var renderedCell = void 0;\n\n      // Avoid re-creating cells while scrolling.\n      // This can lead to the same cell being created many times and can cause performance issues for \"heavy\" cells.\n      // If a scroll is in progress- cache and reuse cells.\n      // This cache will be thrown away once scrolling complets.\n      if (isScrolling) {\n        if (!cellCache[key]) {\n          cellCache[key] = cellRenderer({\n            columnIndex: columnIndex,\n            isScrolling: isScrolling,\n            rowIndex: rowIndex\n          });\n        }\n        renderedCell = cellCache[key];\n        // If the user is no longer scrolling, don't cache cells.\n        // This makes dynamic cell content difficult for users and would also lead to a heavier memory footprint.\n      } else {\n        renderedCell = cellRenderer({\n          columnIndex: columnIndex,\n          isScrolling: isScrolling,\n          rowIndex: rowIndex\n        });\n      }\n\n      if (renderedCell == null || renderedCell === false) {\n        continue;\n      }\n\n      var className = cellClassName({ columnIndex: columnIndex, rowIndex: rowIndex });\n\n      var child = _react2.default.createElement(\n        'div',\n        {\n          key: key,\n          className: (0, _classnames2.default)('Grid__cell', className),\n          style: _extends({\n            height: rowDatum.size,\n            left: columnDatum.offset + horizontalOffsetAdjustment,\n            top: rowDatum.offset + verticalOffsetAdjustment,\n            width: columnDatum.size\n          }, cellStyleObject)\n        },\n        renderedCell\n      );\n\n      renderedCells.push(child);\n    }\n  }\n\n  return renderedCells;\n}","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.defaultCellRangeRenderer = exports.Grid = exports.default = undefined;\n\nvar _Grid2 = require('./Grid');\n\nvar _Grid3 = _interopRequireDefault(_Grid2);\n\nvar _defaultCellRangeRenderer2 = require('./defaultCellRangeRenderer');\n\nvar _defaultCellRangeRenderer3 = _interopRequireDefault(_defaultCellRangeRenderer2);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = _Grid3.default;\nexports.Grid = _Grid3.default;\nexports.defaultCellRangeRenderer = _defaultCellRangeRenderer3.default;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * Just-in-time calculates and caches size and position information for a collection of cells.\n */\nvar CellSizeAndPositionManager = function () {\n  function CellSizeAndPositionManager(_ref) {\n    var cellCount = _ref.cellCount;\n    var cellSizeGetter = _ref.cellSizeGetter;\n    var estimatedCellSize = _ref.estimatedCellSize;\n\n    _classCallCheck(this, CellSizeAndPositionManager);\n\n    this._cellSizeGetter = cellSizeGetter;\n    this._cellCount = cellCount;\n    this._estimatedCellSize = estimatedCellSize;\n\n    // Cache of size and position data for cells, mapped by cell index.\n    // Note that invalid values may exist in this map so only rely on cells up to this._lastMeasuredIndex\n    this._cellSizeAndPositionData = {};\n\n    // Measurements for cells up to this index can be trusted; cells afterward should be estimated.\n    this._lastMeasuredIndex = -1;\n  }\n\n  _createClass(CellSizeAndPositionManager, [{\n    key: 'configure',\n    value: function configure(_ref2) {\n      var cellCount = _ref2.cellCount;\n      var estimatedCellSize = _ref2.estimatedCellSize;\n\n      this._cellCount = cellCount;\n      this._estimatedCellSize = estimatedCellSize;\n    }\n  }, {\n    key: 'getCellCount',\n    value: function getCellCount() {\n      return this._cellCount;\n    }\n  }, {\n    key: 'getEstimatedCellSize',\n    value: function getEstimatedCellSize() {\n      return this._estimatedCellSize;\n    }\n  }, {\n    key: 'getLastMeasuredIndex',\n    value: function getLastMeasuredIndex() {\n      return this._lastMeasuredIndex;\n    }\n\n    /**\n     * This method returns the size and position for the cell at the specified index.\n     * It just-in-time calculates (or used cached values) for cells leading up to the index.\n     */\n\n  }, {\n    key: 'getSizeAndPositionOfCell',\n    value: function getSizeAndPositionOfCell(index) {\n      if (index < 0 || index >= this._cellCount) {\n        throw Error('Requested index ' + index + ' is outside of range 0..' + this._cellCount);\n      }\n\n      if (index > this._lastMeasuredIndex) {\n        var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();\n        var _offset = lastMeasuredCellSizeAndPosition.offset + lastMeasuredCellSizeAndPosition.size;\n\n        for (var i = this._lastMeasuredIndex + 1; i <= index; i++) {\n          var _size = this._cellSizeGetter({ index: i });\n\n          if (_size == null || isNaN(_size)) {\n            throw Error('Invalid size returned for cell ' + i + ' of value ' + _size);\n          }\n\n          this._cellSizeAndPositionData[i] = {\n            offset: _offset,\n            size: _size\n          };\n\n          _offset += _size;\n        }\n\n        this._lastMeasuredIndex = index;\n      }\n\n      return this._cellSizeAndPositionData[index];\n    }\n  }, {\n    key: 'getSizeAndPositionOfLastMeasuredCell',\n    value: function getSizeAndPositionOfLastMeasuredCell() {\n      return this._lastMeasuredIndex >= 0 ? this._cellSizeAndPositionData[this._lastMeasuredIndex] : {\n        offset: 0,\n        size: 0\n      };\n    }\n\n    /**\n     * Total size of all cells being measured.\n     * This value will be completedly estimated initially.\n     * As cells as measured the estimate will be updated.\n     */\n\n  }, {\n    key: 'getTotalSize',\n    value: function getTotalSize() {\n      var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();\n\n      return lastMeasuredCellSizeAndPosition.offset + lastMeasuredCellSizeAndPosition.size + (this._cellCount - this._lastMeasuredIndex - 1) * this._estimatedCellSize;\n    }\n\n    /**\n     * Determines a new offset that ensures a certain cell is visible, given the current offset.\n     * If the cell is already visible then the current offset will be returned.\n     * If the current offset is too great or small, it will be adjusted just enough to ensure the specified index is visible.\n     *\n     * @param align Desired alignment within container; one of \"auto\" (default), \"start\", or \"end\"\n     * @param containerSize Size (width or height) of the container viewport\n     * @param currentOffset Container's current (x or y) offset\n     * @param totalSize Total size (width or height) of all cells\n     * @return Offset to use to ensure the specified cell is visible\n     */\n\n  }, {\n    key: 'getUpdatedOffsetForIndex',\n    value: function getUpdatedOffsetForIndex(_ref3) {\n      var _ref3$align = _ref3.align;\n      var align = _ref3$align === undefined ? 'auto' : _ref3$align;\n      var containerSize = _ref3.containerSize;\n      var currentOffset = _ref3.currentOffset;\n      var targetIndex = _ref3.targetIndex;\n\n      var datum = this.getSizeAndPositionOfCell(targetIndex);\n      var maxOffset = datum.offset;\n      var minOffset = maxOffset - containerSize + datum.size;\n\n      var idealOffset = void 0;\n\n      switch (align) {\n        case 'start':\n          idealOffset = maxOffset;\n          break;\n        case 'end':\n          idealOffset = minOffset;\n          break;\n        case 'center':\n          idealOffset = maxOffset - (containerSize - datum.size) / 2;\n          break;\n        default:\n          idealOffset = Math.max(minOffset, Math.min(maxOffset, currentOffset));\n          break;\n      }\n\n      var totalSize = this.getTotalSize();\n\n      return Math.max(0, Math.min(totalSize - containerSize, idealOffset));\n    }\n  }, {\n    key: 'getVisibleCellRange',\n    value: function getVisibleCellRange(_ref4) {\n      var containerSize = _ref4.containerSize;\n      var offset = _ref4.offset;\n\n      var totalSize = this.getTotalSize();\n\n      if (totalSize === 0) {\n        return {};\n      }\n\n      var maxOffset = offset + containerSize;\n      var start = this._findNearestCell(offset);\n\n      var datum = this.getSizeAndPositionOfCell(start);\n      offset = datum.offset + datum.size;\n\n      var stop = start;\n\n      while (offset < maxOffset && stop < this._cellCount - 1) {\n        stop++;\n\n        offset += this.getSizeAndPositionOfCell(stop).size;\n      }\n\n      return {\n        start: start,\n        stop: stop\n      };\n    }\n\n    /**\n     * Clear all cached values for cells after the specified index.\n     * This method should be called for any cell that has changed its size.\n     * It will not immediately perform any calculations; they'll be performed the next time getSizeAndPositionOfCell() is called.\n     */\n\n  }, {\n    key: 'resetCell',\n    value: function resetCell(index) {\n      this._lastMeasuredIndex = Math.min(this._lastMeasuredIndex, index - 1);\n    }\n  }, {\n    key: '_binarySearch',\n    value: function _binarySearch(_ref5) {\n      var high = _ref5.high;\n      var low = _ref5.low;\n      var offset = _ref5.offset;\n\n      var middle = void 0;\n      var currentOffset = void 0;\n\n      while (low <= high) {\n        middle = low + Math.floor((high - low) / 2);\n        currentOffset = this.getSizeAndPositionOfCell(middle).offset;\n\n        if (currentOffset === offset) {\n          return middle;\n        } else if (currentOffset < offset) {\n          low = middle + 1;\n        } else if (currentOffset > offset) {\n          high = middle - 1;\n        }\n      }\n\n      if (low > 0) {\n        return low - 1;\n      }\n    }\n  }, {\n    key: '_exponentialSearch',\n    value: function _exponentialSearch(_ref6) {\n      var index = _ref6.index;\n      var offset = _ref6.offset;\n\n      var interval = 1;\n\n      while (index < this._cellCount && this.getSizeAndPositionOfCell(index).offset < offset) {\n        index += interval;\n        interval *= 2;\n      }\n\n      return this._binarySearch({\n        high: Math.min(index, this._cellCount - 1),\n        low: Math.floor(index / 2),\n        offset: offset\n      });\n    }\n\n    /**\n     * Searches for the cell (index) nearest the specified offset.\n     *\n     * If no exact match is found the next lowest cell index will be returned.\n     * This allows partially visible cells (with offsets just before/above the fold) to be visible.\n     */\n\n  }, {\n    key: '_findNearestCell',\n    value: function _findNearestCell(offset) {\n      if (isNaN(offset)) {\n        throw Error('Invalid offset ' + offset + ' specified');\n      }\n\n      // Our search algorithms find the nearest match at or below the specified offset.\n      // So make sure the offset is at least 0 or no match will be found.\n      offset = Math.max(0, offset);\n\n      var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();\n      var lastMeasuredIndex = Math.max(0, this._lastMeasuredIndex);\n\n      if (lastMeasuredCellSizeAndPosition.offset >= offset) {\n        // If we've already measured cells within this range just use a binary search as it's faster.\n        return this._binarySearch({\n          high: lastMeasuredIndex,\n          low: 0,\n          offset: offset\n        });\n      } else {\n        // If we haven't yet measured this high, fallback to an exponential search with an inner binary search.\n        // The exponential search avoids pre-computing sizes for the full set of cells as a binary search would.\n        // The overall complexity for this approach is O(log n).\n        return this._exponentialSearch({\n          index: lastMeasuredIndex,\n          offset: offset\n        });\n      }\n    }\n  }]);\n\n  return CellSizeAndPositionManager;\n}();\n\nexports.default = CellSizeAndPositionManager;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.DEFAULT_MAX_SCROLL_SIZE = undefined;\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _CellSizeAndPositionManager = require('./CellSizeAndPositionManager');\n\nvar _CellSizeAndPositionManager2 = _interopRequireDefault(_CellSizeAndPositionManager);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * Browsers have scroll offset limitations (eg Chrome stops scrolling at ~33.5M pixels where as Edge tops out at ~1.5M pixels).\n * After a certain position, the browser won't allow the user to scroll further (even via JavaScript scroll offset adjustments).\n * This util picks a lower ceiling for max size and artificially adjusts positions within to make it transparent for users.\n */\nvar DEFAULT_MAX_SCROLL_SIZE = exports.DEFAULT_MAX_SCROLL_SIZE = 1500000;\n\n/**\n * Extends CellSizeAndPositionManager and adds scaling behavior for lists that are too large to fit within a browser's native limits.\n */\n\nvar ScalingCellSizeAndPositionManager = function () {\n  function ScalingCellSizeAndPositionManager(_ref) {\n    var _ref$maxScrollSize = _ref.maxScrollSize;\n    var maxScrollSize = _ref$maxScrollSize === undefined ? DEFAULT_MAX_SCROLL_SIZE : _ref$maxScrollSize;\n\n    var params = _objectWithoutProperties(_ref, ['maxScrollSize']);\n\n    _classCallCheck(this, ScalingCellSizeAndPositionManager);\n\n    // Favor composition over inheritance to simplify IE10 support\n    this._cellSizeAndPositionManager = new _CellSizeAndPositionManager2.default(params);\n    this._maxScrollSize = maxScrollSize;\n  }\n\n  _createClass(ScalingCellSizeAndPositionManager, [{\n    key: 'configure',\n    value: function configure(params) {\n      this._cellSizeAndPositionManager.configure(params);\n    }\n  }, {\n    key: 'getCellCount',\n    value: function getCellCount() {\n      return this._cellSizeAndPositionManager.getCellCount();\n    }\n  }, {\n    key: 'getEstimatedCellSize',\n    value: function getEstimatedCellSize() {\n      return this._cellSizeAndPositionManager.getEstimatedCellSize();\n    }\n  }, {\n    key: 'getLastMeasuredIndex',\n    value: function getLastMeasuredIndex() {\n      return this._cellSizeAndPositionManager.getLastMeasuredIndex();\n    }\n\n    /**\n     * Number of pixels a cell at the given position (offset) should be shifted in order to fit within the scaled container.\n     * The offset passed to this function is scalled (safe) as well.\n     */\n\n  }, {\n    key: 'getOffsetAdjustment',\n    value: function getOffsetAdjustment(_ref2) {\n      var containerSize = _ref2.containerSize;\n      var offset = _ref2.offset;\n\n      var totalSize = this._cellSizeAndPositionManager.getTotalSize();\n      var safeTotalSize = this.getTotalSize();\n      var offsetPercentage = this._getOffsetPercentage({\n        containerSize: containerSize,\n        offset: offset,\n        totalSize: safeTotalSize\n      });\n\n      return Math.round(offsetPercentage * (safeTotalSize - totalSize));\n    }\n  }, {\n    key: 'getSizeAndPositionOfCell',\n    value: function getSizeAndPositionOfCell(index) {\n      return this._cellSizeAndPositionManager.getSizeAndPositionOfCell(index);\n    }\n  }, {\n    key: 'getSizeAndPositionOfLastMeasuredCell',\n    value: function getSizeAndPositionOfLastMeasuredCell() {\n      return this._cellSizeAndPositionManager.getSizeAndPositionOfLastMeasuredCell();\n    }\n\n    /** See CellSizeAndPositionManager#getTotalSize */\n\n  }, {\n    key: 'getTotalSize',\n    value: function getTotalSize() {\n      return Math.min(this._maxScrollSize, this._cellSizeAndPositionManager.getTotalSize());\n    }\n\n    /** See CellSizeAndPositionManager#getUpdatedOffsetForIndex */\n\n  }, {\n    key: 'getUpdatedOffsetForIndex',\n    value: function getUpdatedOffsetForIndex(_ref3) {\n      var _ref3$align = _ref3.align;\n      var align = _ref3$align === undefined ? 'auto' : _ref3$align;\n      var containerSize = _ref3.containerSize;\n      var currentOffset = _ref3.currentOffset;\n      var targetIndex = _ref3.targetIndex;\n      var totalSize = _ref3.totalSize;\n\n      currentOffset = this._safeOffsetToOffset({\n        containerSize: containerSize,\n        offset: currentOffset\n      });\n\n      var offset = this._cellSizeAndPositionManager.getUpdatedOffsetForIndex({\n        align: align,\n        containerSize: containerSize,\n        currentOffset: currentOffset,\n        targetIndex: targetIndex,\n        totalSize: totalSize\n      });\n\n      return this._offsetToSafeOffset({\n        containerSize: containerSize,\n        offset: offset\n      });\n    }\n\n    /** See CellSizeAndPositionManager#getVisibleCellRange */\n\n  }, {\n    key: 'getVisibleCellRange',\n    value: function getVisibleCellRange(_ref4) {\n      var containerSize = _ref4.containerSize;\n      var offset = _ref4.offset;\n\n      offset = this._safeOffsetToOffset({\n        containerSize: containerSize,\n        offset: offset\n      });\n\n      return this._cellSizeAndPositionManager.getVisibleCellRange({\n        containerSize: containerSize,\n        offset: offset\n      });\n    }\n  }, {\n    key: 'resetCell',\n    value: function resetCell(index) {\n      this._cellSizeAndPositionManager.resetCell(index);\n    }\n  }, {\n    key: '_getOffsetPercentage',\n    value: function _getOffsetPercentage(_ref5) {\n      var containerSize = _ref5.containerSize;\n      var offset = _ref5.offset;\n      var totalSize = _ref5.totalSize;\n\n      return totalSize <= containerSize ? 0 : offset / (totalSize - containerSize);\n    }\n  }, {\n    key: '_offsetToSafeOffset',\n    value: function _offsetToSafeOffset(_ref6) {\n      var containerSize = _ref6.containerSize;\n      var offset = _ref6.offset;\n\n      var totalSize = this._cellSizeAndPositionManager.getTotalSize();\n      var safeTotalSize = this.getTotalSize();\n\n      if (totalSize === safeTotalSize) {\n        return offset;\n      } else {\n        var offsetPercentage = this._getOffsetPercentage({\n          containerSize: containerSize,\n          offset: offset,\n          totalSize: totalSize\n        });\n\n        return Math.round(offsetPercentage * (safeTotalSize - containerSize));\n      }\n    }\n  }, {\n    key: '_safeOffsetToOffset',\n    value: function _safeOffsetToOffset(_ref7) {\n      var containerSize = _ref7.containerSize;\n      var offset = _ref7.offset;\n\n      var totalSize = this._cellSizeAndPositionManager.getTotalSize();\n      var safeTotalSize = this.getTotalSize();\n\n      if (totalSize === safeTotalSize) {\n        return offset;\n      } else {\n        var offsetPercentage = this._getOffsetPercentage({\n          containerSize: containerSize,\n          offset: offset,\n          totalSize: safeTotalSize\n        });\n\n        return Math.round(offsetPercentage * (totalSize - containerSize));\n      }\n    }\n  }]);\n\n  return ScalingCellSizeAndPositionManager;\n}();\n\nexports.default = ScalingCellSizeAndPositionManager;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = calculateSizeAndPositionDataAndUpdateScrollOffset;\n/**\n * Helper method that determines when to recalculate row or column metadata.\n *\n * @param cellCount Number of rows or columns in the current axis\n * @param cellsSize Width or height of cells for the current axis\n * @param computeMetadataCallback Method to invoke if cell metadata should be recalculated\n * @param computeMetadataCallbackProps Parameters to pass to :computeMetadataCallback\n * @param nextCellsCount Newly updated number of rows or columns in the current axis\n * @param nextCellsSize Newly updated width or height of cells for the current axis\n * @param nextScrollToIndex Newly updated scroll-to-index\n * @param scrollToIndex Scroll-to-index\n * @param updateScrollOffsetForScrollToIndex Callback to invoke if the scroll position should be recalculated\n */\nfunction calculateSizeAndPositionDataAndUpdateScrollOffset(_ref) {\n  var cellCount = _ref.cellCount;\n  var cellSize = _ref.cellSize;\n  var computeMetadataCallback = _ref.computeMetadataCallback;\n  var computeMetadataCallbackProps = _ref.computeMetadataCallbackProps;\n  var nextCellsCount = _ref.nextCellsCount;\n  var nextCellSize = _ref.nextCellSize;\n  var nextScrollToIndex = _ref.nextScrollToIndex;\n  var scrollToIndex = _ref.scrollToIndex;\n  var updateScrollOffsetForScrollToIndex = _ref.updateScrollOffsetForScrollToIndex;\n\n  // Don't compare cell sizes if they are functions because inline functions would cause infinite loops.\n  // In that event users should use the manual recompute methods to inform of changes.\n  if (cellCount !== nextCellsCount || (typeof cellSize === 'number' || typeof nextCellSize === 'number') && cellSize !== nextCellSize) {\n    computeMetadataCallback(computeMetadataCallbackProps);\n\n    // Updated cell metadata may have hidden the previous scrolled-to item.\n    // In this case we should also update the scrollTop to ensure it stays visible.\n    if (scrollToIndex >= 0 && scrollToIndex === nextScrollToIndex) {\n      updateScrollOffsetForScrollToIndex();\n    }\n  }\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = getOverscanIndices;\nvar SCROLL_DIRECTION_BACKWARD = exports.SCROLL_DIRECTION_BACKWARD = -1;\nvar SCROLL_DIRECTION_FIXED = exports.SCROLL_DIRECTION_FIXED = 0;\nvar SCROLL_DIRECTION_FORWARD = exports.SCROLL_DIRECTION_FORWARD = 1;\n\n/**\n * Calculates the number of cells to overscan before and after a specified range.\n * This function ensures that overscanning doesn't exceed the available cells.\n *\n * @param cellCount Number of rows or columns in the current axis\n * @param scrollDirection One of SCROLL_DIRECTION_BACKWARD\n * @param overscanCellsCount Maximum number of cells to over-render in either direction\n * @param startIndex Begin of range of visible cells\n * @param stopIndex End of range of visible cells\n */\nfunction getOverscanIndices(_ref) {\n  var cellCount = _ref.cellCount;\n  var overscanCellsCount = _ref.overscanCellsCount;\n  var scrollDirection = _ref.scrollDirection;\n  var startIndex = _ref.startIndex;\n  var stopIndex = _ref.stopIndex;\n\n  var overscanStartIndex = void 0;\n  var overscanStopIndex = void 0;\n\n  if (scrollDirection === SCROLL_DIRECTION_FORWARD) {\n    overscanStartIndex = startIndex;\n    overscanStopIndex = stopIndex + overscanCellsCount * 2;\n  } else if (scrollDirection === SCROLL_DIRECTION_BACKWARD) {\n    overscanStartIndex = startIndex - overscanCellsCount * 2;\n    overscanStopIndex = stopIndex;\n  } else {\n    overscanStartIndex = startIndex - overscanCellsCount;\n    overscanStopIndex = stopIndex + overscanCellsCount;\n  }\n\n  return {\n    overscanStartIndex: Math.max(0, overscanStartIndex),\n    overscanStopIndex: Math.min(cellCount - 1, overscanStopIndex)\n  };\n}","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = updateScrollIndexHelper;\n/**\n * Helper function that determines when to update scroll offsets to ensure that a scroll-to-index remains visible.\n * This function also ensures that the scroll ofset isn't past the last column/row of cells.\n *\n * @param cellsSize Width or height of cells for the current axis\n * @param cellSizeAndPositionManager Manages size and position metadata of cells\n * @param previousCellsCount Previous number of rows or columns\n * @param previousCellsSize Previous width or height of cells\n * @param previousScrollToIndex Previous scroll-to-index\n * @param previousSize Previous width or height of the virtualized container\n * @param scrollOffset Current scrollLeft or scrollTop\n * @param scrollToIndex Scroll-to-index\n * @param size Width or height of the virtualized container\n * @param updateScrollIndexCallback Callback to invoke with an scroll-to-index value\n */\nfunction updateScrollIndexHelper(_ref) {\n  var cellSize = _ref.cellSize;\n  var cellSizeAndPositionManager = _ref.cellSizeAndPositionManager;\n  var previousCellsCount = _ref.previousCellsCount;\n  var previousCellSize = _ref.previousCellSize;\n  var previousScrollToAlignment = _ref.previousScrollToAlignment;\n  var previousScrollToIndex = _ref.previousScrollToIndex;\n  var previousSize = _ref.previousSize;\n  var scrollOffset = _ref.scrollOffset;\n  var scrollToAlignment = _ref.scrollToAlignment;\n  var scrollToIndex = _ref.scrollToIndex;\n  var size = _ref.size;\n  var updateScrollIndexCallback = _ref.updateScrollIndexCallback;\n\n  var cellCount = cellSizeAndPositionManager.getCellCount();\n  var hasScrollToIndex = scrollToIndex >= 0 && scrollToIndex < cellCount;\n  var sizeHasChanged = size !== previousSize || !previousCellSize || typeof cellSize === 'number' && cellSize !== previousCellSize;\n\n  // If we have a new scroll target OR if height/row-height has changed,\n  // We should ensure that the scroll target is visible.\n  if (hasScrollToIndex && (sizeHasChanged || scrollToAlignment !== previousScrollToAlignment || scrollToIndex !== previousScrollToIndex)) {\n    updateScrollIndexCallback(scrollToIndex);\n\n    // If we don't have a selected item but list size or number of children have decreased,\n    // Make sure we aren't scrolled too far past the current content.\n  } else if (!hasScrollToIndex && cellCount > 0 && (size < previousSize || cellCount < previousCellsCount)) {\n    // We need to ensure that the current scroll offset is still within the collection's range.\n    // To do this, we don't need to measure everything; CellMeasurer would perform poorly.\n    // Just check to make sure we're still okay.\n    // Only adjust the scroll position if we've scrolled below the last set of rows.\n    if (scrollOffset > cellSizeAndPositionManager.getTotalSize() - size) {\n      updateScrollIndexCallback(cellCount - 1);\n    }\n  }\n}","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nexports.isRangeVisible = isRangeVisible;\nexports.scanForUnloadedRanges = scanForUnloadedRanges;\nexports.forceUpdateReactVirtualizedComponent = forceUpdateReactVirtualizedComponent;\n\nvar _react = require('react');\n\nvar _reactAddonsShallowCompare = require('react-addons-shallow-compare');\n\nvar _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare);\n\nvar _createCallbackMemoizer = require('../utils/createCallbackMemoizer');\n\nvar _createCallbackMemoizer2 = _interopRequireDefault(_createCallbackMemoizer);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/**\n * Higher-order component that manages lazy-loading for \"infinite\" data.\n * This component decorates a virtual component and just-in-time prefetches rows as a user scrolls.\n * It is intended as a convenience component; fork it if you'd like finer-grained control over data-loading.\n */\nvar InfiniteLoader = function (_Component) {\n  _inherits(InfiniteLoader, _Component);\n\n  function InfiniteLoader(props, context) {\n    _classCallCheck(this, InfiniteLoader);\n\n    var _this = _possibleConstructorReturn(this, (InfiniteLoader.__proto__ || Object.getPrototypeOf(InfiniteLoader)).call(this, props, context));\n\n    _this._loadMoreRowsMemoizer = (0, _createCallbackMemoizer2.default)();\n\n    _this._onRowsRendered = _this._onRowsRendered.bind(_this);\n    _this._registerChild = _this._registerChild.bind(_this);\n    return _this;\n  }\n\n  _createClass(InfiniteLoader, [{\n    key: 'render',\n    value: function render() {\n      var children = this.props.children;\n\n\n      return children({\n        onRowsRendered: this._onRowsRendered,\n        registerChild: this._registerChild\n      });\n    }\n  }, {\n    key: 'shouldComponentUpdate',\n    value: function shouldComponentUpdate(nextProps, nextState) {\n      return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState);\n    }\n  }, {\n    key: '_loadUnloadedRanges',\n    value: function _loadUnloadedRanges(unloadedRanges) {\n      var _this2 = this;\n\n      var loadMoreRows = this.props.loadMoreRows;\n\n\n      unloadedRanges.forEach(function (unloadedRange) {\n        var promise = loadMoreRows(unloadedRange);\n        if (promise) {\n          promise.then(function () {\n            // Refresh the visible rows if any of them have just been loaded.\n            // Otherwise they will remain in their unloaded visual state.\n            if (isRangeVisible({\n              lastRenderedStartIndex: _this2._lastRenderedStartIndex,\n              lastRenderedStopIndex: _this2._lastRenderedStopIndex,\n              startIndex: unloadedRange.startIndex,\n              stopIndex: unloadedRange.stopIndex\n            })) {\n              if (_this2._registeredChild) {\n                forceUpdateReactVirtualizedComponent(_this2._registeredChild);\n              }\n            }\n          });\n        }\n      });\n    }\n  }, {\n    key: '_onRowsRendered',\n    value: function _onRowsRendered(_ref) {\n      var _this3 = this;\n\n      var startIndex = _ref.startIndex;\n      var stopIndex = _ref.stopIndex;\n      var _props = this.props;\n      var isRowLoaded = _props.isRowLoaded;\n      var minimumBatchSize = _props.minimumBatchSize;\n      var rowCount = _props.rowCount;\n      var threshold = _props.threshold;\n\n\n      this._lastRenderedStartIndex = startIndex;\n      this._lastRenderedStopIndex = stopIndex;\n\n      var unloadedRanges = scanForUnloadedRanges({\n        isRowLoaded: isRowLoaded,\n        minimumBatchSize: minimumBatchSize,\n        rowCount: rowCount,\n        startIndex: Math.max(0, startIndex - threshold),\n        stopIndex: Math.min(rowCount - 1, stopIndex + threshold)\n      });\n\n      // For memoize comparison\n      var squashedUnloadedRanges = unloadedRanges.reduce(function (reduced, unloadedRange) {\n        return reduced.concat([unloadedRange.startIndex, unloadedRange.stopIndex]);\n      }, []);\n\n      this._loadMoreRowsMemoizer({\n        callback: function callback() {\n          _this3._loadUnloadedRanges(unloadedRanges);\n        },\n        indices: { squashedUnloadedRanges: squashedUnloadedRanges }\n      });\n    }\n  }, {\n    key: '_registerChild',\n    value: function _registerChild(registeredChild) {\n      this._registeredChild = registeredChild;\n    }\n  }]);\n\n  return InfiniteLoader;\n}(_react.Component);\n\n/**\n * Determines if the specified start/stop range is visible based on the most recently rendered range.\n */\n\n\nInfiniteLoader.propTypes = {\n  /**\n   * Function respondible for rendering a virtualized component.\n   * This function should implement the following signature:\n   * ({ onRowsRendered, registerChild }) => PropTypes.element\n   *\n   * The specified :onRowsRendered function should be passed through to the child's :onRowsRendered property.\n   * The :registerChild callback should be set as the virtualized component's :ref.\n   */\n  children: _react.PropTypes.func.isRequired,\n\n  /**\n   * Function responsible for tracking the loaded state of each row.\n   * It should implement the following signature: ({ index: number }): boolean\n   */\n  isRowLoaded: _react.PropTypes.func.isRequired,\n\n  /**\n   * Callback to be invoked when more rows must be loaded.\n   * It should implement the following signature: ({ startIndex, stopIndex }): Promise\n   * The returned Promise should be resolved once row data has finished loading.\n   * It will be used to determine when to refresh the list with the newly-loaded data.\n   * This callback may be called multiple times in reaction to a single scroll event.\n   */\n  loadMoreRows: _react.PropTypes.func.isRequired,\n\n  /**\n   * Minimum number of rows to be loaded at a time.\n   * This property can be used to batch requests to reduce HTTP requests.\n   */\n  minimumBatchSize: _react.PropTypes.number.isRequired,\n\n  /**\n   * Number of rows in list; can be arbitrary high number if actual number is unknown.\n   */\n  rowCount: _react.PropTypes.number.isRequired,\n\n  /**\n   * Threshold at which to pre-fetch data.\n   * A threshold X means that data will start loading when a user scrolls within X rows.\n   * This value defaults to 15.\n   */\n  threshold: _react.PropTypes.number.isRequired\n};\nInfiniteLoader.defaultProps = {\n  minimumBatchSize: 10,\n  rowCount: 0,\n  threshold: 15\n};\nexports.default = InfiniteLoader;\nfunction isRangeVisible(_ref2) {\n  var lastRenderedStartIndex = _ref2.lastRenderedStartIndex;\n  var lastRenderedStopIndex = _ref2.lastRenderedStopIndex;\n  var startIndex = _ref2.startIndex;\n  var stopIndex = _ref2.stopIndex;\n\n  return !(startIndex > lastRenderedStopIndex || stopIndex < lastRenderedStartIndex);\n}\n\n/**\n * Returns all of the ranges within a larger range that contain unloaded rows.\n */\nfunction scanForUnloadedRanges(_ref3) {\n  var isRowLoaded = _ref3.isRowLoaded;\n  var minimumBatchSize = _ref3.minimumBatchSize;\n  var rowCount = _ref3.rowCount;\n  var startIndex = _ref3.startIndex;\n  var stopIndex = _ref3.stopIndex;\n\n  var unloadedRanges = [];\n\n  var rangeStartIndex = null;\n  var rangeStopIndex = null;\n\n  for (var index = startIndex; index <= stopIndex; index++) {\n    var loaded = isRowLoaded({ index: index });\n\n    if (!loaded) {\n      rangeStopIndex = index;\n      if (rangeStartIndex === null) {\n        rangeStartIndex = index;\n      }\n    } else if (rangeStopIndex !== null) {\n      unloadedRanges.push({\n        startIndex: rangeStartIndex,\n        stopIndex: rangeStopIndex\n      });\n\n      rangeStartIndex = rangeStopIndex = null;\n    }\n  }\n\n  // If :rangeStopIndex is not null it means we haven't ran out of unloaded rows.\n  // Scan forward to try filling our :minimumBatchSize.\n  if (rangeStopIndex !== null) {\n    var potentialStopIndex = Math.min(Math.max(rangeStopIndex, rangeStartIndex + minimumBatchSize - 1), rowCount - 1);\n\n    for (var _index = rangeStopIndex + 1; _index <= potentialStopIndex; _index++) {\n      if (!isRowLoaded({ index: _index })) {\n        rangeStopIndex = _index;\n      } else {\n        break;\n      }\n    }\n\n    unloadedRanges.push({\n      startIndex: rangeStartIndex,\n      stopIndex: rangeStopIndex\n    });\n  }\n\n  // Check to see if our first range ended prematurely.\n  // In this case we should scan backwards to try filling our :minimumBatchSize.\n  if (unloadedRanges.length) {\n    var firstUnloadedRange = unloadedRanges[0];\n\n    while (firstUnloadedRange.stopIndex - firstUnloadedRange.startIndex + 1 < minimumBatchSize && firstUnloadedRange.startIndex > 0) {\n      var _index2 = firstUnloadedRange.startIndex - 1;\n\n      if (!isRowLoaded({ index: _index2 })) {\n        firstUnloadedRange.startIndex = _index2;\n      } else {\n        break;\n      }\n    }\n  }\n\n  return unloadedRanges;\n}\n\n/**\n * Since RV components use shallowCompare we need to force a render (even though props haven't changed).\n * However InfiniteLoader may wrap a Grid or it may wrap a FlexTable or VirtualScroll.\n * In the first case the built-in React forceUpdate() method is sufficient to force a re-render,\n * But in the latter cases we need to use the RV-specific forceUpdateGrid() method.\n * Else the inner Grid will not be re-rendered and visuals may be stale.\n */\nfunction forceUpdateReactVirtualizedComponent(component) {\n  typeof component.forceUpdateGrid === 'function' ? component.forceUpdateGrid() : component.forceUpdate();\n}","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.InfiniteLoader = exports.default = undefined;\n\nvar _InfiniteLoader2 = require('./InfiniteLoader');\n\nvar _InfiniteLoader3 = _interopRequireDefault(_InfiniteLoader2);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = _InfiniteLoader3.default;\nexports.InfiniteLoader = _InfiniteLoader3.default;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _react = require('react');\n\nvar _reactAddonsShallowCompare = require('react-addons-shallow-compare');\n\nvar _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/**\n * HOC that simplifies the process of synchronizing scrolling between two or more virtualized components.\n */\nvar ScrollSync = function (_Component) {\n  _inherits(ScrollSync, _Component);\n\n  function ScrollSync(props, context) {\n    _classCallCheck(this, ScrollSync);\n\n    var _this = _possibleConstructorReturn(this, (ScrollSync.__proto__ || Object.getPrototypeOf(ScrollSync)).call(this, props, context));\n\n    _this.state = {\n      clientHeight: 0,\n      clientWidth: 0,\n      scrollHeight: 0,\n      scrollLeft: 0,\n      scrollTop: 0,\n      scrollWidth: 0\n    };\n\n    _this._onScroll = _this._onScroll.bind(_this);\n    return _this;\n  }\n\n  _createClass(ScrollSync, [{\n    key: 'render',\n    value: function render() {\n      var children = this.props.children;\n      var _state = this.state;\n      var clientHeight = _state.clientHeight;\n      var clientWidth = _state.clientWidth;\n      var scrollHeight = _state.scrollHeight;\n      var scrollLeft = _state.scrollLeft;\n      var scrollTop = _state.scrollTop;\n      var scrollWidth = _state.scrollWidth;\n\n\n      return children({\n        clientHeight: clientHeight,\n        clientWidth: clientWidth,\n        onScroll: this._onScroll,\n        scrollHeight: scrollHeight,\n        scrollLeft: scrollLeft,\n        scrollTop: scrollTop,\n        scrollWidth: scrollWidth\n      });\n    }\n  }, {\n    key: 'shouldComponentUpdate',\n    value: function shouldComponentUpdate(nextProps, nextState) {\n      return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState);\n    }\n  }, {\n    key: '_onScroll',\n    value: function _onScroll(_ref) {\n      var clientHeight = _ref.clientHeight;\n      var clientWidth = _ref.clientWidth;\n      var scrollHeight = _ref.scrollHeight;\n      var scrollLeft = _ref.scrollLeft;\n      var scrollTop = _ref.scrollTop;\n      var scrollWidth = _ref.scrollWidth;\n\n      this.setState({ clientHeight: clientHeight, clientWidth: clientWidth, scrollHeight: scrollHeight, scrollLeft: scrollLeft, scrollTop: scrollTop, scrollWidth: scrollWidth });\n    }\n  }]);\n\n  return ScrollSync;\n}(_react.Component);\n\nScrollSync.propTypes = {\n  /**\n   * Function respondible for rendering 2 or more virtualized components.\n   * This function should implement the following signature:\n   * ({ onScroll, scrollLeft, scrollTop }) => PropTypes.element\n   */\n  children: _react.PropTypes.func.isRequired\n};\nexports.default = ScrollSync;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.ScrollSync = exports.default = undefined;\n\nvar _ScrollSync2 = require('./ScrollSync');\n\nvar _ScrollSync3 = _interopRequireDefault(_ScrollSync2);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = _ScrollSync3.default;\nexports.ScrollSync = _ScrollSync3.default;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _Grid = require('../Grid');\n\nvar _Grid2 = _interopRequireDefault(_Grid);\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _classnames = require('classnames');\n\nvar _classnames2 = _interopRequireDefault(_classnames);\n\nvar _reactAddonsShallowCompare = require('react-addons-shallow-compare');\n\nvar _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/**\n * It is inefficient to create and manage a large list of DOM elements within a scrolling container\n * if only a few of those elements are visible. The primary purpose of this component is to improve\n * performance by only rendering the DOM nodes that a user is able to see based on their current\n * scroll position.\n *\n * This component renders a virtualized list of elements with either fixed or dynamic heights.\n */\nvar VirtualScroll = function (_Component) {\n  _inherits(VirtualScroll, _Component);\n\n  function VirtualScroll(props, context) {\n    _classCallCheck(this, VirtualScroll);\n\n    var _this = _possibleConstructorReturn(this, (VirtualScroll.__proto__ || Object.getPrototypeOf(VirtualScroll)).call(this, props, context));\n\n    _this._cellRenderer = _this._cellRenderer.bind(_this);\n    _this._createRowClassNameGetter = _this._createRowClassNameGetter.bind(_this);\n    _this._createRowStyleGetter = _this._createRowStyleGetter.bind(_this);\n    _this._onScroll = _this._onScroll.bind(_this);\n    _this._onSectionRendered = _this._onSectionRendered.bind(_this);\n    return _this;\n  }\n\n  _createClass(VirtualScroll, [{\n    key: 'forceUpdateGrid',\n    value: function forceUpdateGrid() {\n      this.Grid.forceUpdate();\n    }\n\n    /** See Grid#measureAllCells */\n\n  }, {\n    key: 'measureAllRows',\n    value: function measureAllRows() {\n      this.Grid.measureAllCells();\n    }\n\n    /** See Grid#recomputeGridSize */\n\n  }, {\n    key: 'recomputeRowHeights',\n    value: function recomputeRowHeights() {\n      var index = arguments.length <= 0 || arguments[0] === undefined ? 0 : arguments[0];\n\n      this.Grid.recomputeGridSize({\n        rowIndex: index\n      });\n      this.forceUpdateGrid();\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      var _this2 = this;\n\n      var _props = this.props;\n      var className = _props.className;\n      var noRowsRenderer = _props.noRowsRenderer;\n      var scrollToIndex = _props.scrollToIndex;\n      var width = _props.width;\n\n\n      var classNames = (0, _classnames2.default)('VirtualScroll', className);\n\n      return _react2.default.createElement(_Grid2.default, _extends({}, this.props, {\n        autoContainerWidth: true,\n        cellRenderer: this._cellRenderer,\n        cellClassName: this._createRowClassNameGetter(),\n        cellStyle: this._createRowStyleGetter(),\n        className: classNames,\n        columnWidth: width,\n        columnCount: 1,\n        noContentRenderer: noRowsRenderer,\n        onScroll: this._onScroll,\n        onSectionRendered: this._onSectionRendered,\n        ref: function ref(_ref) {\n          _this2.Grid = _ref;\n        },\n        scrollToRow: scrollToIndex\n      }));\n    }\n  }, {\n    key: 'shouldComponentUpdate',\n    value: function shouldComponentUpdate(nextProps, nextState) {\n      return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState);\n    }\n  }, {\n    key: '_cellRenderer',\n    value: function _cellRenderer(_ref2) {\n      var columnIndex = _ref2.columnIndex;\n      var isScrolling = _ref2.isScrolling;\n      var rowIndex = _ref2.rowIndex;\n      var rowRenderer = this.props.rowRenderer;\n\n\n      return rowRenderer({\n        index: rowIndex,\n        isScrolling: isScrolling\n      });\n    }\n  }, {\n    key: '_createRowClassNameGetter',\n    value: function _createRowClassNameGetter() {\n      var rowClassName = this.props.rowClassName;\n\n\n      return rowClassName instanceof Function ? function (_ref3) {\n        var rowIndex = _ref3.rowIndex;\n        return rowClassName({ index: rowIndex });\n      } : function () {\n        return rowClassName;\n      };\n    }\n  }, {\n    key: '_createRowStyleGetter',\n    value: function _createRowStyleGetter() {\n      var rowStyle = this.props.rowStyle;\n\n\n      var wrapped = rowStyle instanceof Function ? rowStyle : function () {\n        return rowStyle;\n      };\n\n      // Default width to 100% to prevent list rows from flowing under the vertical scrollbar\n      return function (_ref4) {\n        var rowIndex = _ref4.rowIndex;\n        return _extends({\n          width: '100%'\n        }, wrapped({ index: rowIndex }));\n      };\n    }\n  }, {\n    key: '_onScroll',\n    value: function _onScroll(_ref5) {\n      var clientHeight = _ref5.clientHeight;\n      var scrollHeight = _ref5.scrollHeight;\n      var scrollTop = _ref5.scrollTop;\n      var onScroll = this.props.onScroll;\n\n\n      onScroll({ clientHeight: clientHeight, scrollHeight: scrollHeight, scrollTop: scrollTop });\n    }\n  }, {\n    key: '_onSectionRendered',\n    value: function _onSectionRendered(_ref6) {\n      var rowOverscanStartIndex = _ref6.rowOverscanStartIndex;\n      var rowOverscanStopIndex = _ref6.rowOverscanStopIndex;\n      var rowStartIndex = _ref6.rowStartIndex;\n      var rowStopIndex = _ref6.rowStopIndex;\n      var onRowsRendered = this.props.onRowsRendered;\n\n\n      onRowsRendered({\n        overscanStartIndex: rowOverscanStartIndex,\n        overscanStopIndex: rowOverscanStopIndex,\n        startIndex: rowStartIndex,\n        stopIndex: rowStopIndex\n      });\n    }\n  }]);\n\n  return VirtualScroll;\n}(_react.Component);\n\nVirtualScroll.propTypes = {\n  'aria-label': _react.PropTypes.string,\n\n  /**\n   * Removes fixed height from the scrollingContainer so that the total height\n   * of rows can stretch the window. Intended for use with WindowScroller\n   */\n  autoHeight: _react.PropTypes.bool,\n\n  /** Optional CSS class name */\n  className: _react.PropTypes.string,\n\n  /**\n   * Used to estimate the total height of a VirtualScroll before all of its rows have actually been measured.\n   * The estimated total height is adjusted as rows are rendered.\n   */\n  estimatedRowSize: _react.PropTypes.number.isRequired,\n\n  /** Height constraint for list (determines how many actual rows are rendered) */\n  height: _react.PropTypes.number.isRequired,\n\n  /** Optional renderer to be used in place of rows when rowCount is 0 */\n  noRowsRenderer: _react.PropTypes.func.isRequired,\n\n  /**\n   * Callback invoked with information about the slice of rows that were just rendered.\n   * ({ startIndex, stopIndex }): void\n   */\n  onRowsRendered: _react.PropTypes.func.isRequired,\n\n  /**\n   * Number of rows to render above/below the visible bounds of the list.\n   * These rows can help for smoother scrolling on touch devices.\n   */\n  overscanRowCount: _react.PropTypes.number.isRequired,\n\n  /**\n   * Callback invoked whenever the scroll offset changes within the inner scrollable region.\n   * This callback can be used to sync scrolling between lists, tables, or grids.\n   * ({ clientHeight, scrollHeight, scrollTop }): void\n   */\n  onScroll: _react.PropTypes.func.isRequired,\n\n  /**\n   * Either a fixed row height (number) or a function that returns the height of a row given its index.\n   * ({ index: number }): number\n   */\n  rowHeight: _react.PropTypes.oneOfType([_react.PropTypes.number, _react.PropTypes.func]).isRequired,\n\n  /** Responsbile for rendering a row given an index; ({ index: number }): node */\n  rowRenderer: _react.PropTypes.func.isRequired,\n\n  /** Optional custom CSS class for individual rows */\n  rowClassName: _react.PropTypes.oneOfType([_react.PropTypes.string, _react.PropTypes.func]),\n\n  /** Number of rows in list. */\n  rowCount: _react.PropTypes.number.isRequired,\n\n  /** Optional custom styles for individual cells */\n  rowStyle: _react.PropTypes.oneOfType([_react.PropTypes.object, _react.PropTypes.func]),\n\n  /** See Grid#scrollToAlignment */\n  scrollToAlignment: _react.PropTypes.oneOf(['auto', 'end', 'start', 'center']).isRequired,\n\n  /** Row index to ensure visible (by forcefully scrolling if necessary) */\n  scrollToIndex: _react.PropTypes.number,\n\n  /** Vertical offset. */\n  scrollTop: _react.PropTypes.number,\n\n  /** Optional inline style */\n  style: _react.PropTypes.object,\n\n  /** Tab index for focus */\n  tabIndex: _react.PropTypes.number,\n\n  /** Width of list */\n  width: _react.PropTypes.number.isRequired\n};\nVirtualScroll.defaultProps = {\n  estimatedRowSize: 30,\n  noRowsRenderer: function noRowsRenderer() {\n    return null;\n  },\n  onRowsRendered: function onRowsRendered() {\n    return null;\n  },\n  onScroll: function onScroll() {\n    return null;\n  },\n  overscanRowCount: 10,\n  scrollToAlignment: 'auto',\n  style: {}\n};\nexports.default = VirtualScroll;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.VirtualScroll = exports.default = undefined;\n\nvar _VirtualScroll2 = require('./VirtualScroll');\n\nvar _VirtualScroll3 = _interopRequireDefault(_VirtualScroll2);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = _VirtualScroll3.default;\nexports.VirtualScroll = _VirtualScroll3.default;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _reactDom = require('react-dom');\n\nvar _reactDom2 = _interopRequireDefault(_reactDom);\n\nvar _reactAddonsShallowCompare = require('react-addons-shallow-compare');\n\nvar _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare);\n\nvar _raf = require('raf');\n\nvar _raf2 = _interopRequireDefault(_raf);\n\nvar _onScroll = require('./utils/onScroll');\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar WindowScroller = function (_Component) {\n  _inherits(WindowScroller, _Component);\n\n  function WindowScroller(props) {\n    _classCallCheck(this, WindowScroller);\n\n    var _this = _possibleConstructorReturn(this, (WindowScroller.__proto__ || Object.getPrototypeOf(WindowScroller)).call(this, props));\n\n    var height = typeof window !== 'undefined' ? window.innerHeight : 0;\n\n    _this.state = {\n      isScrolling: false,\n      height: height,\n      scrollTop: 0\n    };\n\n    _this._onScrollWindow = _this._onScrollWindow.bind(_this);\n    _this._onResizeWindow = _this._onResizeWindow.bind(_this);\n    _this._enablePointerEventsAfterDelayCallback = _this._enablePointerEventsAfterDelayCallback.bind(_this);\n    return _this;\n  }\n\n  _createClass(WindowScroller, [{\n    key: 'componentDidMount',\n    value: function componentDidMount() {\n      var height = this.state.height;\n\n      // Subtract documentElement top to handle edge-case where a user is navigating back (history) from an already-scrolled bage.\n      // In this case the body's top position will be a negative number and this element's top will be increased (by that amount).\n\n      this._positionFromTop = _reactDom2.default.findDOMNode(this).getBoundingClientRect().top - document.documentElement.getBoundingClientRect().top;\n\n      if (height !== window.innerHeight) {\n        this.setState({\n          height: window.innerHeight\n        });\n      }\n\n      (0, _onScroll.registerScrollListener)(this);\n      window.addEventListener('resize', this._onResizeWindow, false);\n    }\n  }, {\n    key: 'componentWillUnmount',\n    value: function componentWillUnmount() {\n      (0, _onScroll.unregisterScrollListener)(this);\n\n      window.removeEventListener('resize', this._onResizeWindow, false);\n    }\n\n    /**\n     * Updates the state during the next animation frame.\n     * Use this method to avoid multiple renders in a small span of time.\n     * This helps performance for bursty events (like onScroll).\n     */\n\n  }, {\n    key: '_setNextState',\n    value: function _setNextState(state) {\n      var _this2 = this;\n\n      if (this._setNextStateAnimationFrameId) {\n        _raf2.default.cancel(this._setNextStateAnimationFrameId);\n      }\n\n      this._setNextStateAnimationFrameId = (0, _raf2.default)(function () {\n        _this2._setNextStateAnimationFrameId = null;\n        _this2.setState(state);\n      });\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      var children = this.props.children;\n      var _state = this.state;\n      var isScrolling = _state.isScrolling;\n      var scrollTop = _state.scrollTop;\n      var height = _state.height;\n\n\n      return _react2.default.createElement(\n        'div',\n        null,\n        children({\n          height: height,\n          isScrolling: isScrolling,\n          scrollTop: scrollTop\n        })\n      );\n    }\n  }, {\n    key: 'shouldComponentUpdate',\n    value: function shouldComponentUpdate(nextProps, nextState) {\n      return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState);\n    }\n  }, {\n    key: '_enablePointerEventsAfterDelayCallback',\n    value: function _enablePointerEventsAfterDelayCallback() {\n      this.setState({\n        isScrolling: false\n      });\n    }\n  }, {\n    key: '_onResizeWindow',\n    value: function _onResizeWindow(event) {\n      var onResize = this.props.onResize;\n\n\n      var height = window.innerHeight || 0;\n\n      this.setState({ height: height });\n\n      onResize({ height: height });\n    }\n  }, {\n    key: '_onScrollWindow',\n    value: function _onScrollWindow(event) {\n      var onScroll = this.props.onScroll;\n\n      // In IE10+ scrollY is undefined, so we replace that with the latter\n\n      var scrollY = 'scrollY' in window ? window.scrollY : document.documentElement.scrollTop;\n\n      var scrollTop = Math.max(0, scrollY - this._positionFromTop);\n\n      var state = {\n        isScrolling: true,\n        scrollTop: scrollTop\n      };\n\n      if (!this.state.isScrolling) {\n        this.setState(state);\n      } else {\n        this._setNextState(state);\n      }\n\n      onScroll({ scrollTop: scrollTop });\n    }\n  }]);\n\n  return WindowScroller;\n}(_react.Component);\n\nWindowScroller.propTypes = {\n  /**\n   * Function respondible for rendering children.\n   * This function should implement the following signature:\n   * ({ height, scrollTop }) => PropTypes.element\n   */\n  children: _react.PropTypes.func.isRequired,\n\n  /** Callback to be invoked on-resize: ({ height }) */\n  onResize: _react.PropTypes.func.isRequired,\n\n  /** Callback to be invoked on-scroll: ({ scrollTop }) */\n  onScroll: _react.PropTypes.func.isRequired\n};\nWindowScroller.defaultProps = {\n  onResize: function onResize() {},\n  onScroll: function onScroll() {}\n};\nexports.default = WindowScroller;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.IS_SCROLLING_TIMEOUT = exports.WindowScroller = exports.default = undefined;\n\nvar _WindowScroller2 = require('./WindowScroller');\n\nvar _WindowScroller3 = _interopRequireDefault(_WindowScroller2);\n\nvar _onScroll = require('./utils/onScroll');\n\nvar _onScroll2 = _interopRequireDefault(_onScroll);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = _WindowScroller3.default;\nexports.WindowScroller = _WindowScroller3.default;\nexports.IS_SCROLLING_TIMEOUT = _onScroll2.default;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.registerScrollListener = registerScrollListener;\nexports.unregisterScrollListener = unregisterScrollListener;\nvar mountedInstances = [];\nvar originalBodyPointerEvents = null;\nvar disablePointerEventsTimeoutId = null;\n\n/**\n * Specifies the number of miliseconds during which to disable pointer events while a scroll is in progress.\n * This improves performance and makes scrolling smoother.\n */\nvar IS_SCROLLING_TIMEOUT = exports.IS_SCROLLING_TIMEOUT = 150;\n\nfunction enablePointerEventsIfDisabled() {\n  if (disablePointerEventsTimeoutId) {\n    disablePointerEventsTimeoutId = null;\n\n    document.body.style.pointerEvents = originalBodyPointerEvents;\n\n    originalBodyPointerEvents = null;\n  }\n}\n\nfunction enablePointerEventsAfterDelayCallback() {\n  enablePointerEventsIfDisabled();\n  mountedInstances.forEach(function (component) {\n    return component._enablePointerEventsAfterDelayCallback();\n  });\n}\n\nfunction enablePointerEventsAfterDelay() {\n  if (disablePointerEventsTimeoutId) {\n    clearTimeout(disablePointerEventsTimeoutId);\n  }\n\n  disablePointerEventsTimeoutId = setTimeout(enablePointerEventsAfterDelayCallback, IS_SCROLLING_TIMEOUT);\n}\n\nfunction onScrollWindow(event) {\n  if (originalBodyPointerEvents == null) {\n    originalBodyPointerEvents = document.body.style.pointerEvents;\n\n    document.body.style.pointerEvents = 'none';\n\n    enablePointerEventsAfterDelay();\n  }\n  mountedInstances.forEach(function (component) {\n    return component._onScrollWindow(event);\n  });\n}\n\nfunction registerScrollListener(component) {\n  if (!mountedInstances.length) {\n    window.addEventListener('scroll', onScrollWindow);\n  }\n  mountedInstances.push(component);\n}\n\nfunction unregisterScrollListener(component) {\n  mountedInstances = mountedInstances.filter(function (c) {\n    return c !== component;\n  });\n  if (!mountedInstances.length) {\n    window.removeEventListener('scroll', onScrollWindow);\n    if (disablePointerEventsTimeoutId) {\n      clearTimeout(disablePointerEventsTimeoutId);\n      enablePointerEventsIfDisabled();\n    }\n  }\n}","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _ArrowKeyStepper = require('./ArrowKeyStepper');\n\nObject.defineProperty(exports, 'ArrowKeyStepper', {\n  enumerable: true,\n  get: function get() {\n    return _ArrowKeyStepper.ArrowKeyStepper;\n  }\n});\n\nvar _AutoSizer = require('./AutoSizer');\n\nObject.defineProperty(exports, 'AutoSizer', {\n  enumerable: true,\n  get: function get() {\n    return _AutoSizer.AutoSizer;\n  }\n});\n\nvar _CellMeasurer = require('./CellMeasurer');\n\nObject.defineProperty(exports, 'CellMeasurer', {\n  enumerable: true,\n  get: function get() {\n    return _CellMeasurer.CellMeasurer;\n  }\n});\nObject.defineProperty(exports, 'defaultCellMeasurerCellSizeCache', {\n  enumerable: true,\n  get: function get() {\n    return _CellMeasurer.defaultCellSizeCache;\n  }\n});\nObject.defineProperty(exports, 'uniformSizeCellMeasurerCellSizeCache', {\n  enumerable: true,\n  get: function get() {\n    return _CellMeasurer.defaultCellSizeCache;\n  }\n});\n\nvar _Collection = require('./Collection');\n\nObject.defineProperty(exports, 'Collection', {\n  enumerable: true,\n  get: function get() {\n    return _Collection.Collection;\n  }\n});\n\nvar _ColumnSizer = require('./ColumnSizer');\n\nObject.defineProperty(exports, 'ColumnSizer', {\n  enumerable: true,\n  get: function get() {\n    return _ColumnSizer.ColumnSizer;\n  }\n});\n\nvar _FlexTable = require('./FlexTable');\n\nObject.defineProperty(exports, 'defaultFlexTableCellDataGetter', {\n  enumerable: true,\n  get: function get() {\n    return _FlexTable.defaultCellDataGetter;\n  }\n});\nObject.defineProperty(exports, 'defaultFlexTableCellRenderer', {\n  enumerable: true,\n  get: function get() {\n    return _FlexTable.defaultCellRenderer;\n  }\n});\nObject.defineProperty(exports, 'defaultFlexTableHeaderRenderer', {\n  enumerable: true,\n  get: function get() {\n    return _FlexTable.defaultHeaderRenderer;\n  }\n});\nObject.defineProperty(exports, 'defaultFlexTableRowRenderer', {\n  enumerable: true,\n  get: function get() {\n    return _FlexTable.defaultRowRenderer;\n  }\n});\nObject.defineProperty(exports, 'FlexTable', {\n  enumerable: true,\n  get: function get() {\n    return _FlexTable.FlexTable;\n  }\n});\nObject.defineProperty(exports, 'FlexColumn', {\n  enumerable: true,\n  get: function get() {\n    return _FlexTable.FlexColumn;\n  }\n});\nObject.defineProperty(exports, 'SortDirection', {\n  enumerable: true,\n  get: function get() {\n    return _FlexTable.SortDirection;\n  }\n});\nObject.defineProperty(exports, 'SortIndicator', {\n  enumerable: true,\n  get: function get() {\n    return _FlexTable.SortIndicator;\n  }\n});\n\nvar _Grid = require('./Grid');\n\nObject.defineProperty(exports, 'defaultCellRangeRenderer', {\n  enumerable: true,\n  get: function get() {\n    return _Grid.defaultCellRangeRenderer;\n  }\n});\nObject.defineProperty(exports, 'Grid', {\n  enumerable: true,\n  get: function get() {\n    return _Grid.Grid;\n  }\n});\n\nvar _InfiniteLoader = require('./InfiniteLoader');\n\nObject.defineProperty(exports, 'InfiniteLoader', {\n  enumerable: true,\n  get: function get() {\n    return _InfiniteLoader.InfiniteLoader;\n  }\n});\n\nvar _ScrollSync = require('./ScrollSync');\n\nObject.defineProperty(exports, 'ScrollSync', {\n  enumerable: true,\n  get: function get() {\n    return _ScrollSync.ScrollSync;\n  }\n});\n\nvar _VirtualScroll = require('./VirtualScroll');\n\nObject.defineProperty(exports, 'VirtualScroll', {\n  enumerable: true,\n  get: function get() {\n    return _VirtualScroll.VirtualScroll;\n  }\n});\n\nvar _WindowScroller = require('./WindowScroller');\n\nObject.defineProperty(exports, 'WindowScroller', {\n  enumerable: true,\n  get: function get() {\n    return _WindowScroller.WindowScroller;\n  }\n});","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = createCallbackMemoizer;\n/**\n * Helper utility that updates the specified callback whenever any of the specified indices have changed.\n */\nfunction createCallbackMemoizer() {\n  var requireAllKeys = arguments.length <= 0 || arguments[0] === undefined ? true : arguments[0];\n\n  var cachedIndices = {};\n\n  return function (_ref) {\n    var callback = _ref.callback;\n    var indices = _ref.indices;\n\n    var keys = Object.keys(indices);\n    var allInitialized = !requireAllKeys || keys.every(function (key) {\n      var value = indices[key];\n      return Array.isArray(value) ? value.length > 0 : value >= 0;\n    });\n    var indexChanged = keys.length !== Object.keys(cachedIndices).length || keys.some(function (key) {\n      var cachedValue = cachedIndices[key];\n      var value = indices[key];\n\n      return Array.isArray(value) ? cachedValue.join(',') !== value.join(',') : cachedValue !== value;\n    });\n\n    cachedIndices = indices;\n\n    if (allInitialized && indexChanged) {\n      callback(indices);\n    }\n  };\n}","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = getUpdatedOffsetForIndex;\n/**\n * Determines a new offset that ensures a certain cell is visible, given the current offset.\n * If the cell is already visible then the current offset will be returned.\n * If the current offset is too great or small, it will be adjusted just enough to ensure the specified index is visible.\n *\n * @param align Desired alignment within container; one of \"auto\" (default), \"start\", or \"end\"\n * @param cellOffset Offset (x or y) position for cell\n * @param cellSize Size (width or height) of cell\n * @param containerSize Total size (width or height) of the container\n * @param currentOffset Container's current (x or y) offset\n * @return Offset to use to ensure the specified cell is visible\n */\nfunction getUpdatedOffsetForIndex(_ref) {\n  var _ref$align = _ref.align;\n  var align = _ref$align === undefined ? 'auto' : _ref$align;\n  var cellOffset = _ref.cellOffset;\n  var cellSize = _ref.cellSize;\n  var containerSize = _ref.containerSize;\n  var currentOffset = _ref.currentOffset;\n\n  var maxOffset = cellOffset;\n  var minOffset = maxOffset - containerSize + cellSize;\n\n  switch (align) {\n    case 'start':\n      return maxOffset;\n    case 'end':\n      return minOffset;\n    case 'center':\n      return maxOffset - (containerSize - cellSize) / 2;\n    default:\n      return Math.max(minOffset, Math.min(maxOffset, currentOffset));\n  }\n}","'use strict';\n\n/**\n* Detect Element Resize.\n* Forked in order to guard against unsafe 'window' and 'document' references.\n*\n* https://github.com/sdecima/javascript-detect-element-resize\n* Sebastian Decima\n*\n* version: 0.5.3\n**/\n\n// Check `document` and `window` in case of server-side rendering\nvar _window;\nif (typeof window !== 'undefined') {\n  _window = window;\n} else if (typeof self !== 'undefined') {\n  _window = self;\n} else {\n  _window = undefined;\n}\n\nvar attachEvent = typeof document !== 'undefined' && document.attachEvent;\nvar stylesCreated = false;\n\nif (!attachEvent) {\n  var requestFrame = function () {\n    var raf = _window.requestAnimationFrame || _window.mozRequestAnimationFrame || _window.webkitRequestAnimationFrame || function (fn) {\n      return _window.setTimeout(fn, 20);\n    };\n    return function (fn) {\n      return raf(fn);\n    };\n  }();\n\n  var cancelFrame = function () {\n    var cancel = _window.cancelAnimationFrame || _window.mozCancelAnimationFrame || _window.webkitCancelAnimationFrame || _window.clearTimeout;\n    return function (id) {\n      return cancel(id);\n    };\n  }();\n\n  var resetTriggers = function resetTriggers(element) {\n    var triggers = element.__resizeTriggers__,\n        expand = triggers.firstElementChild,\n        contract = triggers.lastElementChild,\n        expandChild = expand.firstElementChild;\n    contract.scrollLeft = contract.scrollWidth;\n    contract.scrollTop = contract.scrollHeight;\n    expandChild.style.width = expand.offsetWidth + 1 + 'px';\n    expandChild.style.height = expand.offsetHeight + 1 + 'px';\n    expand.scrollLeft = expand.scrollWidth;\n    expand.scrollTop = expand.scrollHeight;\n  };\n\n  var checkTriggers = function checkTriggers(element) {\n    return element.offsetWidth != element.__resizeLast__.width || element.offsetHeight != element.__resizeLast__.height;\n  };\n\n  var scrollListener = function scrollListener(e) {\n    var element = this;\n    resetTriggers(this);\n    if (this.__resizeRAF__) cancelFrame(this.__resizeRAF__);\n    this.__resizeRAF__ = requestFrame(function () {\n      if (checkTriggers(element)) {\n        element.__resizeLast__.width = element.offsetWidth;\n        element.__resizeLast__.height = element.offsetHeight;\n        element.__resizeListeners__.forEach(function (fn) {\n          fn.call(element, e);\n        });\n      }\n    });\n  };\n\n  /* Detect CSS Animations support to detect element display/re-attach */\n  var animation = false,\n      animationstring = 'animation',\n      keyframeprefix = '',\n      animationstartevent = 'animationstart',\n      domPrefixes = 'Webkit Moz O ms'.split(' '),\n      startEvents = 'webkitAnimationStart animationstart oAnimationStart MSAnimationStart'.split(' '),\n      pfx = '';\n  {\n    var elm = document.createElement('fakeelement');\n    if (elm.style.animationName !== undefined) {\n      animation = true;\n    }\n\n    if (animation === false) {\n      for (var i = 0; i < domPrefixes.length; i++) {\n        if (elm.style[domPrefixes[i] + 'AnimationName'] !== undefined) {\n          pfx = domPrefixes[i];\n          animationstring = pfx + 'Animation';\n          keyframeprefix = '-' + pfx.toLowerCase() + '-';\n          animationstartevent = startEvents[i];\n          animation = true;\n          break;\n        }\n      }\n    }\n  }\n\n  var animationName = 'resizeanim';\n  var animationKeyframes = '@' + keyframeprefix + 'keyframes ' + animationName + ' { from { opacity: 0; } to { opacity: 0; } } ';\n  var animationStyle = keyframeprefix + 'animation: 1ms ' + animationName + '; ';\n}\n\nvar createStyles = function createStyles() {\n  if (!stylesCreated) {\n    //opacity:0 works around a chrome bug https://code.google.com/p/chromium/issues/detail?id=286360\n    var css = (animationKeyframes ? animationKeyframes : '') + '.resize-triggers { ' + (animationStyle ? animationStyle : '') + 'visibility: hidden; opacity: 0; } ' + '.resize-triggers, .resize-triggers > div, .contract-trigger:before { content: \\\" \\\"; display: block; position: absolute; top: 0; left: 0; height: 100%; width: 100%; overflow: hidden; } .resize-triggers > div { background: #eee; overflow: auto; } .contract-trigger:before { width: 200%; height: 200%; }',\n        head = document.head || document.getElementsByTagName('head')[0],\n        style = document.createElement('style');\n\n    style.type = 'text/css';\n    if (style.styleSheet) {\n      style.styleSheet.cssText = css;\n    } else {\n      style.appendChild(document.createTextNode(css));\n    }\n\n    head.appendChild(style);\n    stylesCreated = true;\n  }\n};\n\nvar addResizeListener = function addResizeListener(element, fn) {\n  if (attachEvent) element.attachEvent('onresize', fn);else {\n    if (!element.__resizeTriggers__) {\n      if (getComputedStyle(element).position == 'static') element.style.position = 'relative';\n      createStyles();\n      element.__resizeLast__ = {};\n      element.__resizeListeners__ = [];\n      (element.__resizeTriggers__ = document.createElement('div')).className = 'resize-triggers';\n      element.__resizeTriggers__.innerHTML = '<div class=\"expand-trigger\"><div></div></div>' + '<div class=\"contract-trigger\"></div>';\n      element.appendChild(element.__resizeTriggers__);\n      resetTriggers(element);\n      element.addEventListener('scroll', scrollListener, true);\n\n      /* Listen for a css animation to detect element display/re-attach */\n      animationstartevent && element.__resizeTriggers__.addEventListener(animationstartevent, function (e) {\n        if (e.animationName == animationName) resetTriggers(element);\n      });\n    }\n    element.__resizeListeners__.push(fn);\n  }\n};\n\nvar removeResizeListener = function removeResizeListener(element, fn) {\n  if (attachEvent) element.detachEvent('onresize', fn);else {\n    element.__resizeListeners__.splice(element.__resizeListeners__.indexOf(fn), 1);\n    if (!element.__resizeListeners__.length) {\n      element.removeEventListener('scroll', scrollListener, true);\n      element.__resizeTriggers__ = !element.removeChild(element.__resizeTriggers__);\n    }\n  }\n};\n\nmodule.exports = {\n  addResizeListener: addResizeListener,\n  removeResizeListener: removeResizeListener\n};","'use strict';\nmodule.exports = !!(typeof window !== 'undefined' && window.document && window.document.createElement);","'use strict';\n\nvar canUseDOM = require('./inDOM');\n\nvar size;\n\nmodule.exports = function (recalc) {\n  if (!size || recalc) {\n    if (canUseDOM) {\n      var scrollDiv = document.createElement('div');\n\n      scrollDiv.style.position = 'absolute';\n      scrollDiv.style.top = '-9999px';\n      scrollDiv.style.width = '50px';\n      scrollDiv.style.height = '50px';\n      scrollDiv.style.overflow = 'scroll';\n\n      document.body.appendChild(scrollDiv);\n      size = scrollDiv.offsetWidth - scrollDiv.clientWidth;\n      document.body.removeChild(scrollDiv);\n    }\n  }\n\n  return size;\n};","var now = require('performance-now')\n  , root = typeof window === 'undefined' ? global : window\n  , vendors = ['moz', 'webkit']\n  , suffix = 'AnimationFrame'\n  , raf = root['request' + suffix]\n  , caf = root['cancel' + suffix] || root['cancelRequest' + suffix]\n\nfor(var i = 0; !raf && i < vendors.length; i++) {\n  raf = root[vendors[i] + 'Request' + suffix]\n  caf = root[vendors[i] + 'Cancel' + suffix]\n      || root[vendors[i] + 'CancelRequest' + suffix]\n}\n\n// Some versions of FF have rAF but not cAF\nif(!raf || !caf) {\n  var last = 0\n    , id = 0\n    , queue = []\n    , frameDuration = 1000 / 60\n\n  raf = function(callback) {\n    if(queue.length === 0) {\n      var _now = now()\n        , next = Math.max(0, frameDuration - (_now - last))\n      last = next + _now\n      setTimeout(function() {\n        var cp = queue.slice(0)\n        // Clear queue here to prevent\n        // callbacks from appending listeners\n        // to the current frame's queue\n        queue.length = 0\n        for(var i = 0; i < cp.length; i++) {\n          if(!cp[i].cancelled) {\n            try{\n              cp[i].callback(last)\n            } catch(e) {\n              setTimeout(function() { throw e }, 0)\n            }\n          }\n        }\n      }, Math.round(next))\n    }\n    queue.push({\n      handle: ++id,\n      callback: callback,\n      cancelled: false\n    })\n    return id\n  }\n\n  caf = function(handle) {\n    for(var i = 0; i < queue.length; i++) {\n      if(queue[i].handle === handle) {\n        queue[i].cancelled = true\n      }\n    }\n  }\n}\n\nmodule.exports = function(fn) {\n  // Wrap in a new function to prevent\n  // `cancel` potentially being assigned\n  // to the native rAF function\n  return raf.call(root, fn)\n}\nmodule.exports.cancel = function() {\n  caf.apply(root, arguments)\n}\nmodule.exports.polyfill = function() {\n  root.requestAnimationFrame = raf\n  root.cancelAnimationFrame = caf\n}\n","// Generated by CoffeeScript 1.12.2\n(function() {\n  var getNanoSeconds, hrtime, loadTime, moduleLoadTime, nodeLoadTime, upTime;\n\n  if ((typeof performance !== \"undefined\" && performance !== null) && performance.now) {\n    module.exports = function() {\n      return performance.now();\n    };\n  } else if ((typeof process !== \"undefined\" && process !== null) && process.hrtime) {\n    module.exports = function() {\n      return (getNanoSeconds() - nodeLoadTime) / 1e6;\n    };\n    hrtime = process.hrtime;\n    getNanoSeconds = function() {\n      var hr;\n      hr = hrtime();\n      return hr[0] * 1e9 + hr[1];\n    };\n    moduleLoadTime = getNanoSeconds();\n    upTime = process.uptime() * 1e9;\n    nodeLoadTime = moduleLoadTime - upTime;\n  } else if (Date.now) {\n    module.exports = function() {\n      return Date.now() - loadTime;\n    };\n    loadTime = Date.now();\n  } else {\n    module.exports = function() {\n      return new Date().getTime() - loadTime;\n    };\n    loadTime = new Date().getTime();\n  }\n\n}).call(this);\n\n//# sourceMappingURL=performance-now.js.map\n"]} diff --git a/examples/dist/bundle.js b/examples/dist/bundle.js index ad9809313a..3248f69c1c 100644 --- a/examples/dist/bundle.js +++ b/examples/dist/bundle.js @@ -13,8 +13,6 @@ var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_ag function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } -function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } @@ -98,16 +96,13 @@ var Async = (function (_Component) { } } }, { - key: 'componentWillUpdate', - value: function componentWillUpdate(nextProps, nextState) { - var _this = this; - - var propertiesToSync = ['options']; - propertiesToSync.forEach(function (prop) { - if (_this.props[prop] !== nextProps[prop]) { - _this.setState(_defineProperty({}, prop, nextProps[prop])); - } - }); + key: 'componentWillReceiveProps', + value: function componentWillReceiveProps(nextProps) { + if (nextProps.options !== this.props.options) { + this.setState({ + options: nextProps.options + }); + } } }, { key: 'clearOptions', @@ -117,7 +112,7 @@ var Async = (function (_Component) { }, { key: 'loadOptions', value: function loadOptions(inputValue) { - var _this2 = this; + var _this = this; var loadOptions = this.props.loadOptions; @@ -132,8 +127,8 @@ var Async = (function (_Component) { } var callback = function callback(error, data) { - if (callback === _this2._callback) { - _this2._callback = null; + if (callback === _this._callback) { + _this._callback = null; var options = data && data.options || []; @@ -141,7 +136,7 @@ var Async = (function (_Component) { cache[inputValue] = options; } - _this2.setState({ + _this.setState({ isLoading: false, options: options }); @@ -165,8 +160,6 @@ var Async = (function (_Component) { isLoading: true }); } - - return inputValue; } }, { key: '_onInputChange', @@ -176,19 +169,24 @@ var Async = (function (_Component) { var ignoreCase = _props.ignoreCase; var onInputChange = _props.onInputChange; + var transformedInputValue = inputValue; + if (ignoreAccents) { - inputValue = (0, _utilsStripDiacritics2['default'])(inputValue); + transformedInputValue = (0, _utilsStripDiacritics2['default'])(transformedInputValue); } if (ignoreCase) { - inputValue = inputValue.toLowerCase(); + transformedInputValue = transformedInputValue.toLowerCase(); } if (onInputChange) { - onInputChange(inputValue); + onInputChange(transformedInputValue); } - return this.loadOptions(inputValue); + this.loadOptions(transformedInputValue); + + // Return the original input value to avoid modifying the user's view of the input while typing. + return inputValue; } }, { key: 'inputValue', @@ -225,7 +223,7 @@ var Async = (function (_Component) { }, { key: 'render', value: function render() { - var _this3 = this; + var _this2 = this; var _props3 = this.props; var children = _props3.children; @@ -240,13 +238,13 @@ var Async = (function (_Component) { placeholder: isLoading ? loadingPlaceholder : placeholder, options: isLoading && loadingPlaceholder ? [] : options, ref: function ref(_ref) { - return _this3.select = _ref; + return _this2.select = _ref; }, onChange: function onChange(newValues) { - if (_this3.props.multi && _this3.props.value && newValues.length > _this3.props.value.length) { - _this3.clearOptions(); + if (_this2.props.multi && _this2.props.value && newValues.length > _this2.props.value.length) { + _this2.clearOptions(); } - _this3.props.onChange(newValues); + _this2.props.onChange(newValues); } }; @@ -270,25 +268,37 @@ function defaultChildren(props) { } module.exports = exports['default']; -},{"./Select":"react-select","./utils/stripDiacritics":10,"prop-types":undefined,"react":undefined}],2:[function(require,module,exports){ +},{"./Select":5,"./utils/stripDiacritics":11,"prop-types":undefined,"react":undefined}],2:[function(require,module,exports){ 'use strict'; var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +var _get = function get(_x2, _x3, _x4) { var _again = true; _function: while (_again) { var object = _x2, property = _x3, receiver = _x4; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x2 = parent; _x3 = property; _x4 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } -var _react = require('react'); +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } -var _react2 = _interopRequireDefault(_react); +function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -var _createReactClass = require('create-react-class'); +var _react = require('react'); -var _createReactClass2 = _interopRequireDefault(_createReactClass); +var _react2 = _interopRequireDefault(_react); var _Select = require('./Select'); var _Select2 = _interopRequireDefault(_Select); +var _Async = require('./Async'); + +var _Async2 = _interopRequireDefault(_Async); + +var _Creatable = require('./Creatable'); + +var _Creatable2 = _interopRequireDefault(_Creatable); + function reduce(obj) { var props = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; @@ -299,60 +309,78 @@ function reduce(obj) { }, props); } -var AsyncCreatable = (0, _createReactClass2['default'])({ - displayName: 'AsyncCreatableSelect', - - focus: function focus() { - this.select.focus(); - }, +var AsyncCreatableSelect = (function (_React$Component) { + _inherits(AsyncCreatableSelect, _React$Component); - render: function render() { - var _this = this; + function AsyncCreatableSelect() { + _classCallCheck(this, AsyncCreatableSelect); - return _react2['default'].createElement( - _Select2['default'].Async, - this.props, - function (asyncProps) { - return _react2['default'].createElement( - _Select2['default'].Creatable, - _this.props, - function (creatableProps) { - return _react2['default'].createElement(_Select2['default'], _extends({}, reduce(asyncProps, reduce(creatableProps, {})), { - onInputChange: function (input) { - creatableProps.onInputChange(input); - return asyncProps.onInputChange(input); - }, - ref: function (ref) { - _this.select = ref; - creatableProps.ref(ref); - asyncProps.ref(ref); - } - })); - } - ); - } - ); + _get(Object.getPrototypeOf(AsyncCreatableSelect.prototype), 'constructor', this).apply(this, arguments); } -}); -module.exports = AsyncCreatable; + _createClass(AsyncCreatableSelect, [{ + key: 'focus', + value: function focus() { + this.select.focus(); + } + }, { + key: 'render', + value: function render() { + var _this = this; + + return _react2['default'].createElement( + _Async2['default'], + this.props, + function (asyncProps) { + return _react2['default'].createElement( + _Creatable2['default'], + _this.props, + function (creatableProps) { + return _react2['default'].createElement(_Select2['default'], _extends({}, reduce(asyncProps, reduce(creatableProps, {})), { + onInputChange: function (input) { + creatableProps.onInputChange(input); + return asyncProps.onInputChange(input); + }, + ref: function (ref) { + _this.select = ref; + creatableProps.ref(ref); + asyncProps.ref(ref); + } + })); + } + ); + } + ); + } + }]); + + return AsyncCreatableSelect; +})(_react2['default'].Component); -},{"./Select":"react-select","create-react-class":undefined,"react":undefined}],3:[function(require,module,exports){ +; + +module.exports = AsyncCreatableSelect; + +},{"./Async":1,"./Creatable":3,"./Select":5,"react":undefined}],3:[function(require,module,exports){ 'use strict'; var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } -var _react = require('react'); +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } -var _react2 = _interopRequireDefault(_react); +function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -var _createReactClass = require('create-react-class'); +var _react = require('react'); -var _createReactClass2 = _interopRequireDefault(_createReactClass); +var _react2 = _interopRequireDefault(_react); var _propTypes = require('prop-types'); @@ -370,249 +398,210 @@ var _utilsDefaultMenuRenderer = require('./utils/defaultMenuRenderer'); var _utilsDefaultMenuRenderer2 = _interopRequireDefault(_utilsDefaultMenuRenderer); -var Creatable = (0, _createReactClass2['default'])({ - displayName: 'CreatableSelect', - - propTypes: { - // Child function responsible for creating the inner Select component - // This component can be used to compose HOCs (eg Creatable and Async) - // (props: Object): PropTypes.element - children: _propTypes2['default'].func, - - // See Select.propTypes.filterOptions - filterOptions: _propTypes2['default'].any, - - // Searches for any matching option within the set of options. - // This function prevents duplicate options from being created. - // ({ option: Object, options: Array, labelKey: string, valueKey: string }): boolean - isOptionUnique: _propTypes2['default'].func, - - // Determines if the current input text represents a valid option. - // ({ label: string }): boolean - isValidNewOption: _propTypes2['default'].func, - - // See Select.propTypes.menuRenderer - menuRenderer: _propTypes2['default'].any, - - // Factory to create new option. - // ({ label: string, labelKey: string, valueKey: string }): Object - newOptionCreator: _propTypes2['default'].func, - - // input change handler: function (inputValue) {} - onInputChange: _propTypes2['default'].func, - - // input keyDown handler: function (event) {} - onInputKeyDown: _propTypes2['default'].func, - - // new option click handler: function (option) {} - onNewOptionClick: _propTypes2['default'].func, - - // See Select.propTypes.options - options: _propTypes2['default'].array, - - // Creates prompt/placeholder option text. - // (filterText: string): string - promptTextCreator: _propTypes2['default'].func, - - // Decides if a keyDown event (eg its `keyCode`) should result in the creation of a new option. - shouldKeyDownEventCreateNewOption: _propTypes2['default'].func - }, - - // Default prop methods - statics: { - isOptionUnique: isOptionUnique, - isValidNewOption: isValidNewOption, - newOptionCreator: newOptionCreator, - promptTextCreator: promptTextCreator, - shouldKeyDownEventCreateNewOption: shouldKeyDownEventCreateNewOption - }, - - getDefaultProps: function getDefaultProps() { - return { - filterOptions: _utilsDefaultFilterOptions2['default'], - isOptionUnique: isOptionUnique, - isValidNewOption: isValidNewOption, - menuRenderer: _utilsDefaultMenuRenderer2['default'], - newOptionCreator: newOptionCreator, - promptTextCreator: promptTextCreator, - shouldKeyDownEventCreateNewOption: shouldKeyDownEventCreateNewOption - }; - }, - - createNewOption: function createNewOption() { - var _props = this.props; - var isValidNewOption = _props.isValidNewOption; - var newOptionCreator = _props.newOptionCreator; - var onNewOptionClick = _props.onNewOptionClick; - var _props$options = _props.options; - var options = _props$options === undefined ? [] : _props$options; - var shouldKeyDownEventCreateNewOption = _props.shouldKeyDownEventCreateNewOption; - - if (isValidNewOption({ label: this.inputValue })) { - var option = newOptionCreator({ label: this.inputValue, labelKey: this.labelKey, valueKey: this.valueKey }); - var _isOptionUnique = this.isOptionUnique({ option: option }); - - // Don't add the same option twice. - if (_isOptionUnique) { - if (onNewOptionClick) { - onNewOptionClick(option); - } else { - options.unshift(option); - - this.select.selectValue(option); - } - } - } - }, +var CreatableSelect = (function (_React$Component) { + _inherits(CreatableSelect, _React$Component); - filterOptions: function filterOptions() { - var _props2 = this.props; - var filterOptions = _props2.filterOptions; - var isValidNewOption = _props2.isValidNewOption; - var options = _props2.options; - var promptTextCreator = _props2.promptTextCreator; + function CreatableSelect(props, context) { + _classCallCheck(this, CreatableSelect); - // TRICKY Check currently selected options as well. - // Don't display a create-prompt for a value that's selected. - // This covers async edge-cases where a newly-created Option isn't yet in the async-loaded array. - var excludeOptions = arguments[2] || []; + _get(Object.getPrototypeOf(CreatableSelect.prototype), 'constructor', this).call(this, props, context); - var filteredOptions = filterOptions.apply(undefined, arguments) || []; + this.filterOptions = this.filterOptions.bind(this); + this.menuRenderer = this.menuRenderer.bind(this); + this.onInputKeyDown = this.onInputKeyDown.bind(this); + this.onInputChange = this.onInputChange.bind(this); + this.onOptionSelect = this.onOptionSelect.bind(this); + } - if (isValidNewOption({ label: this.inputValue })) { - var _newOptionCreator = this.props.newOptionCreator; + _createClass(CreatableSelect, [{ + key: 'createNewOption', + value: function createNewOption() { + var _props = this.props; + var isValidNewOption = _props.isValidNewOption; + var newOptionCreator = _props.newOptionCreator; + var onNewOptionClick = _props.onNewOptionClick; + var _props$options = _props.options; + var options = _props$options === undefined ? [] : _props$options; + var shouldKeyDownEventCreateNewOption = _props.shouldKeyDownEventCreateNewOption; + + if (isValidNewOption({ label: this.inputValue })) { + var option = newOptionCreator({ label: this.inputValue, labelKey: this.labelKey, valueKey: this.valueKey }); + var _isOptionUnique = this.isOptionUnique({ option: option }); + + // Don't add the same option twice. + if (_isOptionUnique) { + if (onNewOptionClick) { + onNewOptionClick(option); + } else { + options.unshift(option); + + this.select.selectValue(option); + } + } + } + } + }, { + key: 'filterOptions', + value: function filterOptions() { + var _props2 = this.props; + var filterOptions = _props2.filterOptions; + var isValidNewOption = _props2.isValidNewOption; + var options = _props2.options; + var promptTextCreator = _props2.promptTextCreator; - var option = _newOptionCreator({ - label: this.inputValue, - labelKey: this.labelKey, - valueKey: this.valueKey - }); + // TRICKY Check currently selected options as well. + // Don't display a create-prompt for a value that's selected. + // This covers async edge-cases where a newly-created Option isn't yet in the async-loaded array. + var excludeOptions = arguments[2] || []; - // TRICKY Compare to all options (not just filtered options) in case option has already been selected). - // For multi-selects, this would remove it from the filtered list. - var _isOptionUnique2 = this.isOptionUnique({ - option: option, - options: excludeOptions.concat(filteredOptions) - }); + var filteredOptions = filterOptions.apply(undefined, arguments) || []; - if (_isOptionUnique2) { - var _prompt = promptTextCreator(this.inputValue); + if (isValidNewOption({ label: this.inputValue })) { + var _newOptionCreator = this.props.newOptionCreator; - this._createPlaceholderOption = _newOptionCreator({ - label: _prompt, + var option = _newOptionCreator({ + label: this.inputValue, labelKey: this.labelKey, valueKey: this.valueKey }); - filteredOptions.unshift(this._createPlaceholderOption); - } - } - - return filteredOptions; - }, + // TRICKY Compare to all options (not just filtered options) in case option has already been selected). + // For multi-selects, this would remove it from the filtered list. + var _isOptionUnique2 = this.isOptionUnique({ + option: option, + options: excludeOptions.concat(filteredOptions) + }); - isOptionUnique: function isOptionUnique(_ref2) { - var option = _ref2.option; - var options = _ref2.options; - var isOptionUnique = this.props.isOptionUnique; + if (_isOptionUnique2) { + var _prompt = promptTextCreator(this.inputValue); - options = options || this.select.filterOptions(); + this._createPlaceholderOption = _newOptionCreator({ + label: _prompt, + labelKey: this.labelKey, + valueKey: this.valueKey + }); - return isOptionUnique({ - labelKey: this.labelKey, - option: option, - options: options, - valueKey: this.valueKey - }); - }, + filteredOptions.unshift(this._createPlaceholderOption); + } + } - menuRenderer: function menuRenderer(params) { - var menuRenderer = this.props.menuRenderer; + return filteredOptions; + } + }, { + key: 'isOptionUnique', + value: function isOptionUnique(_ref2) { + var option = _ref2.option; + var options = _ref2.options; + var isOptionUnique = this.props.isOptionUnique; - return menuRenderer(_extends({}, params, { - onSelect: this.onOptionSelect, - selectValue: this.onOptionSelect - })); - }, + options = options || this.select.filterOptions(); - onInputChange: function onInputChange(input) { - var onInputChange = this.props.onInputChange; + return isOptionUnique({ + labelKey: this.labelKey, + option: option, + options: options, + valueKey: this.valueKey + }); + } + }, { + key: 'menuRenderer', + value: function menuRenderer(params) { + var menuRenderer = this.props.menuRenderer; - if (onInputChange) { - onInputChange(input); + return menuRenderer(_extends({}, params, { + onSelect: this.onOptionSelect, + selectValue: this.onOptionSelect + })); } + }, { + key: 'onInputChange', + value: function onInputChange(input) { + var onInputChange = this.props.onInputChange; - // This value may be needed in between Select mounts (when this.select is null) - this.inputValue = input; - }, + if (onInputChange) { + onInputChange(input); + } - onInputKeyDown: function onInputKeyDown(event) { - var _props3 = this.props; - var shouldKeyDownEventCreateNewOption = _props3.shouldKeyDownEventCreateNewOption; - var onInputKeyDown = _props3.onInputKeyDown; + // This value may be needed in between Select mounts (when this.select is null) + this.inputValue = input; + } + }, { + key: 'onInputKeyDown', + value: function onInputKeyDown(event) { + var _props3 = this.props; + var shouldKeyDownEventCreateNewOption = _props3.shouldKeyDownEventCreateNewOption; + var onInputKeyDown = _props3.onInputKeyDown; - var focusedOption = this.select.getFocusedOption(); + var focusedOption = this.select.getFocusedOption(); - if (focusedOption && focusedOption === this._createPlaceholderOption && shouldKeyDownEventCreateNewOption({ keyCode: event.keyCode })) { - this.createNewOption(); + if (focusedOption && focusedOption === this._createPlaceholderOption && shouldKeyDownEventCreateNewOption({ keyCode: event.keyCode })) { + this.createNewOption(); - // Prevent decorated Select from doing anything additional with this keyDown event - event.preventDefault(); - } else if (onInputKeyDown) { - onInputKeyDown(event); + // Prevent decorated Select from doing anything additional with this keyDown event + event.preventDefault(); + } else if (onInputKeyDown) { + onInputKeyDown(event); + } } - }, - - onOptionSelect: function onOptionSelect(option, event) { - if (option === this._createPlaceholderOption) { - this.createNewOption(); - } else { - this.select.selectValue(option); + }, { + key: 'onOptionSelect', + value: function onOptionSelect(option, event) { + if (option === this._createPlaceholderOption) { + this.createNewOption(); + } else { + this.select.selectValue(option); + } + } + }, { + key: 'focus', + value: function focus() { + this.select.focus(); } - }, + }, { + key: 'render', + value: function render() { + var _this = this; - focus: function focus() { - this.select.focus(); - }, + var _props4 = this.props; + var newOptionCreator = _props4.newOptionCreator; + var shouldKeyDownEventCreateNewOption = _props4.shouldKeyDownEventCreateNewOption; - render: function render() { - var _this = this; + var restProps = _objectWithoutProperties(_props4, ['newOptionCreator', 'shouldKeyDownEventCreateNewOption']); - var _props4 = this.props; - var newOptionCreator = _props4.newOptionCreator; - var shouldKeyDownEventCreateNewOption = _props4.shouldKeyDownEventCreateNewOption; + var children = this.props.children; - var restProps = _objectWithoutProperties(_props4, ['newOptionCreator', 'shouldKeyDownEventCreateNewOption']); + // We can't use destructuring default values to set the children, + // because it won't apply work if `children` is null. A falsy check is + // more reliable in real world use-cases. + if (!children) { + children = defaultChildren; + } - var children = this.props.children; + var props = _extends({}, restProps, { + allowCreate: true, + filterOptions: this.filterOptions, + menuRenderer: this.menuRenderer, + onInputChange: this.onInputChange, + onInputKeyDown: this.onInputKeyDown, + ref: function ref(_ref) { + _this.select = _ref; - // We can't use destructuring default values to set the children, - // because it won't apply work if `children` is null. A falsy check is - // more reliable in real world use-cases. - if (!children) { - children = defaultChildren; - } + // These values may be needed in between Select mounts (when this.select is null) + if (_ref) { + _this.labelKey = _ref.props.labelKey; + _this.valueKey = _ref.props.valueKey; + } + } + }); - var props = _extends({}, restProps, { - allowCreate: true, - filterOptions: this.filterOptions, - menuRenderer: this.menuRenderer, - onInputChange: this.onInputChange, - onInputKeyDown: this.onInputKeyDown, - ref: function ref(_ref) { - _this.select = _ref; + return children(props); + } + }]); - // These values may be needed in between Select mounts (when this.select is null) - if (_ref) { - _this.labelKey = _ref.props.labelKey; - _this.valueKey = _ref.props.valueKey; - } - } - }); + return CreatableSelect; +})(_react2['default'].Component); - return children(props); - } -}); +; function defaultChildren(props) { return _react2['default'].createElement(_Select2['default'], props); @@ -665,139 +654,86 @@ function shouldKeyDownEventCreateNewOption(_ref6) { return false; }; -module.exports = Creatable; +// Default prop methods +CreatableSelect.isOptionUnique = isOptionUnique; +CreatableSelect.isValidNewOption = isValidNewOption; +CreatableSelect.newOptionCreator = newOptionCreator; +CreatableSelect.promptTextCreator = promptTextCreator; +CreatableSelect.shouldKeyDownEventCreateNewOption = shouldKeyDownEventCreateNewOption; + +CreatableSelect.defaultProps = { + filterOptions: _utilsDefaultFilterOptions2['default'], + isOptionUnique: isOptionUnique, + isValidNewOption: isValidNewOption, + menuRenderer: _utilsDefaultMenuRenderer2['default'], + newOptionCreator: newOptionCreator, + promptTextCreator: promptTextCreator, + shouldKeyDownEventCreateNewOption: shouldKeyDownEventCreateNewOption +}; -},{"./Select":"react-select","./utils/defaultFilterOptions":8,"./utils/defaultMenuRenderer":9,"create-react-class":undefined,"prop-types":undefined,"react":undefined}],4:[function(require,module,exports){ -'use strict'; +CreatableSelect.propTypes = { + // Child function responsible for creating the inner Select component + // This component can be used to compose HOCs (eg Creatable and Async) + // (props: Object): PropTypes.element + children: _propTypes2['default'].func, -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + // See Select.propTypes.filterOptions + filterOptions: _propTypes2['default'].any, -var _react = require('react'); + // Searches for any matching option within the set of options. + // This function prevents duplicate options from being created. + // ({ option: Object, options: Array, labelKey: string, valueKey: string }): boolean + isOptionUnique: _propTypes2['default'].func, -var _react2 = _interopRequireDefault(_react); + // Determines if the current input text represents a valid option. + // ({ label: string }): boolean + isValidNewOption: _propTypes2['default'].func, -var _createReactClass = require('create-react-class'); + // See Select.propTypes.menuRenderer + menuRenderer: _propTypes2['default'].any, -var _createReactClass2 = _interopRequireDefault(_createReactClass); + // Factory to create new option. + // ({ label: string, labelKey: string, valueKey: string }): Object + newOptionCreator: _propTypes2['default'].func, -var _propTypes = require('prop-types'); + // input change handler: function (inputValue) {} + onInputChange: _propTypes2['default'].func, -var _propTypes2 = _interopRequireDefault(_propTypes); + // input keyDown handler: function (event) {} + onInputKeyDown: _propTypes2['default'].func, -var _classnames = require('classnames'); + // new option click handler: function (option) {} + onNewOptionClick: _propTypes2['default'].func, -var _classnames2 = _interopRequireDefault(_classnames); + // See Select.propTypes.options + options: _propTypes2['default'].array, -var Option = (0, _createReactClass2['default'])({ - propTypes: { - children: _propTypes2['default'].node, - className: _propTypes2['default'].string, // className (based on mouse position) - instancePrefix: _propTypes2['default'].string.isRequired, // unique prefix for the ids (used for aria) - isDisabled: _propTypes2['default'].bool, // the option is disabled - isFocused: _propTypes2['default'].bool, // the option is focused - isSelected: _propTypes2['default'].bool, // the option is selected - onFocus: _propTypes2['default'].func, // method to handle mouseEnter on option element - onSelect: _propTypes2['default'].func, // method to handle click on option element - onUnfocus: _propTypes2['default'].func, // method to handle mouseLeave on option element - option: _propTypes2['default'].object.isRequired, // object that is base for that option - optionIndex: _propTypes2['default'].number }, - // index of the option, used to generate unique ids for aria - blockEvent: function blockEvent(event) { - event.preventDefault(); - event.stopPropagation(); - if (event.target.tagName !== 'A' || !('href' in event.target)) { - return; - } - if (event.target.target) { - window.open(event.target.href, event.target.target); - } else { - window.location.href = event.target.href; - } - }, - - handleMouseDown: function handleMouseDown(event) { - event.preventDefault(); - event.stopPropagation(); - this.props.onSelect(this.props.option, event); - }, - - handleMouseEnter: function handleMouseEnter(event) { - this.onFocus(event); - }, - - handleMouseMove: function handleMouseMove(event) { - this.onFocus(event); - }, - - handleTouchEnd: function handleTouchEnd(event) { - // Check if the view is being dragged, In this case - // we don't want to fire the click event (because the user only wants to scroll) - if (this.dragging) return; - - this.handleMouseDown(event); - }, - - handleTouchMove: function handleTouchMove(event) { - // Set a flag that the view is being dragged - this.dragging = true; - }, - - handleTouchStart: function handleTouchStart(event) { - // Set a flag that the view is not being dragged - this.dragging = false; - }, - - onFocus: function onFocus(event) { - if (!this.props.isFocused) { - this.props.onFocus(this.props.option, event); - } - }, - render: function render() { - var _props = this.props; - var option = _props.option; - var instancePrefix = _props.instancePrefix; - var optionIndex = _props.optionIndex; - - var className = (0, _classnames2['default'])(this.props.className, option.className); - - return option.disabled ? _react2['default'].createElement( - 'div', - { className: className, - onMouseDown: this.blockEvent, - onClick: this.blockEvent }, - this.props.children - ) : _react2['default'].createElement( - 'div', - { className: className, - style: option.style, - role: 'option', - onMouseDown: this.handleMouseDown, - onMouseEnter: this.handleMouseEnter, - onMouseMove: this.handleMouseMove, - onTouchStart: this.handleTouchStart, - onTouchMove: this.handleTouchMove, - onTouchEnd: this.handleTouchEnd, - id: instancePrefix + '-option-' + optionIndex, - title: option.title }, - this.props.children - ); - } -}); + // Creates prompt/placeholder option text. + // (filterText: string): string + promptTextCreator: _propTypes2['default'].func, -module.exports = Option; + // Decides if a keyDown event (eg its `keyCode`) should result in the creation of a new option. + shouldKeyDownEventCreateNewOption: _propTypes2['default'].func +}; + +module.exports = CreatableSelect; -},{"classnames":undefined,"create-react-class":undefined,"prop-types":undefined,"react":undefined}],5:[function(require,module,exports){ +},{"./Select":5,"./utils/defaultFilterOptions":9,"./utils/defaultMenuRenderer":10,"prop-types":undefined,"react":undefined}],4:[function(require,module,exports){ 'use strict'; +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } -var _react = require('react'); +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } -var _react2 = _interopRequireDefault(_react); +function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -var _createReactClass = require('create-react-class'); +var _react = require('react'); -var _createReactClass2 = _interopRequireDefault(_createReactClass); +var _react2 = _interopRequireDefault(_react); var _propTypes = require('prop-types'); @@ -807,299 +743,168 @@ var _classnames = require('classnames'); var _classnames2 = _interopRequireDefault(_classnames); -var Value = (0, _createReactClass2['default'])({ +var Option = (function (_React$Component) { + _inherits(Option, _React$Component); - displayName: 'Value', + function Option(props) { + _classCallCheck(this, Option); - propTypes: { - children: _propTypes2['default'].node, - disabled: _propTypes2['default'].bool, // disabled prop passed to ReactSelect - id: _propTypes2['default'].string, // Unique id for the value - used for aria - onClick: _propTypes2['default'].func, // method to handle click on value label - onRemove: _propTypes2['default'].func, // method to handle removal of the value - value: _propTypes2['default'].object.isRequired }, + _get(Object.getPrototypeOf(Option.prototype), 'constructor', this).call(this, props); - // the option object for this value - handleMouseDown: function handleMouseDown(event) { - if (event.type === 'mousedown' && event.button !== 0) { - return; - } - if (this.props.onClick) { + this.handleMouseDown = this.handleMouseDown.bind(this); + this.handleMouseEnter = this.handleMouseEnter.bind(this); + this.handleMouseMove = this.handleMouseMove.bind(this); + this.handleTouchStart = this.handleTouchStart.bind(this); + this.onFocus = this.onFocus.bind(this); + } + + _createClass(Option, [{ + key: 'blockEvent', + value: function blockEvent(event) { + event.preventDefault(); event.stopPropagation(); - this.props.onClick(this.props.value, event); - return; + if (event.target.tagName !== 'A' || !('href' in event.target)) { + return; + } + if (event.target.target) { + window.open(event.target.href, event.target.target); + } else { + window.location.href = event.target.href; + } } - if (this.props.value.href) { + }, { + key: 'handleMouseDown', + value: function handleMouseDown(event) { + event.preventDefault(); event.stopPropagation(); + this.props.onSelect(this.props.option, event); } - }, - - onRemove: function onRemove(event) { - event.preventDefault(); - event.stopPropagation(); - this.props.onRemove(this.props.value); - }, - - handleTouchEndRemove: function handleTouchEndRemove(event) { - // Check if the view is being dragged, In this case - // we don't want to fire the click event (because the user only wants to scroll) - if (this.dragging) return; + }, { + key: 'handleMouseEnter', + value: function handleMouseEnter(event) { + this.onFocus(event); + } + }, { + key: 'handleMouseMove', + value: function handleMouseMove(event) { + this.onFocus(event); + } + }, { + key: 'handleTouchEnd', + value: function handleTouchEnd(event) { + // Check if the view is being dragged, In this case + // we don't want to fire the click event (because the user only wants to scroll) + if (this.dragging) return; - // Fire the mouse events - this.onRemove(event); - }, + this.handleMouseDown(event); + } + }, { + key: 'handleTouchMove', + value: function handleTouchMove(event) { + // Set a flag that the view is being dragged + this.dragging = true; + } + }, { + key: 'handleTouchStart', + value: function handleTouchStart(event) { + // Set a flag that the view is not being dragged + this.dragging = false; + } + }, { + key: 'onFocus', + value: function onFocus(event) { + if (!this.props.isFocused) { + this.props.onFocus(this.props.option, event); + } + } + }, { + key: 'render', + value: function render() { + var _props = this.props; + var option = _props.option; + var instancePrefix = _props.instancePrefix; + var optionIndex = _props.optionIndex; - handleTouchMove: function handleTouchMove(event) { - // Set a flag that the view is being dragged - this.dragging = true; - }, + var className = (0, _classnames2['default'])(this.props.className, option.className); - handleTouchStart: function handleTouchStart(event) { - // Set a flag that the view is not being dragged - this.dragging = false; - }, + return option.disabled ? _react2['default'].createElement( + 'div', + { className: className, + onMouseDown: this.blockEvent, + onClick: this.blockEvent }, + this.props.children + ) : _react2['default'].createElement( + 'div', + { className: className, + style: option.style, + role: 'option', + onMouseDown: this.handleMouseDown, + onMouseEnter: this.handleMouseEnter, + onMouseMove: this.handleMouseMove, + onTouchStart: this.handleTouchStart, + onTouchMove: this.handleTouchMove, + onTouchEnd: this.handleTouchEnd, + id: instancePrefix + '-option-' + optionIndex, + title: option.title }, + this.props.children + ); + } + }]); - renderRemoveIcon: function renderRemoveIcon() { - if (this.props.disabled || !this.props.onRemove) return; - return _react2['default'].createElement( - 'span', - { className: 'Select-value-icon', - 'aria-hidden': 'true', - onMouseDown: this.onRemove, - onTouchEnd: this.handleTouchEndRemove, - onTouchStart: this.handleTouchStart, - onTouchMove: this.handleTouchMove }, - '×' - ); - }, - - renderLabel: function renderLabel() { - var className = 'Select-value-label'; - return this.props.onClick || this.props.value.href ? _react2['default'].createElement( - 'a', - { className: className, href: this.props.value.href, target: this.props.value.target, onMouseDown: this.handleMouseDown, onTouchEnd: this.handleMouseDown }, - this.props.children - ) : _react2['default'].createElement( - 'span', - { className: className, role: 'option', 'aria-selected': 'true', id: this.props.id }, - this.props.children - ); - }, + return Option; +})(_react2['default'].Component); - render: function render() { - return _react2['default'].createElement( - 'div', - { className: (0, _classnames2['default'])('Select-value', this.props.value.className), - style: this.props.value.style, - title: this.props.value.title - }, - this.renderRemoveIcon(), - this.renderLabel() - ); - } +; -}); +Option.propTypes = { + children: _propTypes2['default'].node, + className: _propTypes2['default'].string, // className (based on mouse position) + instancePrefix: _propTypes2['default'].string.isRequired, // unique prefix for the ids (used for aria) + isDisabled: _propTypes2['default'].bool, // the option is disabled + isFocused: _propTypes2['default'].bool, // the option is focused + isSelected: _propTypes2['default'].bool, // the option is selected + onFocus: _propTypes2['default'].func, // method to handle mouseEnter on option element + onSelect: _propTypes2['default'].func, // method to handle click on option element + onUnfocus: _propTypes2['default'].func, // method to handle mouseLeave on option element + option: _propTypes2['default'].object.isRequired, // object that is base for that option + optionIndex: _propTypes2['default'].number }; + +// index of the option, used to generate unique ids for aria +module.exports = Option; -module.exports = Value; +},{"classnames":undefined,"prop-types":undefined,"react":undefined}],5:[function(require,module,exports){ +/*! + Copyright (c) 2016 Jed Watson. + Licensed under the MIT License (MIT), see + http://jedwatson.github.io/react-select +*/ -},{"classnames":undefined,"create-react-class":undefined,"prop-types":undefined,"react":undefined}],6:[function(require,module,exports){ -"use strict"; +'use strict'; -Object.defineProperty(exports, "__esModule", { +Object.defineProperty(exports, '__esModule', { value: true }); -exports["default"] = arrowRenderer; -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } - -var _react = require('react'); +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); -var _react2 = _interopRequireDefault(_react); +var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; -function arrowRenderer(_ref) { - var onMouseDown = _ref.onMouseDown; +var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; - return _react2["default"].createElement("span", { - className: "Select-arrow", - onMouseDown: onMouseDown - }); -} +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } -; -module.exports = exports["default"]; +function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } -},{"react":undefined}],7:[function(require,module,exports){ -'use strict'; +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } -Object.defineProperty(exports, '__esModule', { - value: true -}); -exports['default'] = clearRenderer; +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } +function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } var _react = require('react'); var _react2 = _interopRequireDefault(_react); -function clearRenderer() { - return _react2['default'].createElement('span', { - className: 'Select-clear', - dangerouslySetInnerHTML: { __html: '×' } - }); -} - -; -module.exports = exports['default']; - -},{"react":undefined}],8:[function(require,module,exports){ -'use strict'; - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } - -var _stripDiacritics = require('./stripDiacritics'); - -var _stripDiacritics2 = _interopRequireDefault(_stripDiacritics); - -function filterOptions(options, filterValue, excludeOptions, props) { - var _this = this; - - if (props.ignoreAccents) { - filterValue = (0, _stripDiacritics2['default'])(filterValue); - } - - if (props.ignoreCase) { - filterValue = filterValue.toLowerCase(); - } - - if (excludeOptions) excludeOptions = excludeOptions.map(function (i) { - return i[props.valueKey]; - }); - - return options.filter(function (option) { - if (excludeOptions && excludeOptions.indexOf(option[props.valueKey]) > -1) return false; - if (props.filterOption) return props.filterOption.call(_this, option, filterValue); - if (!filterValue) return true; - var valueTest = String(option[props.valueKey]); - var labelTest = String(option[props.labelKey]); - if (props.ignoreAccents) { - if (props.matchProp !== 'label') valueTest = (0, _stripDiacritics2['default'])(valueTest); - if (props.matchProp !== 'value') labelTest = (0, _stripDiacritics2['default'])(labelTest); - } - if (props.ignoreCase) { - if (props.matchProp !== 'label') valueTest = valueTest.toLowerCase(); - if (props.matchProp !== 'value') labelTest = labelTest.toLowerCase(); - } - return props.matchPos === 'start' ? props.matchProp !== 'label' && valueTest.substr(0, filterValue.length) === filterValue || props.matchProp !== 'value' && labelTest.substr(0, filterValue.length) === filterValue : props.matchProp !== 'label' && valueTest.indexOf(filterValue) >= 0 || props.matchProp !== 'value' && labelTest.indexOf(filterValue) >= 0; - }); -} - -module.exports = filterOptions; - -},{"./stripDiacritics":10}],9:[function(require,module,exports){ -'use strict'; - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } - -var _classnames = require('classnames'); - -var _classnames2 = _interopRequireDefault(_classnames); - -var _react = require('react'); - -var _react2 = _interopRequireDefault(_react); - -function menuRenderer(_ref) { - var focusedOption = _ref.focusedOption; - var instancePrefix = _ref.instancePrefix; - var labelKey = _ref.labelKey; - var onFocus = _ref.onFocus; - var onSelect = _ref.onSelect; - var optionClassName = _ref.optionClassName; - var optionComponent = _ref.optionComponent; - var optionRenderer = _ref.optionRenderer; - var options = _ref.options; - var valueArray = _ref.valueArray; - var valueKey = _ref.valueKey; - var onOptionRef = _ref.onOptionRef; - - var Option = optionComponent; - - return options.map(function (option, i) { - var isSelected = valueArray && valueArray.indexOf(option) > -1; - var isFocused = option === focusedOption; - var optionClass = (0, _classnames2['default'])(optionClassName, { - 'Select-option': true, - 'is-selected': isSelected, - 'is-focused': isFocused, - 'is-disabled': option.disabled - }); - - return _react2['default'].createElement( - Option, - { - className: optionClass, - instancePrefix: instancePrefix, - isDisabled: option.disabled, - isFocused: isFocused, - isSelected: isSelected, - key: 'option-' + i + '-' + option[valueKey], - onFocus: onFocus, - onSelect: onSelect, - option: option, - optionIndex: i, - ref: function (ref) { - onOptionRef(ref, isFocused); - } - }, - optionRenderer(option, i) - ); - }); -} - -module.exports = menuRenderer; - -},{"classnames":undefined,"react":undefined}],10:[function(require,module,exports){ -'use strict'; - -var map = [{ 'base': 'A', 'letters': /[\u0041\u24B6\uFF21\u00C0\u00C1\u00C2\u1EA6\u1EA4\u1EAA\u1EA8\u00C3\u0100\u0102\u1EB0\u1EAE\u1EB4\u1EB2\u0226\u01E0\u00C4\u01DE\u1EA2\u00C5\u01FA\u01CD\u0200\u0202\u1EA0\u1EAC\u1EB6\u1E00\u0104\u023A\u2C6F]/g }, { 'base': 'AA', 'letters': /[\uA732]/g }, { 'base': 'AE', 'letters': /[\u00C6\u01FC\u01E2]/g }, { 'base': 'AO', 'letters': /[\uA734]/g }, { 'base': 'AU', 'letters': /[\uA736]/g }, { 'base': 'AV', 'letters': /[\uA738\uA73A]/g }, { 'base': 'AY', 'letters': /[\uA73C]/g }, { 'base': 'B', 'letters': /[\u0042\u24B7\uFF22\u1E02\u1E04\u1E06\u0243\u0182\u0181]/g }, { 'base': 'C', 'letters': /[\u0043\u24B8\uFF23\u0106\u0108\u010A\u010C\u00C7\u1E08\u0187\u023B\uA73E]/g }, { 'base': 'D', 'letters': /[\u0044\u24B9\uFF24\u1E0A\u010E\u1E0C\u1E10\u1E12\u1E0E\u0110\u018B\u018A\u0189\uA779]/g }, { 'base': 'DZ', 'letters': /[\u01F1\u01C4]/g }, { 'base': 'Dz', 'letters': /[\u01F2\u01C5]/g }, { 'base': 'E', 'letters': /[\u0045\u24BA\uFF25\u00C8\u00C9\u00CA\u1EC0\u1EBE\u1EC4\u1EC2\u1EBC\u0112\u1E14\u1E16\u0114\u0116\u00CB\u1EBA\u011A\u0204\u0206\u1EB8\u1EC6\u0228\u1E1C\u0118\u1E18\u1E1A\u0190\u018E]/g }, { 'base': 'F', 'letters': /[\u0046\u24BB\uFF26\u1E1E\u0191\uA77B]/g }, { 'base': 'G', 'letters': /[\u0047\u24BC\uFF27\u01F4\u011C\u1E20\u011E\u0120\u01E6\u0122\u01E4\u0193\uA7A0\uA77D\uA77E]/g }, { 'base': 'H', 'letters': /[\u0048\u24BD\uFF28\u0124\u1E22\u1E26\u021E\u1E24\u1E28\u1E2A\u0126\u2C67\u2C75\uA78D]/g }, { 'base': 'I', 'letters': /[\u0049\u24BE\uFF29\u00CC\u00CD\u00CE\u0128\u012A\u012C\u0130\u00CF\u1E2E\u1EC8\u01CF\u0208\u020A\u1ECA\u012E\u1E2C\u0197]/g }, { 'base': 'J', 'letters': /[\u004A\u24BF\uFF2A\u0134\u0248]/g }, { 'base': 'K', 'letters': /[\u004B\u24C0\uFF2B\u1E30\u01E8\u1E32\u0136\u1E34\u0198\u2C69\uA740\uA742\uA744\uA7A2]/g }, { 'base': 'L', 'letters': /[\u004C\u24C1\uFF2C\u013F\u0139\u013D\u1E36\u1E38\u013B\u1E3C\u1E3A\u0141\u023D\u2C62\u2C60\uA748\uA746\uA780]/g }, { 'base': 'LJ', 'letters': /[\u01C7]/g }, { 'base': 'Lj', 'letters': /[\u01C8]/g }, { 'base': 'M', 'letters': /[\u004D\u24C2\uFF2D\u1E3E\u1E40\u1E42\u2C6E\u019C]/g }, { 'base': 'N', 'letters': /[\u004E\u24C3\uFF2E\u01F8\u0143\u00D1\u1E44\u0147\u1E46\u0145\u1E4A\u1E48\u0220\u019D\uA790\uA7A4]/g }, { 'base': 'NJ', 'letters': /[\u01CA]/g }, { 'base': 'Nj', 'letters': /[\u01CB]/g }, { 'base': 'O', 'letters': /[\u004F\u24C4\uFF2F\u00D2\u00D3\u00D4\u1ED2\u1ED0\u1ED6\u1ED4\u00D5\u1E4C\u022C\u1E4E\u014C\u1E50\u1E52\u014E\u022E\u0230\u00D6\u022A\u1ECE\u0150\u01D1\u020C\u020E\u01A0\u1EDC\u1EDA\u1EE0\u1EDE\u1EE2\u1ECC\u1ED8\u01EA\u01EC\u00D8\u01FE\u0186\u019F\uA74A\uA74C]/g }, { 'base': 'OI', 'letters': /[\u01A2]/g }, { 'base': 'OO', 'letters': /[\uA74E]/g }, { 'base': 'OU', 'letters': /[\u0222]/g }, { 'base': 'P', 'letters': /[\u0050\u24C5\uFF30\u1E54\u1E56\u01A4\u2C63\uA750\uA752\uA754]/g }, { 'base': 'Q', 'letters': /[\u0051\u24C6\uFF31\uA756\uA758\u024A]/g }, { 'base': 'R', 'letters': /[\u0052\u24C7\uFF32\u0154\u1E58\u0158\u0210\u0212\u1E5A\u1E5C\u0156\u1E5E\u024C\u2C64\uA75A\uA7A6\uA782]/g }, { 'base': 'S', 'letters': /[\u0053\u24C8\uFF33\u1E9E\u015A\u1E64\u015C\u1E60\u0160\u1E66\u1E62\u1E68\u0218\u015E\u2C7E\uA7A8\uA784]/g }, { 'base': 'T', 'letters': /[\u0054\u24C9\uFF34\u1E6A\u0164\u1E6C\u021A\u0162\u1E70\u1E6E\u0166\u01AC\u01AE\u023E\uA786]/g }, { 'base': 'TZ', 'letters': /[\uA728]/g }, { 'base': 'U', 'letters': /[\u0055\u24CA\uFF35\u00D9\u00DA\u00DB\u0168\u1E78\u016A\u1E7A\u016C\u00DC\u01DB\u01D7\u01D5\u01D9\u1EE6\u016E\u0170\u01D3\u0214\u0216\u01AF\u1EEA\u1EE8\u1EEE\u1EEC\u1EF0\u1EE4\u1E72\u0172\u1E76\u1E74\u0244]/g }, { 'base': 'V', 'letters': /[\u0056\u24CB\uFF36\u1E7C\u1E7E\u01B2\uA75E\u0245]/g }, { 'base': 'VY', 'letters': /[\uA760]/g }, { 'base': 'W', 'letters': /[\u0057\u24CC\uFF37\u1E80\u1E82\u0174\u1E86\u1E84\u1E88\u2C72]/g }, { 'base': 'X', 'letters': /[\u0058\u24CD\uFF38\u1E8A\u1E8C]/g }, { 'base': 'Y', 'letters': /[\u0059\u24CE\uFF39\u1EF2\u00DD\u0176\u1EF8\u0232\u1E8E\u0178\u1EF6\u1EF4\u01B3\u024E\u1EFE]/g }, { 'base': 'Z', 'letters': /[\u005A\u24CF\uFF3A\u0179\u1E90\u017B\u017D\u1E92\u1E94\u01B5\u0224\u2C7F\u2C6B\uA762]/g }, { 'base': 'a', 'letters': /[\u0061\u24D0\uFF41\u1E9A\u00E0\u00E1\u00E2\u1EA7\u1EA5\u1EAB\u1EA9\u00E3\u0101\u0103\u1EB1\u1EAF\u1EB5\u1EB3\u0227\u01E1\u00E4\u01DF\u1EA3\u00E5\u01FB\u01CE\u0201\u0203\u1EA1\u1EAD\u1EB7\u1E01\u0105\u2C65\u0250]/g }, { 'base': 'aa', 'letters': /[\uA733]/g }, { 'base': 'ae', 'letters': /[\u00E6\u01FD\u01E3]/g }, { 'base': 'ao', 'letters': /[\uA735]/g }, { 'base': 'au', 'letters': /[\uA737]/g }, { 'base': 'av', 'letters': /[\uA739\uA73B]/g }, { 'base': 'ay', 'letters': /[\uA73D]/g }, { 'base': 'b', 'letters': /[\u0062\u24D1\uFF42\u1E03\u1E05\u1E07\u0180\u0183\u0253]/g }, { 'base': 'c', 'letters': /[\u0063\u24D2\uFF43\u0107\u0109\u010B\u010D\u00E7\u1E09\u0188\u023C\uA73F\u2184]/g }, { 'base': 'd', 'letters': /[\u0064\u24D3\uFF44\u1E0B\u010F\u1E0D\u1E11\u1E13\u1E0F\u0111\u018C\u0256\u0257\uA77A]/g }, { 'base': 'dz', 'letters': /[\u01F3\u01C6]/g }, { 'base': 'e', 'letters': /[\u0065\u24D4\uFF45\u00E8\u00E9\u00EA\u1EC1\u1EBF\u1EC5\u1EC3\u1EBD\u0113\u1E15\u1E17\u0115\u0117\u00EB\u1EBB\u011B\u0205\u0207\u1EB9\u1EC7\u0229\u1E1D\u0119\u1E19\u1E1B\u0247\u025B\u01DD]/g }, { 'base': 'f', 'letters': /[\u0066\u24D5\uFF46\u1E1F\u0192\uA77C]/g }, { 'base': 'g', 'letters': /[\u0067\u24D6\uFF47\u01F5\u011D\u1E21\u011F\u0121\u01E7\u0123\u01E5\u0260\uA7A1\u1D79\uA77F]/g }, { 'base': 'h', 'letters': /[\u0068\u24D7\uFF48\u0125\u1E23\u1E27\u021F\u1E25\u1E29\u1E2B\u1E96\u0127\u2C68\u2C76\u0265]/g }, { 'base': 'hv', 'letters': /[\u0195]/g }, { 'base': 'i', 'letters': /[\u0069\u24D8\uFF49\u00EC\u00ED\u00EE\u0129\u012B\u012D\u00EF\u1E2F\u1EC9\u01D0\u0209\u020B\u1ECB\u012F\u1E2D\u0268\u0131]/g }, { 'base': 'j', 'letters': /[\u006A\u24D9\uFF4A\u0135\u01F0\u0249]/g }, { 'base': 'k', 'letters': /[\u006B\u24DA\uFF4B\u1E31\u01E9\u1E33\u0137\u1E35\u0199\u2C6A\uA741\uA743\uA745\uA7A3]/g }, { 'base': 'l', 'letters': /[\u006C\u24DB\uFF4C\u0140\u013A\u013E\u1E37\u1E39\u013C\u1E3D\u1E3B\u017F\u0142\u019A\u026B\u2C61\uA749\uA781\uA747]/g }, { 'base': 'lj', 'letters': /[\u01C9]/g }, { 'base': 'm', 'letters': /[\u006D\u24DC\uFF4D\u1E3F\u1E41\u1E43\u0271\u026F]/g }, { 'base': 'n', 'letters': /[\u006E\u24DD\uFF4E\u01F9\u0144\u00F1\u1E45\u0148\u1E47\u0146\u1E4B\u1E49\u019E\u0272\u0149\uA791\uA7A5]/g }, { 'base': 'nj', 'letters': /[\u01CC]/g }, { 'base': 'o', 'letters': /[\u006F\u24DE\uFF4F\u00F2\u00F3\u00F4\u1ED3\u1ED1\u1ED7\u1ED5\u00F5\u1E4D\u022D\u1E4F\u014D\u1E51\u1E53\u014F\u022F\u0231\u00F6\u022B\u1ECF\u0151\u01D2\u020D\u020F\u01A1\u1EDD\u1EDB\u1EE1\u1EDF\u1EE3\u1ECD\u1ED9\u01EB\u01ED\u00F8\u01FF\u0254\uA74B\uA74D\u0275]/g }, { 'base': 'oi', 'letters': /[\u01A3]/g }, { 'base': 'ou', 'letters': /[\u0223]/g }, { 'base': 'oo', 'letters': /[\uA74F]/g }, { 'base': 'p', 'letters': /[\u0070\u24DF\uFF50\u1E55\u1E57\u01A5\u1D7D\uA751\uA753\uA755]/g }, { 'base': 'q', 'letters': /[\u0071\u24E0\uFF51\u024B\uA757\uA759]/g }, { 'base': 'r', 'letters': /[\u0072\u24E1\uFF52\u0155\u1E59\u0159\u0211\u0213\u1E5B\u1E5D\u0157\u1E5F\u024D\u027D\uA75B\uA7A7\uA783]/g }, { 'base': 's', 'letters': /[\u0073\u24E2\uFF53\u00DF\u015B\u1E65\u015D\u1E61\u0161\u1E67\u1E63\u1E69\u0219\u015F\u023F\uA7A9\uA785\u1E9B]/g }, { 'base': 't', 'letters': /[\u0074\u24E3\uFF54\u1E6B\u1E97\u0165\u1E6D\u021B\u0163\u1E71\u1E6F\u0167\u01AD\u0288\u2C66\uA787]/g }, { 'base': 'tz', 'letters': /[\uA729]/g }, { 'base': 'u', 'letters': /[\u0075\u24E4\uFF55\u00F9\u00FA\u00FB\u0169\u1E79\u016B\u1E7B\u016D\u00FC\u01DC\u01D8\u01D6\u01DA\u1EE7\u016F\u0171\u01D4\u0215\u0217\u01B0\u1EEB\u1EE9\u1EEF\u1EED\u1EF1\u1EE5\u1E73\u0173\u1E77\u1E75\u0289]/g }, { 'base': 'v', 'letters': /[\u0076\u24E5\uFF56\u1E7D\u1E7F\u028B\uA75F\u028C]/g }, { 'base': 'vy', 'letters': /[\uA761]/g }, { 'base': 'w', 'letters': /[\u0077\u24E6\uFF57\u1E81\u1E83\u0175\u1E87\u1E85\u1E98\u1E89\u2C73]/g }, { 'base': 'x', 'letters': /[\u0078\u24E7\uFF58\u1E8B\u1E8D]/g }, { 'base': 'y', 'letters': /[\u0079\u24E8\uFF59\u1EF3\u00FD\u0177\u1EF9\u0233\u1E8F\u00FF\u1EF7\u1E99\u1EF5\u01B4\u024F\u1EFF]/g }, { 'base': 'z', 'letters': /[\u007A\u24E9\uFF5A\u017A\u1E91\u017C\u017E\u1E93\u1E95\u01B6\u0225\u0240\u2C6C\uA763]/g }]; - -module.exports = function stripDiacritics(str) { - for (var i = 0; i < map.length; i++) { - str = str.replace(map[i].letters, map[i].base); - } - return str; -}; - -},{}],"react-select":[function(require,module,exports){ -/*! - Copyright (c) 2016 Jed Watson. - Licensed under the MIT License (MIT), see - http://jedwatson.github.io/react-select -*/ - -'use strict'; - -Object.defineProperty(exports, '__esModule', { - value: true -}); - -var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } - -function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } - -function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } - -var _react = require('react'); - -var _react2 = _interopRequireDefault(_react); - -var _createReactClass = require('create-react-class'); - -var _createReactClass2 = _interopRequireDefault(_createReactClass); - var _propTypes = require('prop-types'); var _propTypes2 = _interopRequireDefault(_propTypes); @@ -1132,18 +937,6 @@ var _utilsDefaultClearRenderer = require('./utils/defaultClearRenderer'); var _utilsDefaultClearRenderer2 = _interopRequireDefault(_utilsDefaultClearRenderer); -var _Async = require('./Async'); - -var _Async2 = _interopRequireDefault(_Async); - -var _AsyncCreatable = require('./AsyncCreatable'); - -var _AsyncCreatable2 = _interopRequireDefault(_AsyncCreatable); - -var _Creatable = require('./Creatable'); - -var _Creatable2 = _interopRequireDefault(_Creatable); - var _Option = require('./Option'); var _Option2 = _interopRequireDefault(_Option); @@ -1169,1150 +962,1619 @@ var stringOrNode = _propTypes2['default'].oneOfType([_propTypes2['default'].stri var instanceId = 1; -var Select = (0, _createReactClass2['default'])({ - - displayName: 'Select', - - propTypes: { - addLabelText: _propTypes2['default'].string, // placeholder displayed when you want to add a label on a multi-value input - 'aria-describedby': _propTypes2['default'].string, // HTML ID(s) of element(s) that should be used to describe this input (for assistive tech) - 'aria-label': _propTypes2['default'].string, // Aria label (for assistive tech) - 'aria-labelledby': _propTypes2['default'].string, // HTML ID of an element that should be used as the label (for assistive tech) - arrowRenderer: _propTypes2['default'].func, // Create drop-down caret element - autoBlur: _propTypes2['default'].bool, // automatically blur the component when an option is selected - autofocus: _propTypes2['default'].bool, // autofocus the component on mount - autosize: _propTypes2['default'].bool, // whether to enable autosizing or not - backspaceRemoves: _propTypes2['default'].bool, // whether backspace removes an item if there is no text input - backspaceToRemoveMessage: _propTypes2['default'].string, // Message to use for screenreaders to press backspace to remove the current item - {label} is replaced with the item label - className: _propTypes2['default'].string, // className for the outer element - clearAllText: stringOrNode, // title for the "clear" control when multi: true - clearRenderer: _propTypes2['default'].func, // create clearable x element - clearValueText: stringOrNode, // title for the "clear" control - clearable: _propTypes2['default'].bool, // should it be possible to reset value - deleteRemoves: _propTypes2['default'].bool, // whether backspace removes an item if there is no text input - delimiter: _propTypes2['default'].string, // delimiter to use to join multiple values for the hidden field value - disabled: _propTypes2['default'].bool, // whether the Select is disabled or not - escapeClearsValue: _propTypes2['default'].bool, // whether escape clears the value when the menu is closed - filterOption: _propTypes2['default'].func, // method to filter a single option (option, filterString) - filterOptions: _propTypes2['default'].any, // boolean to enable default filtering or function to filter the options array ([options], filterString, [values]) - ignoreAccents: _propTypes2['default'].bool, // whether to strip diacritics when filtering - ignoreCase: _propTypes2['default'].bool, // whether to perform case-insensitive filtering - inputProps: _propTypes2['default'].object, // custom attributes for the Input - inputRenderer: _propTypes2['default'].func, // returns a custom input component - instanceId: _propTypes2['default'].string, // set the components instanceId - isLoading: _propTypes2['default'].bool, // whether the Select is loading externally or not (such as options being loaded) - joinValues: _propTypes2['default'].bool, // joins multiple values into a single form field with the delimiter (legacy mode) - labelKey: _propTypes2['default'].string, // path of the label value in option objects - matchPos: _propTypes2['default'].string, // (any|start) match the start or entire string when filtering - matchProp: _propTypes2['default'].string, // (any|label|value) which option property to filter on - menuBuffer: _propTypes2['default'].number, // optional buffer (in px) between the bottom of the viewport and the bottom of the menu - menuContainerStyle: _propTypes2['default'].object, // optional style to apply to the menu container - menuRenderer: _propTypes2['default'].func, // renders a custom menu with options - menuStyle: _propTypes2['default'].object, // optional style to apply to the menu - multi: _propTypes2['default'].bool, // multi-value input - name: _propTypes2['default'].string, // generates a hidden tag with this field name for html forms - noResultsText: stringOrNode, // placeholder displayed when there are no matching search results - onBlur: _propTypes2['default'].func, // onBlur handler: function (event) {} - onBlurResetsInput: _propTypes2['default'].bool, // whether input is cleared on blur - onChange: _propTypes2['default'].func, // onChange handler: function (newValue) {} - onClose: _propTypes2['default'].func, // fires when the menu is closed - onCloseResetsInput: _propTypes2['default'].bool, // whether input is cleared when menu is closed through the arrow - onFocus: _propTypes2['default'].func, // onFocus handler: function (event) {} - onInputChange: _propTypes2['default'].func, // onInputChange handler: function (inputValue) {} - onInputKeyDown: _propTypes2['default'].func, // input keyDown handler: function (event) {} - onMenuScrollToBottom: _propTypes2['default'].func, // fires when the menu is scrolled to the bottom; can be used to paginate options - onOpen: _propTypes2['default'].func, // fires when the menu is opened - onValueClick: _propTypes2['default'].func, // onClick handler for value labels: function (value, event) {} - openAfterFocus: _propTypes2['default'].bool, // boolean to enable opening dropdown when focused - openOnFocus: _propTypes2['default'].bool, // always open options menu on focus - optionClassName: _propTypes2['default'].string, // additional class(es) to apply to the