PageSourceSearch

https://www.genesispregnancyregistry.com/Assets/Registries/Website…/xTemplate/app.xtemplate.components.js

js genesispregnancyregistry.com collected 2026-10-04 02:37:52 UTC 28,104 bytes, 789 lines download raw bytes

1app.xtemplate.components = function () {
2
3    var LoadAppModel = Vue.component('app-modal', {
4        template: '#app-modal-template',
5        data: function () {
6			return {
7				state: this.$state
8			};
9        },
10        props: {
11            date: String
12        },
13        methods: {
14            closeModal: app.xtemplate.store.componentstore.closeModal
15        }
16    });
17
18    var LoadDays = Vue.component('day', {
19        template: '#day-template',
20        data: function () {
21			return {
22				state: this.$state
23			};
24        },
25        created: function () {
26            var start = moment().format('YYYY-MM-DD');
27            app.xtemplate.store.componentstore.setRangeStart(start);
28            app.xtemplate.store.componentstore.setRangeStart(start);
29            // this will update the range dates
30            this.state.viewCreated = 'DAY';
31
32            app.xtemplate.store.componentstore.startLoader();
33            app.xtemplate.store.componentstore.getEvents(start, start, function (status) {
34                app.xtemplate.store.componentstore.stopLoader();
35                console.log(status);
36                //if ( status === 'MERGED' ) this.state.events = events;
37            }.bind(this));
38
39
40        },
41        computed: {
42            events: function () {
43                //if ( !this.hasEvents ) return {};
44                return app.xtemplate.helpers.sortEvents(this.state.events[this.state.rangeStart]);
45            },
46            hasEvents: function () {
47                return this.state.events.hasOwnProperty(this.state.rangeStart);
48            }
49        }
50    });
51
52    var LoadSmallEvents = Vue.component('small-event', {
53        template: '#small-event-template',
54        data: function () {
55			return {
56				view: this.$state.view,
57				modal: this.$state.showModal
58			};
59        },
60        props: {
61            event: Object
62        },
63        computed: {
64            showContactTime: function () {
65                //return (this.view === "WEEK" || this.view === "DAY") && this.event.contactTime;
66                return (this.view === "DAY") && this.event.contactTime;
67            },
68            showNotes: function () {
69				return this.view === "DAY";
70            }
71		},
72		methods: {
73            initiatePopupDefault: function (patientKey, MileStoneKey, contactDateTime, action, status) {
74                var parsedDate = app.handelbar.helpers.dateFormatWithDay(contactDateTime);
75                AssignValuesforMilestoneReportPopup(patientKey, MileStoneKey, parsedDate, action, status);
76			}
77		}
78    });
79
80    var LoadWeeks = Vue.component('week', {
81        template: '#week-template',
82        data: function () {
83			return {
84				state: this.$state
85			};
86        },
87        created: function () {
88
89
90            var start = moment().startOf('week');
91
92
93            var range = app.xtemplate.helpers.genRange(start, 7);
94            app.xtemplate.store.componentstore.setRangeStart(range[0]);
95            app.xtemplate.store.componentstore.setRange(range);
96            app.xtemplate.store.componentstore.setRangeEnd(range[range.length - 1]);
97
98
99            this.state.viewCreated = 'WEEK';
100
101            app.xtemplate.store.componentstore.startLoader();
102            app.xtemplate.store.componentstore.getEvents(range[0], range[range.length - 1], function (status) {
103                app.xtemplate.store.componentstore.stopLoader();
104                console.log(status);
105            }.bind(this));
106
107
108        },
109        computed: {
110            weekDays: function () {
111                var out = [];
112                var days = app.xtemplate.helpers.calcWeekDays(app.xtemplate.store.componentstore.daysShort, app.xtemplate.store.componentstore.startDay);
113
114                for (var i = 0; i < this.state.range.length; i++) {
115                    out.push({
116                        name: days[i],
117                        num: moment(this.state.range[i]).format('DD'),
118                        today: moment().isSame(this.state.range[i], 'day')
119                    });
120                }
121                return out;
122            }
123        }
124    });
125
126	var LoadWeekDay = Vue.component('week-day', {
127		template: '#week-day-template',
128		data: function () {
129			return {
130				state: this.$state,
131				hasEvents: false,
132                events: {},
133                morningEvents: 0,
134                afternoonEvents: 0,
135                eveningEvents: 0,
136                nightEvents: 0,
137				more: {
138					'Morning': 0,
139					'Evening': 0,
140					'Afternoon': 0,
141					'Night': 0
142                }
143			};
144		},
145		props: {
146			date: String
147		},
148		created: function () {
149			this.hasEvents = this.state.events.hasOwnProperty(this.date);
150			// no need to execute further
151			if (!this.hasEvents)
152				return;
153
154			// sort events based on time preference
155            this.events = app.xtemplate.helpers.sortEvents(this.state.events[this.date]);
156
157            // connect events together and discard all but 2
158            if (this.events.Morning.length > 2) {
159                this.morningEvents = this.events.Morning.length - 2;
160                this.events.Morning.splice(0, this.events.Morning.length - 2);
161            }
162
163            if (this.events.Afternoon.length > 2) {
164                this.afternoonEvents = this.events.Afternoon.length - 2;
165                this.events.Afternoon.splice(0, this.events.Afternoon.length - 2);
166            }
167
168            if (this.events.Evening.length > 2) {
169                this.eveningEvents = this.events.Evening.length - 2;
170                this.events.Evening.splice(0, this.events.Evening.length - 2);
171            }
172
173            if (this.events.Night.length > 2) {
174                this.nightEvents = this.events.Night.length - 2;
175                this.events.Night.splice(0, this.events.Night.length - 2);
176            }
177
178			//for ( tp in this.events ) {
179			//  if ( this.events[tp].length > 3 )
180			//}
181
182			// if (this.allEvents.length > 2) {
183			//   this.moreEvents = this.allEvents.length - 2;
184			//   this.allEvents.splice(0, this.allEvents.length - 2);
185			// }
186		},
187		computed: {
188
189			classList: function () {
190
191                var date = moment(this.date);
192                var now = moment().startOf('day');
193
194                return {
195                    today: this.today,
196                    su: date.day() === 0 || date.day() === 6,
197                    past: date.isBefore(now),
198                    'first-day': date.isSame(this.state.range[0])
199                };
200
201			},
202			today: function () {
203				return moment().isSame(this.date, 'day');
204			}
205		},
206		methods: {
207			openModal: function (day, e) {
208
209				// exit if link is clicked (patientID, HCPID, ...)
210				if (e.target.tagName === 'A')
211					return;
212
213				//store.setModalDay(day);
214				app.xtemplate.store.componentstore.openModal(day);
215
216				// botstrap methids does not work here, because it manipulates the DOM and vue will get out of sync
217				//$('#appModal').modal();
218			}
219		}
220	});
221
222    var LoadMonths = Vue.component('month', {
223        template: '#month-template',
224        data: function () {
225			return {
226				state: this.$state
227			};
228        },
229        created: function () {
230
231            // set month outside of this component, like from year view
232            if (this.state.monthSet) {
233				var start = moment(this.state.monthSet);
234            } else {
235                start = moment().startOf('month');
236            }
237
238            var range = app.xtemplate.helpers.genRange(start, start.daysInMonth());
239            app.xtemplate.store.componentstore.setRangeStart(range[0]);
240            app.xtemplate.store.componentstore.setRange(range);
241            app.xtemplate.store.componentstore.setRangeEnd(range[range.length - 1]);
242            this.state.monthSet = null;
243            this.state.viewCreated = 'MONTH';
244
245            app.xtemplate.store.componentstore.startLoader();
246            app.xtemplate.store.componentstore.getEvents(range[0], range[range.length - 1], function (status) {
247                app.xtemplate.store.componentstore.stopLoader();
248                console.log(status);
249            }.bind(this));
250        },
251        computed: {
252            spacer: function () {
253				return app.xtemplate.helpers.calcFirstDayOffset(this.state.range[0], app.xtemplate.store.componentstore.startDay);
254            },
255            spacerEnd: function () {
256                // position of first day
257                var startDayPosition = (moment(this.state.range[0]).day() - app.xtemplate.store.componentstore.startDay) < 0 ? 6 : (moment(this.state.range[0]).day() - app.xtemplate.store.componentstore.startDay);
258                var itemsInFirstLine = 7 - startDayPosition;
259
260                var itemsInLastLine = (moment(this.state.range[this.state.range.length - 1]).daysInMonth() - itemsInFirstLine) % 7;
261                return itemsInLastLine > 0;
262
263            },
264            weekDays: function () {
265				return app.xtemplate.helpers.calcWeekDays(app.xtemplate.store.componentstore.daysShort, app.xtemplate.store.componentstore.startDay);
266            }
267        }
268    });
269
270    var LoadMonthDays = Vue.component('month-day', {
271        template: '#month-day-template',
272        data: function () {
273			return {
274				state: this.$state,
275				allEvents: [],
276				moreEvents: 0,
277                hasEvents: false,
278                more: {
279                    'Morning': 0,
280                    'Evening': 0,
281                    'Afternoon': 0,
282                    'Night': 0
283                }
284			};
285        },
286        created: function () {
287            this.hasEvents = this.state.events.hasOwnProperty(this.date);
288            // no need to execute further
289            if (!this.hasEvents)
290                return;
291            // sort events based on time preference
292
293            var sortedEvents = app.xtemplate.helpers.sortEvents(this.state.events[this.date]);
294
295
296			// connect events together and discard all but 2
297			this.allEvents = sortedEvents.Morning.concat(sortedEvents.Afternoon, sortedEvents.Evening, sortedEvents.Night);
298            if (this.allEvents.length > 2) {
299                this.moreEvents = this.allEvents.length - 2;
300                this.allEvents.splice(0, this.allEvents.length - 2);
301            }
302
303        },
304        methods: {
305            openModal: function (day, e) {
306                //console.log(e);
307                // exit if link is clicked (patientID, HCPID, ...)
308                if (e.target.tagName === 'A')
309                    return;
310
311                //store.setModalDay(day);
312                app.xtemplate.store.componentstore.openModal(day);
313
314                // botstrap methids does not work here, because it manipulates the DOM and vue will get out of sync
315                //$('#appModal').modal();
316            }
317        },
318        computed: {
319            day: function () {
320                return moment(this.date).date();
321            },
322            classList: function () {
323
324                var date = moment(this.date);
325                var now = moment().startOf('day');
326
327				return {
328					today: now.isSame(date),
329					su: date.day() === 0 || date.day() === 6,
330					'has-events': this.hasEvents,
331					past: this.hasEvents && date.isBefore(now)
332				};
333            }
334        },
335        props: {
336            date: String
337        }
338    });
339
340    var LoadAgenda = Vue.component('agenda', {
341        template: '#agenda-template',
342        data: function () {
343			return {
344				state: this.$state
345			};
346        },
347        created: function () {
348
349            var range = app.xtemplate.helpers.genRange(moment(), app.xtemplate.store.componentstore.agendaStep);
350            app.xtemplate.store.componentstore.setRangeStart(range[0]);
351            app.xtemplate.store.componentstore.setRange(range);
352            app.xtemplate.store.componentstore.setRangeEnd(range[range.length - 1]);
353
354            app.xtemplate.store.componentstore.startLoader();
355
356            // this will update the range dates
357            this.state.viewCreated = 'AGENDA';
358
359            app.xtemplate.store.componentstore.startLoader();
360            app.xtemplate.store.componentstore.getEvents(range[0], range[range.length - 1], function (status) {
361                app.xtemplate.store.componentstore.stopLoader();
362                console.log(status);
363            }.bind(this));
364
365
366        },
367        computed: {
368            hasEventsInRange: function () {
369                for (var i = 0; i < this.state.range.length; i++) {
370                    if (this.state.events.hasOwnProperty(this.state.range[i]))
371                        return true;
372                }
373                return false;
374            }
375        }
376    });
377
378    var LoadAgendaDay = Vue.component('agenda-day', {
379        template: '#agenda-day-template',
380        props: {
381            date: String
382        },
383        data: function () {
384			return {
385				state: this.$state,
386				allEvents: [],
387				hasEvents: false
388			};
389        },
390        created: function () {
391            this.hasEvents = this.state.events.hasOwnProperty(this.date);
392            // no need to execute further
393            if (!this.hasEvents)
394                return;
395
396            var sortedEvents = app.xtemplate.helpers.sortEvents(this.state.events[this.date]);
397
398            // connect events together
399			//this.allEvents = sortedEvents.MORNING.concat(sortedEvents.AFTERNOON, sortedEvents.EVENING, sortedEvents.NIGHT);
400			this.allEvents = sortedEvents.Morning.concat(sortedEvents.Afternoon, sortedEvents.Evening, sortedEvents.Night);
401
402        },
403        computed: {
404            day: function () {
405				return moment(this.date).format('DD');
406            },
407            nameOfDay: function () {
408                return app.xtemplate.store.componentstore.days[moment(this.date).day()];
409            },
410            nameOfMonth: function () {
411                return app.xtemplate.store.componentstore.fullMonths[moment(this.date).month()];
412            },
413            year: function () {
414                return moment(this.date).year();
415            }
416        }
417    });
418   
419    var LoadYears = Vue.component('year', {
420        template: '#year-template',
421        data: function () {
422			return {
423				state: this.$state
424			};
425        },
426        created: function () {
427
428            var yearStart = moment().startOf('year').format('YYYY-MM-DD');
429            var yearEnd = moment().endOf('year').format('YYYY-MM-DD');
430
431
432
433            app.xtemplate.store.componentstore.setRangeStart(yearStart);
434            //store.setRange(range);
435            app.xtemplate.store.componentstore.setRangeEnd(yearEnd);
436
437
438            // this will update the range dates
439            this.state.viewCreated = 'YEAR';
440
441            app.xtemplate.store.componentstore.startLoader();
442            app.xtemplate.store.componentstore.getEvents(yearStart, yearEnd, function (status) {
443                app.xtemplate.store.componentstore.stopLoader();
444                console.log(status);
445            }.bind(this));
446
447
448
449
450        },
451        computed: {
452            year: function () {
453                return moment(this.state.rangeStart).year();
454            }
455        }
456    });
457
458    var LoadSmallMonths = Vue.component('small-month', {
459        template: '#small-month-template',
460        data: function () {
461			return {
462				state: this.$state,
463			};
464        },
465        watch: {
466        },
467        props: {
468            month: Number,
469            year: Number
470        },
471        created: function () {
472            //year( moment(this.state.rangeStart).year() )
473
474        },
475        computed: {
476            monthName: function () {
477                return app.xtemplate.store.componentstore.fullMonths[this.month];
478            },
479            weekDays: function () {
480				return app.xtemplate.helpers.calcWeekDays(app.xtemplate.store.componentstore.daysShorter, app.xtemplate.store.componentstore.startDay);
481            },
482            localRange: function () {
483                var date = moment().year(this.year).month(this.month).startOf('month');
484                return app.xtemplate.helpers.genRange(date, date.daysInMonth());
485            },
486            spacer: function () {
487				return app.xtemplate.helpers.calcFirstDayOffset(this.localRange[0], app.xtemplate.store.componentstore.startDay);
488            }
489        },
490        methods: {
491            //goToMonth() {
492			goToMonth: function() {
493                this.state.monthSet = moment().year(this.year).month(this.month).startOf('month');
494
495                //this.state.switcherRefs[this.state.view].classList.remove('active');
496                //this.state.switcherRefs['MONTH'].classList.add('active');
497                //console.log(this.switcherRefs)
498				app.xtemplate.store.componentstore.setView('MONTH');
499            }
500        }
501    });
502
503    var LoadSmallMonthDays = Vue.component('small-month-day', {
504        template: '#small-month-day-template',
505        data: function () {
506			return {
507				state: this.$state,
508				hasEvents: false,
509				holiday: false
510			};
511        },
512        props: {
513            date: String,
514            month: Number
515		},
516		mounted: function () {
517			this.hasEvents = this.state.events.hasOwnProperty(this.date);
518			this.holiday = app.xtemplate.store.componentstore.holidays.indexOf(this.date) > -1;
519            // no need to execute further
520            if (!this.hasEvents)
521				return;
522
523        },
524        computed: {
525            dayNum: function () {
526                return moment(this.date).date();
527            },
528            classList: function () {
529
530                var date = moment(this.date);
531                var now = moment().startOf('day');
532                //console.log([moment(), date])
533				return {
534					today: now.isSame(date),
535					su: date.day() === 0 || date.day() === 6,
536					'has-events': this.hasEvents,
537					'past-events': this.hasEvents && date.isBefore(now),
538					'holiday': this.holiday
539				};
540
541            }
542        },
543        methods: {
544            openModal: function (day) {
545                if (!this.hasEvents)
546                    return;
547
548                //store.setModalDay(day);
549				app.xtemplate.store.componentstore.openModal(day);
550
551                //$('#appModal').modal();
552            }
553        }
554    });
555
556    var LoadTimeTravel = Vue.component('time-travel', {
557        template: '#time-travel-template',
558        data: function () {
559			return {
560				state: this.$state
561			};
562        },
563        created: function () {
564            // set initial ranges
565            // moved to cal view components
566        },
567        computed: {
568            // formated range string
569            range: function () {
570                if (this.state.viewCreated === 'AGENDA') {
571
572
573					var end = moment(this.state.rangeEnd);
574                    var ed = end.date();
575                    var em = end.month();
576                    var ey = end.year();
577
578					var start = moment(this.state.rangeStart);
579					var sd = start.date();
580                    var sm = start.month();
581                    var sy = start.year();
582
583                    return sd + ' ' + app.xtemplate.store.componentstore.months[sm] + ' ' + sy + ' - ' + ed + ' ' + app.xtemplate.store.componentstore.months[em] + ' ' + ey;
584                }
585
586                if (this.state.viewCreated === "MONTH") {
587                    var date = moment(this.state.rangeStart);
588                    return app.xtemplate.store.componentstore.fullMonths[date.month()] + ' ' + date.year();
589                }
590
591                if (this.state.viewCreated === 'YEAR') {
592					return moment(this.state.rangeStart).year();
593                }
594
595                if (this.state.viewCreated === 'WEEK') {
596                    //23 - 29 Jun 2019
597                    //30 Jun - 7 Jul 2019
598                    start = moment(this.state.rangeStart);
599                    end = moment(this.state.rangeEnd);
600
601                    if (start.month() === end.month()) {
602						return start.date() + ' - ' + end.date() + ' ' + app.xtemplate.store.componentstore.months[end.month()] + ' ' + end.year();
603                    } else {
604                        return start.date() + ' ' + app.xtemplate.store.componentstore.months[start.month()] + ' - ' + end.date() + ' ' + app.xtemplate.store.componentstore.months[end.month()] + ' ' + end.year();
605                    }
606
607                }
608
609                if (this.state.viewCreated === 'DAY') {
610                    //Mon 04 December 2019
611                    start = moment(this.state.rangeStart);
612
613                    //return app.xtemplate.helpers.ucFirst(app.xtemplate.store.componentstore.daysShort[start.day()]) + ' ' + start.format('DD') + ' ' + app.xtemplate.store.componentstore.fullMonths[start.month()] + ' ' + start.year();
614                    return app.xtemplate.store.componentstore.daysShort[start.day()] + ' ' + start.format('DD') + ' ' + app.xtemplate.store.componentstore.fullMonths[start.month()] + ' ' + start.year();
615
616                }
617
618
619            }
620        },
621        methods: {
622            goToStart: function () {
623
624                // move the counter to force rerendering the component, default mounted method will run and set current date
625                app.xtemplate.store.componentstore.counterPlus();
626
627            },
628            stepForward: function () {
629
630
631
632                if (this.state.view === 'DAY') {
633                    var date = moment(this.state.rangeStart).add(1, 'days').format('YYYY-MM-DD');
634                    app.xtemplate.store.componentstore.setRangeStart(date);
635                    app.xtemplate.store.componentstore.setRangeEnd(date);
636                }
637
638                if (this.state.view === 'AGENDA') {
639                    date = moment(this.state.rangeEnd).add(1, 'days');
640
641					var range = app.xtemplate.helpers.genRange(date, app.xtemplate.store.componentstore.agendaStep);
642
643                    // update state
644                    app.xtemplate.store.componentstore.setRangeStart(range[0]);
645                    app.xtemplate.store.componentstore.setRangeEnd(range[range.length - 1]);
646                    app.xtemplate.store.componentstore.setRange(range);
647                }
648
649                if (this.state.view === 'MONTH') {
650
651                    date = moment(this.state.rangeStart).add(1, 'months');
652
653                    date.startOf('month');
654
655                    // get numbr of days
656                    var days = date.daysInMonth();
657
658                    range = app.xtemplate.helpers.genRange(date, days);
659
660                    // update state
661                    app.xtemplate.store.componentstore.setRangeStart(range[0]);
662                    app.xtemplate.store.componentstore.setRangeEnd(range[range.length - 1]);
663                    app.xtemplate.store.componentstore.setRange(range);
664
665                }
666
667                if (this.state.view === 'YEAR') {
668                    date = moment(this.state.rangeStart).add(1, 'years');
669                    app.xtemplate.store.componentstore.setRangeStart(date.startOf('year').format('YYYY-MM-DD'));
670                    app.xtemplate.store.componentstore.setRangeEnd(date.endOf('year').format('YYYY-MM-DD'));
671                }
672
673                if (this.state.view === 'WEEK') {
674
675                    date = moment(this.state.rangeStart).add(1, 'weeks');
676
677                    range = app.xtemplate.helpers.genRange(date, 7);
678
679                    // update state
680                    app.xtemplate.store.componentstore.setRangeStart(range[0]);
681                    app.xtemplate.store.componentstore.setRangeEnd(range[range.length - 1]);
682                    app.xtemplate.store.componentstore.setRange(range);
683                }
684
685                // fetch new events
686                app.xtemplate.store.componentstore.startLoader();
687                app.xtemplate.store.componentstore.getEvents(this.state.rangeStart, this.state.rangeEnd, function (status) {
688                    app.xtemplate.store.componentstore.stopLoader();
689                    console.log(status);
690                }.bind(this));
691
692            },
693            stepBack: function () {
694
695                if (this.state.view === 'DAY') {
696                    var date = moment(this.state.rangeStart).subtract(1, 'days').format('YYYY-MM-DD');
697                    app.xtemplate.store.componentstore.setRangeStart(date);
698                    app.xtemplate.store.componentstore.setRangeEnd(date);
699                }
700
701                if (this.state.view === 'AGENDA') {
702                    // current start date
703                    var start = moment(this.state.rangeStart).subtract(app.xtemplate.store.componentstore.agendaStep, 'days');
704
705                    // generate new range
706					var range = app.xtemplate.helpers.genRange(start, app.xtemplate.store.componentstore.agendaStep);
707
708                    // update state
709					app.xtemplate.store.componentstore.setRangeStart(range[0]);
710					app.xtemplate.store.componentstore.setRangeEnd(range[range.length - 1]);
711					app.xtemplate.store.componentstore.setRange(range);
712                }
713
714                if (this.state.view === 'MONTH') {
715                    date = moment(this.state.rangeStart).subtract('1', 'months');
716
717                    date.startOf('month');
718
719                    // get numbr of days
720					var days = date.daysInMonth();
721
722                    range = app.xtemplate.helpers.genRange(date, days);
723
724                    // update state
725					app.xtemplate.store.componentstore.setRangeStart(range[0]);
726					app.xtemplate.store.componentstore.setRangeEnd(range[range.length - 1]);
727					app.xtemplate.store.componentstore.setRange(range);
728
729                }
730
731                if (this.state.view === 'YEAR') {
732                    date = moment(this.state.rangeStart).subtract(1, 'years');
733                    app.xtemplate.store.componentstore.setRangeStart(date.startOf('year').format('YYYY-MM-DD'));
734                    app.xtemplate.store.componentstore.setRangeEnd(date.endOf('year').format('YYYY-MM-DD'));
735                }
736
737                if (this.state.view === 'WEEK') {
738
739                    date = moment(this.state.rangeStart).subtract(1, 'weeks');
740
741                    range = app.xtemplate.helpers.genRange(date, 7);
742
743                    // update state
744					app.xtemplate.store.componentstore.setRangeStart(range[0]);
745					app.xtemplate.store.componentstore.setRangeEnd(range[range.length - 1]);
746					app.xtemplate.store.componentstore.setRange(range);
747                }
748
749
750                // fetch new events
751                app.xtemplate.store.componentstore.startLoader();
752                app.xtemplate.store.componentstore.getEvents(this.state.rangeStart, this.state.rangeEnd, function (status) {
753                    app.xtemplate.store.componentstore.stopLoader();
754                    console.log(status);
755                }.bind(this));
756
757            }
758        }
759    });
760
761    var LoadViewSwitcher = Vue.component('view-switcher', {
762        template: '#view-switcher-template',
763        data: function () {
764			return {
765				state: this.$state
766			};
767        },
768        methods: {
769            setView: app.xtemplate.store.componentstore.setView
770        }
771    });
772
773    return {
774        LoadAppModel: LoadAppModel,
775        LoadDays: LoadDays,
776        LoadSmallEvents: LoadSmallEvents,
777        LoadWeeks: LoadWeeks,
778        LoadWeekDay: LoadWeekDay,
779        LoadMonths: LoadMonths,
780        LoadMonthDays: LoadMonthDays,
781        LoadAgenda: LoadAgenda,
782        LoadAgendaDay: LoadAgendaDay,
783        LoadYears: LoadYears,
784        LoadSmallMonths: LoadSmallMonths,
785        LoadSmallMonthDays: LoadSmallMonthDays,
786        LoadTimeTravel: LoadTimeTravel,
787        LoadViewSwitcher: LoadViewSwitcher
788    };
789}();

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.