gitsidian-testing
/
obsidian-sandbox-vault
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
obsidian-sandbox-vault/.obsidian/plugins/obsidian-activity-history/main.js

2777 lines
76 KiB
JavaScript
Raw Blame History

'use strict';
var obsidian = require('obsidian');
require('constants');
/**
* Calculate size of MD files in the specified directory
* @param projectPath - path to project e.g. 'Test Project/First Sub Project'
* @param vaultFiles - list of all TFiles of Obsidian vault
*/
const getProjectSize = (projectPath, vaultFiles) => {
let projectSize = 0;
let reg = new RegExp(`^${projectPath}\/.*\.md$`);
if (projectPath === '/') {
reg = new RegExp(`^.*\.md$`);
}
for (let file in vaultFiles) {
if (vaultFiles[file].path.match(reg)) {
projectSize += vaultFiles[file].stat.size;
}
}
return projectSize;
};
const updateActivity = (projectPath, vaultFiles, activitySettings) => {
let timestampNow = getTimestamp();
let newSize = getProjectSize(projectPath, vaultFiles);
let checkpoint = getProjectCheckpoint(projectPath, activitySettings.checkpointList);
let activity = Math.abs(newSize - checkpoint.size);
if (timestampNow == checkpoint.date) {
updateProjectCheckpoint(projectPath, activitySettings.checkpointList, timestampNow, newSize);
activity = activity + getActivityAtDate(projectPath, activitySettings.activityHistory, timestampNow);
updateActivityAtDate(projectPath, activitySettings.activityHistory, timestampNow, activity);
}
updateProjectCheckpoint(projectPath, activitySettings.checkpointList, timestampNow, newSize);
updateActivityAtDate(projectPath, activitySettings.activityHistory, timestampNow, activity);
};
/**
* Return timestamp for current day
*/
const getTimestamp = () => {
let today = new Date();
let timestamp = today.getFullYear().toString();
let month = today.getMonth() + 1;
let date = today.getDate();
timestamp += `-${((month < 10) ? '0' : '') + month.toString()}`;
timestamp += `-${((date < 10) ? '0' : '') + date.toString()}`;
return timestamp;
};
/**
* Return size for specified day
*/
const getActivityAtDate = (projectPath, activityHistoryList, timestamp) => {
for (let index = 0; index < activityHistoryList.length; index++) {
if (projectPath == activityHistoryList[index].path) {
for (let i = 0; i < activityHistoryList[index].size.length; i++) {
if (activityHistoryList[index].size[i].date == timestamp) {
return activityHistoryList[index].size[i].value;
}
}
}
}
return null;
};
/**
* Return Activity History for specified project
*/
const getProjectActivityHistory = (projectPath, activityHistoryList) => {
for (let index = 0; index < activityHistoryList.length; index++) {
if (projectPath == activityHistoryList[index].path) {
return activityHistoryList[index];
}
}
return null;
};
/**
* Return checkpoint size & date for specified project
*/
const getProjectCheckpoint = (projectPath, checkpointList) => {
for (let index = 0; index < checkpointList.length; index++) {
if (projectPath == checkpointList[index].path) {
return checkpointList[index];
}
}
return null;
};
/**
* Update checkpoint size & date for specified project
*/
const updateProjectCheckpoint = (projectPath, checkpointList, valueDate, valueSize) => {
for (let index = 0; index < checkpointList.length; index++) {
if (projectPath == checkpointList[index].path) {
checkpointList[index] = { path: projectPath, date: valueDate, size: valueSize };
}
}
};
/**
* Return initialization status for specified project
*/
const getInitializationStatus = (projectPath, initializationList) => {
for (let index = 0; index < initializationList.length; index++) {
if (projectPath == initializationList[index].path) {
return initializationList[index];
}
}
return null;
};
/**
* Update timestamp for specified day
*/
const updateActivityAtDate = (projectPath, activityHistoryList, timestamp, value) => {
for (let index = 0; index < activityHistoryList.length; index++) {
if (projectPath == activityHistoryList[index].path) {
for (let i = activityHistoryList[index].size.length - 1; i >= 0; i--) {
if (activityHistoryList[index].size[i].date == timestamp) {
activityHistoryList[index].size[i].value = value;
return true;
}
}
activityHistoryList[index].size.push({ date: timestamp, value: value });
return true;
}
}
return false;
};
/**
* Check if project path is being tracked
*/
const isTracked = (projectPath, trackedProjects) => {
return trackedProjects.contains(projectPath);
};
/**
* Check if project path is valid (at least 1 md file contained)
*/
const isValidProject = (projectPath, vaultFiles) => {
let reg = new RegExp(`^${projectPath}\/.*\.md$`);
for (let file in vaultFiles) {
if (vaultFiles[file].path.match(reg)) {
return true;
}
}
return false;
};
/**
* Stop tracking specified project
*/
const removeProject = (projectPath, activitySettings) => {
activitySettings.trackedProjects.remove(projectPath);
activitySettings.initialized.remove(getInitializationStatus(projectPath, activitySettings.initialized));
activitySettings.checkpointList.remove(getProjectCheckpoint(projectPath, activitySettings.checkpointList));
activitySettings.activityHistory.remove(getProjectActivityHistory(projectPath, activitySettings.activityHistory));
return activitySettings;
};
/**
* Start tracking specified project
*/
const addProject = (projectPath, activitySettings, vaultFiles) => {
let timestampNow = getTimestamp();
activitySettings.trackedProjects.push(projectPath);
activitySettings.initialized.push({ path: projectPath, initialized: true });
activitySettings.checkpointList.push({ path: projectPath, date: timestampNow, size: getProjectSize(projectPath, vaultFiles) });
activitySettings.activityHistory.push({ path: projectPath, size: [{ date: timestampNow, value: 0 }] });
return activitySettings;
};
/**
* Get Year Span for specified project
*/
const getYearRange = (projectPath, activityHistoryList) => {
let yearRange = [];
for (let index = 0; index < activityHistoryList.length; index++) {
if (projectPath == activityHistoryList[index].path) {
for (let i = activityHistoryList[index].size.length - 1; i >= 0; i--) {
let yearTmp = activityHistoryList[index].size[i].date.split('-')[0];
if (yearRange) {
if (yearRange.every(x => x.year != yearTmp)) {
yearRange.push({ year: yearTmp });
}
}
}
}
}
return yearRange;
};
/**
* Check if string is a valid hexcolor
*/
const isHexColor = (hex) => {
return typeof hex === 'string'
&& hex.length === 7
&& hex[0] === '#';
};
const updateActivityAll = (activitySettings, vaultFiles) => {
// Loop over all tracked projects
for (let project in activitySettings.trackedProjects) {
updateActivity(activitySettings.trackedProjects[project], vaultFiles, activitySettings);
}
};
class ActivityHistorySettingTab extends obsidian.PluginSettingTab {
constructor(app, plugin) {
super(app, plugin);
this.plugin = plugin;
}
display() {
let { containerEl } = this;
containerEl.empty();
containerEl.createEl('h2', { text: 'Activity History Settings' });
new obsidian.Setting(containerEl)
.setName('Tracked Projects:')
.setDesc(this.plugin.settings.trackedProjects.join(" --------- "));
new obsidian.Setting(containerEl)
.setName('Track Project:')
.setDesc('Add project to tracking list. e.g. write `Project 1` to track the project located in `/Project 1`')
.addText(text => text
.setPlaceholder(`Project Example`)
.onChange(async (value) => {
if (value.trim() === '/') {
return;
}
// check if project already tracked
if (isTracked(value, this.plugin.settings.trackedProjects)) {
return;
}
// check if project is a valid project
if (!isValidProject(value, this.plugin.app.vault.getMarkdownFiles())) {
return;
}
// add & initialize project
addProject(value, this.plugin.settings, this.plugin.app.vault.getMarkdownFiles());
// save settings
await this.plugin.saveSettings();
}));
new obsidian.Setting(containerEl)
.setName('Stop Tracking Project:')
.setDesc('Remove project from the tracking list. e.g. `Project 1`')
.addText(text => text
.setPlaceholder(`Project Example`)
.onChange(async (value) => {
if (value.trim() === '/') {
return;
}
// check if project being tracked
if (!isTracked(value, this.plugin.settings.trackedProjects)) {
return;
}
// add & initialize project
removeProject(value, this.plugin.settings);
// save settings
await this.plugin.saveSettings();
}));
new obsidian.Setting(containerEl)
.setName('Activity 1 Color:')
.setDesc('Color for lowest activity. Placeholder shows current color.')
.addDropdown(dropDown => dropDown
.addOption('yearly', 'Yearly')
.addOption('monthly', 'Monthly')
.setValue(this.plugin.settings.type || 'yearly')
.onChange((value) => {
this.plugin.settings.type = value;
this.plugin.saveSettings();
}));
new obsidian.Setting(containerEl)
.setName('Activity 1 Color:')
.setDesc('Color for lowest activity. Placeholder shows current color.')
.addText(text => text
.setPlaceholder(this.plugin.settings.activityColor1)
.onChange(async (value) => {
// check if valid hex
if (!isHexColor(value)) {
return;
}
this.plugin.settings.activityColor1 = value;
await this.plugin.saveSettings();
}));
new obsidian.Setting(containerEl)
.setName('Activity 2 Color:')
.setDesc('Color for low activity. Placeholder shows current color.')
.addText(text => text
.setPlaceholder(this.plugin.settings.activityColor2)
.onChange(async (value) => {
// check if valid hex
if (!isHexColor(value)) {
return;
}
this.plugin.settings.activityColor2 = value;
await this.plugin.saveSettings();
}));
new obsidian.Setting(containerEl)
.setName('Activity 3 Color:')
.setDesc('Color for medium activity. Placeholder shows current color.')
.addText(text => text
.setPlaceholder(this.plugin.settings.activityColor3)
.onChange(async (value) => {
// check if valid hex
if (!isHexColor(value)) {
return;
}
this.plugin.settings.activityColor3 = value;
await this.plugin.saveSettings();
}));
new obsidian.Setting(containerEl)
.setName('Activity 4 Color:')
.setDesc('Color for highest activity. Placeholder shows current color.')
.addText(text => text
.setPlaceholder(this.plugin.settings.activityColor4)
.onChange(async (value) => {
// check if valid hex
if (!isHexColor(value)) {
return;
}
this.plugin.settings.activityColor4 = value;
await this.plugin.saveSettings();
}));
new obsidian.Setting(containerEl)
.setName('Text color:')
.setDesc('Text color. Placeholder shows current color.')
.addText(text => text
.setPlaceholder(this.plugin.settings.textColor)
.onChange(async (value) => {
// check if valid hex
if (!isHexColor(value)) {
return;
}
this.plugin.settings.textColor = value;
await this.plugin.saveSettings();
}));
new obsidian.Setting(containerEl)
.setName('Empty color:')
.setDesc('Empty color. Placeholder shows current color.')
.addText(text => text
.setPlaceholder(this.plugin.settings.emptyColor)
.onChange(async (value) => {
// check if valid hex
if (!isHexColor(value)) {
return;
}
this.plugin.settings.emptyColor = value;
await this.plugin.saveSettings();
}));
new obsidian.Setting(containerEl)
.setName('Cell Radius:')
.setDesc('Cell Radius. integer, default is 1 = square, the higher the more round.')
.addText(text => text
.setPlaceholder(this.plugin.settings.cellRadius)
.onChange(async (value) => {
let numValue = parseInt(value);
// check if valid hex
if (isNaN(numValue)) {
return;
}
this.plugin.settings.cellRadius = Math.abs(numValue);
await this.plugin.saveSettings();
}));
}
}
function noop() { }
function run(fn) {
return fn();
}
function blank_object() {
return Object.create(null);
}
function run_all(fns) {
fns.forEach(run);
}
function is_function(thing) {
return typeof thing === 'function';
}
function safe_not_equal(a, b) {
return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function');
}
function is_empty(obj) {
return Object.keys(obj).length === 0;
}
function append(target, node) {
target.appendChild(node);
}
function insert(target, node, anchor) {
target.insertBefore(node, anchor || null);
}
function detach(node) {
node.parentNode.removeChild(node);
}
function destroy_each(iterations, detaching) {
for (let i = 0; i < iterations.length; i += 1) {
if (iterations[i])
iterations[i].d(detaching);
}
}
function element(name) {
return document.createElement(name);
}
function svg_element(name) {
return document.createElementNS('http://www.w3.org/2000/svg', name);
}
function text(data) {
return document.createTextNode(data);
}
function empty() {
return text('');
}
function listen(node, event, handler, options) {
node.addEventListener(event, handler, options);
return () => node.removeEventListener(event, handler, options);
}
function attr(node, attribute, value) {
if (value == null)
node.removeAttribute(attribute);
else if (node.getAttribute(attribute) !== value)
node.setAttribute(attribute, value);
}
function children(element) {
return Array.from(element.childNodes);
}
function set_data(text, data) {
data = '' + data;
if (text.wholeText !== data)
text.data = data;
}
function select_option(select, value) {
for (let i = 0; i < select.options.length; i += 1) {
const option = select.options[i];
if (option.__value === value) {
option.selected = true;
return;
}
}
}
function select_value(select) {
const selected_option = select.querySelector(':checked') || select.options[0];
return selected_option && selected_option.__value;
}
let current_component;
function set_current_component(component) {
current_component = component;
}
const dirty_components = [];
const binding_callbacks = [];
const render_callbacks = [];
const flush_callbacks = [];
const resolved_promise = Promise.resolve();
let update_scheduled = false;
function schedule_update() {
if (!update_scheduled) {
update_scheduled = true;
resolved_promise.then(flush);
}
}
function add_render_callback(fn) {
render_callbacks.push(fn);
}
function add_flush_callback(fn) {
flush_callbacks.push(fn);
}
let flushing = false;
const seen_callbacks = new Set();
function flush() {
if (flushing)
return;
flushing = true;
do {
// first, call beforeUpdate functions
// and update components
for (let i = 0; i < dirty_components.length; i += 1) {
const component = dirty_components[i];
set_current_component(component);
update(component.$$);
}
set_current_component(null);
dirty_components.length = 0;
while (binding_callbacks.length)
binding_callbacks.pop()();
// then, once components are updated, call
// afterUpdate functions. This may cause
// subsequent updates...
for (let i = 0; i < render_callbacks.length; i += 1) {
const callback = render_callbacks[i];
if (!seen_callbacks.has(callback)) {
// ...so guard against infinite loops
seen_callbacks.add(callback);
callback();
}
}
render_callbacks.length = 0;
} while (dirty_components.length);
while (flush_callbacks.length) {
flush_callbacks.pop()();
}
update_scheduled = false;
flushing = false;
seen_callbacks.clear();
}
function update($$) {
if ($$.fragment !== null) {
$$.update();
run_all($$.before_update);
const dirty = $$.dirty;
$$.dirty = [-1];
$$.fragment && $$.fragment.p($$.ctx, dirty);
$$.after_update.forEach(add_render_callback);
}
}
const outroing = new Set();
let outros;
function group_outros() {
outros = {
r: 0,
c: [],
p: outros // parent group
};
}
function check_outros() {
if (!outros.r) {
run_all(outros.c);
}
outros = outros.p;
}
function transition_in(block, local) {
if (block && block.i) {
outroing.delete(block);
block.i(local);
}
}
function transition_out(block, local, detach, callback) {
if (block && block.o) {
if (outroing.has(block))
return;
outroing.add(block);
outros.c.push(() => {
outroing.delete(block);
if (callback) {
if (detach)
block.d(1);
callback();
}
});
block.o(local);
}
}
function bind(component, name, callback) {
const index = component.$$.props[name];
if (index !== undefined) {
component.$$.bound[index] = callback;
callback(component.$$.ctx[index]);
}
}
function create_component(block) {
block && block.c();
}
function mount_component(component, target, anchor) {
const { fragment, on_mount, on_destroy, after_update } = component.$$;
fragment && fragment.m(target, anchor);
// onMount happens before the initial afterUpdate
add_render_callback(() => {
const new_on_destroy = on_mount.map(run).filter(is_function);
if (on_destroy) {
on_destroy.push(...new_on_destroy);
}
else {
// Edge case - component was destroyed immediately,
// most likely as a result of a binding initialising
run_all(new_on_destroy);
}
component.$$.on_mount = [];
});
after_update.forEach(add_render_callback);
}
function destroy_component(component, detaching) {
const $$ = component.$$;
if ($$.fragment !== null) {
run_all($$.on_destroy);
$$.fragment && $$.fragment.d(detaching);
// TODO null out other refs, including component.$$ (but need to
// preserve final state?)
$$.on_destroy = $$.fragment = null;
$$.ctx = [];
}
}
function make_dirty(component, i) {
if (component.$$.dirty[0] === -1) {
dirty_components.push(component);
schedule_update();
component.$$.dirty.fill(0);
}
component.$$.dirty[(i / 31) | 0] |= (1 << (i % 31));
}
function init(component, options, instance, create_fragment, not_equal, props, dirty = [-1]) {
const parent_component = current_component;
set_current_component(component);
const $$ = component.$$ = {
fragment: null,
ctx: null,
// state
props,
update: noop,
not_equal,
bound: blank_object(),
// lifecycle
on_mount: [],
on_destroy: [],
before_update: [],
after_update: [],
context: new Map(parent_component ? parent_component.$$.context : []),
// everything else
callbacks: blank_object(),
dirty,
skip_bound: false
};
let ready = false;
$$.ctx = instance
? instance(component, options.props || {}, (i, ret, ...rest) => {
const value = rest.length ? rest[0] : ret;
if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {
if (!$$.skip_bound && $$.bound[i])
$$.bound[i](value);
if (ready)
make_dirty(component, i);
}
return ret;
})
: [];
$$.update();
ready = true;
run_all($$.before_update);
// `false` as a special case of no DOM component
$$.fragment = create_fragment ? create_fragment($$.ctx) : false;
if (options.target) {
if (options.hydrate) {
const nodes = children(options.target);
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
$$.fragment && $$.fragment.l(nodes);
nodes.forEach(detach);
}
else {
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
$$.fragment && $$.fragment.c();
}
if (options.intro)
transition_in(component.$$.fragment);
mount_component(component, options.target, options.anchor);
flush();
}
set_current_component(parent_component);
}
/**
* Base class for Svelte components. Used when dev=false.
*/
class SvelteComponent {
$destroy() {
destroy_component(this, 1);
this.$destroy = noop;
}
$on(type, callback) {
const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = []));
callbacks.push(callback);
return () => {
const index = callbacks.indexOf(callback);
if (index !== -1)
callbacks.splice(index, 1);
};
}
$set($$props) {
if (this.$$set && !is_empty($$props)) {
this.$$.skip_bound = true;
this.$$set($$props);
this.$$.skip_bound = false;
}
}
}
/**
* Get the last day of the month.
*
* @param {Date} date
*
* @return {Date}
*/
function getMonthEnd(date) {
return new Date(date.getFullYear(), date.getMonth() + 1, 0);
}
/**
* Get the first day of the month.
*
* @param {Date} date
*
* @return {Date}
*/
function getMonthStart(date) {
return new Date(date.getFullYear(), date.getMonth(), 1);
}
/**
* Get the last day of the week.
*
* @param {Date} date
*
* @return {Date}
*/
function getWeekEnd(date) {
return new Date(date.getFullYear(), date.getMonth(), date.getDate() + (6 - date.getDay()));
}
/**
* Return the week index of a date.
*
* @param {Date} date
*
* @return {number}
*/
function getWeekIndex(date) {
const firstWeekday = new Date(date.getFullYear(), date.getMonth(), 1).getDay();
const offsetDate = date.getDate() + firstWeekday - 1;
return Math.floor(offsetDate / 7);
}
/**
* Get the first day of the week.
*
* @param {Date} date
*
* @return {Date}
*/
function getWeekStart(date) {
return new Date(date.getFullYear(), date.getMonth(), date.getDate() - date.getDay());
}
/**
* Normalize to a javascript Date object.
*
* @param {Date|number|string} value
*
* @return {Date}
*/
function normalizeDate(value) {
if (value instanceof Date) {
return value;
}
if (['number', 'string'].includes(typeof value)) {
return new Date(value);
}
throw new Error('Invalid date value');
}
/**
* Stringify a date.
*
* @param {Date} date
*
* @return {string}
*/
function stringifyDate(date) {
return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`
}
/**
* Divide a calendar into months.
*
* @param {Object} options
* @param {boolean} options.allowOverflow
* @param {Array<Object>} options.calendar
* @param {Date|string|number} options.endDate
* @param {Date|string|number} options.startDate
*
* @return {Array<Array<Object>>}
*/
function chunkMonths({ allowOverflow, calendar, endDate, startDate }) {
let prevMonth = -1;
startDate = normalizeDate(startDate);
endDate = normalizeDate(endDate);
return calendar.reduce((acc, day) => {
const currentMonth = day.date.getMonth();
if (prevMonth !== currentMonth) {
acc.push([]);
prevMonth = currentMonth;
}
if (
allowOverflow || (
(!startDate || day.date >= startDate) &&
(!endDate || day.date <= endDate)
)
) {
acc[acc.length - 1].push(day);
}
return acc;
}, []);
}
/**
* Divide a calendar into weeks.
*
* @param {Object} options
* @param {boolean} options.allowOverflow
* @param {Array<Object>} options.calendar
* @param {Date|string|number} options.endDate
* @param {Date|string|number} options.startDate
*
* @return {Array<Array<Object>>}
*/
function chunkWeeks({ allowOverflow, calendar, endDate, startDate }) {
startDate = normalizeDate(startDate);
endDate = normalizeDate(endDate);
return calendar.reduce((acc, day, index) => {
if (index % 7 === 0) {
acc.push([]);
}
if (
allowOverflow || (
(!startDate || day.date >= startDate) &&
(!endDate || day.date <= endDate)
)
) {
acc[acc.length - 1].push(day);
}
return acc;
}, []);
}
/**
* Determine the first day rendered on the heatmap.
*
* @param {Object} props
* @param {Array<string>} props.colors
* @param {Array<Object>} props.data
* @param {string} props.emptyColor
* @param {Date|number|string} props.endDate
* @param {Date|number|string} props.startDate
* @param {string} props.view
*
* @return {Date}
*/
function getCalendar({ colors, data, emptyColor, endDate, startDate, view }) {
startDate = startDate ? normalizeDate(startDate) : new Date();
endDate = endDate ? normalizeDate(endDate) : new Date();
if (view === 'monthly') {
startDate = getMonthStart(startDate);
endDate = getMonthEnd(endDate);
} else {
startDate = getWeekStart(startDate);
endDate = getWeekEnd(endDate);
}
let max = 0;
const startDayOfMonth = startDate.getDate();
const totalDays = Math.floor((endDate - startDate) / 86400000) + 1; // 86400000 = 1000 * 60 * 60 * 24
return new Array(totalDays)
.fill()
.map((x, offset) => {
const day = getDay({ data, offset, startDate, startDayOfMonth });
if (day.value > max) {
max = day.value;
}
return day;
})
.map(({ date, value }) => {
let color = getColor({ colors, max, value }) || emptyColor;
return { color, date, value }
});
}
/**
* Determine what color a value should be.
*
* @param {options} options
* @param {Array<string>} options.colors
* @param {number} options.max
* @param {number} options.value
*
* @return {string|null}
*/
function getColor({ colors, max, value }) {
if (colors.length && value) {
let color = colors[0];
const intencity = value / max;
for (let i = 1; i < colors.length; i++) {
if (intencity < i / colors.length) {
return color;
}
color = colors[i];
}
return colors[colors.length - 1];
}
return null;
}
/**
* Aggregate the value of each day.
*
* @param {Object} options
* @param {Array<Object>} options.data
* @param {number} options.offset
* @param {number} options.startDayOfMonth
* @param {Date} options.startDate
*
* @return {Object}
*/
function getDay({ data, offset, startDate, startDayOfMonth }) {
const date = new Date(startDate);
date.setDate(startDayOfMonth + offset);
const nextDate = new Date(date);
nextDate.setDate(date.getDate() + 1);
const value = data.reduce((acc, obj) => {
const datapoint = normalizeDate(obj.date);
return datapoint >= date && datapoint < nextDate ? acc + obj.value : acc;
}, 0);
return { date, value };
}
/* node_modules/svelte-heatmap/src/views/Cell.svelte generated by Svelte v3.32.3 */
function create_fragment(ctx) {
let rect;
let rect_data_date_value;
return {
c() {
rect = svg_element("rect");
attr(rect, "data-date", rect_data_date_value = stringifyDate(/*date*/ ctx[1]));
attr(rect, "data-value", /*value*/ ctx[4]);
attr(rect, "fill", /*color*/ ctx[0]);
attr(rect, "height", /*size*/ ctx[3]);
attr(rect, "rx", /*radius*/ ctx[2]);
attr(rect, "width", /*size*/ ctx[3]);
attr(rect, "x", /*x*/ ctx[5]);
attr(rect, "y", /*y*/ ctx[6]);
},
m(target, anchor) {
insert(target, rect, anchor);
},
p(ctx, [dirty]) {
if (dirty & /*date*/ 2 && rect_data_date_value !== (rect_data_date_value = stringifyDate(/*date*/ ctx[1]))) {
attr(rect, "data-date", rect_data_date_value);
}
if (dirty & /*value*/ 16) {
attr(rect, "data-value", /*value*/ ctx[4]);
}
if (dirty & /*color*/ 1) {
attr(rect, "fill", /*color*/ ctx[0]);
}
if (dirty & /*size*/ 8) {
attr(rect, "height", /*size*/ ctx[3]);
}
if (dirty & /*radius*/ 4) {
attr(rect, "rx", /*radius*/ ctx[2]);
}
if (dirty & /*size*/ 8) {
attr(rect, "width", /*size*/ ctx[3]);
}
if (dirty & /*x*/ 32) {
attr(rect, "x", /*x*/ ctx[5]);
}
if (dirty & /*y*/ 64) {
attr(rect, "y", /*y*/ ctx[6]);
}
},
i: noop,
o: noop,
d(detaching) {
if (detaching) detach(rect);
}
};
}
function instance($$self, $$props, $$invalidate) {
let { color } = $$props;
let { date } = $$props;
let { radius } = $$props;
let { size } = $$props;
let { value } = $$props;
let { x } = $$props;
let { y } = $$props;
$$self.$$set = $$props => {
if ("color" in $$props) $$invalidate(0, color = $$props.color);
if ("date" in $$props) $$invalidate(1, date = $$props.date);
if ("radius" in $$props) $$invalidate(2, radius = $$props.radius);
if ("size" in $$props) $$invalidate(3, size = $$props.size);
if ("value" in $$props) $$invalidate(4, value = $$props.value);
if ("x" in $$props) $$invalidate(5, x = $$props.x);
if ("y" in $$props) $$invalidate(6, y = $$props.y);
};
return [color, date, radius, size, value, x, y];
}
class Cell extends SvelteComponent {
constructor(options) {
super();
init(this, options, instance, create_fragment, safe_not_equal, {
color: 0,
date: 1,
radius: 2,
size: 3,
value: 4,
x: 5,
y: 6
});
}
}
/* node_modules/svelte-heatmap/src/views/Month.svelte generated by Svelte v3.32.3 */
function get_each_context(ctx, list, i) {
const child_ctx = ctx.slice();
child_ctx[13] = list[i];
return child_ctx;
}
// (2:4) {#each days as day}
function create_each_block(ctx) {
let cell;
let current;
cell = new Cell({
props: {
color: /*day*/ ctx[13].color,
date: /*day*/ ctx[13].date,
radius: /*cellRadius*/ ctx[0],
size: /*cellSize*/ ctx[2],
value: /*day*/ ctx[13].value,
x: /*day*/ ctx[13].date.getDay() * /*cellRect*/ ctx[1],
y: getWeekIndex(/*day*/ ctx[13].date) * /*cellRect*/ ctx[1] + /*monthLabelHeight*/ ctx[7]
}
});
return {
c() {
create_component(cell.$$.fragment);
},
m(target, anchor) {
mount_component(cell, target, anchor);
current = true;
},
p(ctx, dirty) {
const cell_changes = {};
if (dirty & /*days*/ 8) cell_changes.color = /*day*/ ctx[13].color;
if (dirty & /*days*/ 8) cell_changes.date = /*day*/ ctx[13].date;
if (dirty & /*cellRadius*/ 1) cell_changes.radius = /*cellRadius*/ ctx[0];
if (dirty & /*cellSize*/ 4) cell_changes.size = /*cellSize*/ ctx[2];
if (dirty & /*days*/ 8) cell_changes.value = /*day*/ ctx[13].value;
if (dirty & /*days, cellRect*/ 10) cell_changes.x = /*day*/ ctx[13].date.getDay() * /*cellRect*/ ctx[1];
if (dirty & /*days, cellRect, monthLabelHeight*/ 138) cell_changes.y = getWeekIndex(/*day*/ ctx[13].date) * /*cellRect*/ ctx[1] + /*monthLabelHeight*/ ctx[7];
cell.$set(cell_changes);
},
i(local) {
if (current) return;
transition_in(cell.$$.fragment, local);
current = true;
},
o(local) {
transition_out(cell.$$.fragment, local);
current = false;
},
d(detaching) {
destroy_component(cell, detaching);
}
};
}
// (13:4) {#if monthLabelHeight > 0}
function create_if_block(ctx) {
let text_1;
let t_value = /*monthLabels*/ ctx[8][/*days*/ ctx[3][0].date.getMonth()] + "";
let t;
return {
c() {
text_1 = svg_element("text");
t = text(t_value);
attr(text_1, "alignment-baseline", "hanging");
attr(text_1, "fill", /*fontColor*/ ctx[4]);
attr(text_1, "font-family", /*fontFamily*/ ctx[5]);
attr(text_1, "font-size", /*fontSize*/ ctx[6]);
attr(text_1, "x", "0");
attr(text_1, "y", "0");
},
m(target, anchor) {
insert(target, text_1, anchor);
append(text_1, t);
},
p(ctx, dirty) {
if (dirty & /*monthLabels, days*/ 264 && t_value !== (t_value = /*monthLabels*/ ctx[8][/*days*/ ctx[3][0].date.getMonth()] + "")) set_data(t, t_value);
if (dirty & /*fontColor*/ 16) {
attr(text_1, "fill", /*fontColor*/ ctx[4]);
}
if (dirty & /*fontFamily*/ 32) {
attr(text_1, "font-family", /*fontFamily*/ ctx[5]);
}
if (dirty & /*fontSize*/ 64) {
attr(text_1, "font-size", /*fontSize*/ ctx[6]);
}
},
d(detaching) {
if (detaching) detach(text_1);
}
};
}
function create_fragment$1(ctx) {
let g;
let each_1_anchor;
let g_transform_value;
let current;
let each_value = /*days*/ ctx[3];
let each_blocks = [];
for (let i = 0; i < each_value.length; i += 1) {
each_blocks[i] = create_each_block(get_each_context(ctx, each_value, i));
}
const out = i => transition_out(each_blocks[i], 1, 1, () => {
each_blocks[i] = null;
});
let if_block = /*monthLabelHeight*/ ctx[7] > 0 && create_if_block(ctx);
return {
c() {
g = svg_element("g");
for (let i = 0; i < each_blocks.length; i += 1) {
each_blocks[i].c();
}
each_1_anchor = empty();
if (if_block) if_block.c();
attr(g, "transform", g_transform_value = `translate(${/*translation*/ ctx[9]}, 0)`);
},
m(target, anchor) {
insert(target, g, anchor);
for (let i = 0; i < each_blocks.length; i += 1) {
each_blocks[i].m(g, null);
}
append(g, each_1_anchor);
if (if_block) if_block.m(g, null);
current = true;
},
p(ctx, [dirty]) {
if (dirty & /*days, cellRadius, cellSize, cellRect, getWeekIndex, monthLabelHeight*/ 143) {
each_value = /*days*/ ctx[3];
let i;
for (i = 0; i < each_value.length; i += 1) {
const child_ctx = get_each_context(ctx, each_value, i);
if (each_blocks[i]) {
each_blocks[i].p(child_ctx, dirty);
transition_in(each_blocks[i], 1);
} else {
each_blocks[i] = create_each_block(child_ctx);
each_blocks[i].c();
transition_in(each_blocks[i], 1);
each_blocks[i].m(g, each_1_anchor);
}
}
group_outros();
for (i = each_value.length; i < each_blocks.length; i += 1) {
out(i);
}
check_outros();
}
if (/*monthLabelHeight*/ ctx[7] > 0) {
if (if_block) {
if_block.p(ctx, dirty);
} else {
if_block = create_if_block(ctx);
if_block.c();
if_block.m(g, null);
}
} else if (if_block) {
if_block.d(1);
if_block = null;
}
if (!current || dirty & /*translation*/ 512 && g_transform_value !== (g_transform_value = `translate(${/*translation*/ ctx[9]}, 0)`)) {
attr(g, "transform", g_transform_value);
}
},
i(local) {
if (current) return;
for (let i = 0; i < each_value.length; i += 1) {
transition_in(each_blocks[i]);
}
current = true;
},
o(local) {
each_blocks = each_blocks.filter(Boolean);
for (let i = 0; i < each_blocks.length; i += 1) {
transition_out(each_blocks[i]);
}
current = false;
},
d(detaching) {
if (detaching) detach(g);
destroy_each(each_blocks, detaching);
if (if_block) if_block.d();
}
};
}
function instance$1($$self, $$props, $$invalidate) {
let translation;
let { cellGap } = $$props;
let { cellRadius } = $$props;
let { cellRect } = $$props;
let { cellSize } = $$props;
let { days } = $$props;
let { fontColor } = $$props;
let { fontFamily } = $$props;
let { fontSize } = $$props;
let { index } = $$props;
let { monthGap } = $$props;
let { monthLabelHeight } = $$props;
let { monthLabels } = $$props;
$$self.$$set = $$props => {
if ("cellGap" in $$props) $$invalidate(10, cellGap = $$props.cellGap);
if ("cellRadius" in $$props) $$invalidate(0, cellRadius = $$props.cellRadius);
if ("cellRect" in $$props) $$invalidate(1, cellRect = $$props.cellRect);
if ("cellSize" in $$props) $$invalidate(2, cellSize = $$props.cellSize);
if ("days" in $$props) $$invalidate(3, days = $$props.days);
if ("fontColor" in $$props) $$invalidate(4, fontColor = $$props.fontColor);
if ("fontFamily" in $$props) $$invalidate(5, fontFamily = $$props.fontFamily);
if ("fontSize" in $$props) $$invalidate(6, fontSize = $$props.fontSize);
if ("index" in $$props) $$invalidate(11, index = $$props.index);
if ("monthGap" in $$props) $$invalidate(12, monthGap = $$props.monthGap);
if ("monthLabelHeight" in $$props) $$invalidate(7, monthLabelHeight = $$props.monthLabelHeight);
if ("monthLabels" in $$props) $$invalidate(8, monthLabels = $$props.monthLabels);
};
$$self.$$.update = () => {
if ($$self.$$.dirty & /*cellRect, cellGap, monthGap, index*/ 7170) {
$$invalidate(9, translation = (7 * cellRect - cellGap + monthGap) * index);
}
};
return [
cellRadius,
cellRect,
cellSize,
days,
fontColor,
fontFamily,
fontSize,
monthLabelHeight,
monthLabels,
translation,
cellGap,
index,
monthGap
];
}
class Month extends SvelteComponent {
constructor(options) {
super();
init(this, options, instance$1, create_fragment$1, safe_not_equal, {
cellGap: 10,
cellRadius: 0,
cellRect: 1,
cellSize: 2,
days: 3,
fontColor: 4,
fontFamily: 5,
fontSize: 6,
index: 11,
monthGap: 12,
monthLabelHeight: 7,
monthLabels: 8
});
}
}
/* node_modules/svelte-heatmap/src/views/Week.svelte generated by Svelte v3.32.3 */
function get_each_context$1(ctx, list, i) {
const child_ctx = ctx.slice();
child_ctx[7] = list[i];
child_ctx[6] = i;
return child_ctx;
}
// (2:4) {#each days as day, index}
function create_each_block$1(ctx) {
let cell;
let current;
cell = new Cell({
props: {
color: /*day*/ ctx[7].color,
date: /*day*/ ctx[7].date,
radius: /*cellRadius*/ ctx[0],
size: /*cellSize*/ ctx[2],
value: /*day*/ ctx[7].value,
y: /*day*/ ctx[7].date.getDay() * /*cellRect*/ ctx[1]
}
});
return {
c() {
create_component(cell.$$.fragment);
},
m(target, anchor) {
mount_component(cell, target, anchor);
current = true;
},
p(ctx, dirty) {
const cell_changes = {};
if (dirty & /*days*/ 8) cell_changes.color = /*day*/ ctx[7].color;
if (dirty & /*days*/ 8) cell_changes.date = /*day*/ ctx[7].date;
if (dirty & /*cellRadius*/ 1) cell_changes.radius = /*cellRadius*/ ctx[0];
if (dirty & /*cellSize*/ 4) cell_changes.size = /*cellSize*/ ctx[2];
if (dirty & /*days*/ 8) cell_changes.value = /*day*/ ctx[7].value;
if (dirty & /*days, cellRect*/ 10) cell_changes.y = /*day*/ ctx[7].date.getDay() * /*cellRect*/ ctx[1];
cell.$set(cell_changes);
},
i(local) {
if (current) return;
transition_in(cell.$$.fragment, local);
current = true;
},
o(local) {
transition_out(cell.$$.fragment, local);
current = false;
},
d(detaching) {
destroy_component(cell, detaching);
}
};
}
function create_fragment$2(ctx) {
let g;
let g_transform_value;
let current;
let each_value = /*days*/ ctx[3];
let each_blocks = [];
for (let i = 0; i < each_value.length; i += 1) {
each_blocks[i] = create_each_block$1(get_each_context$1(ctx, each_value, i));
}
const out = i => transition_out(each_blocks[i], 1, 1, () => {
each_blocks[i] = null;
});
return {
c() {
g = svg_element("g");
for (let i = 0; i < each_blocks.length; i += 1) {
each_blocks[i].c();
}
attr(g, "transform", g_transform_value = `translate(${/*translation*/ ctx[5]}, ${/*monthLabelHeight*/ ctx[4]})`);
},
m(target, anchor) {
insert(target, g, anchor);
for (let i = 0; i < each_blocks.length; i += 1) {
each_blocks[i].m(g, null);
}
current = true;
},
p(ctx, [dirty]) {
if (dirty & /*days, cellRadius, cellSize, cellRect*/ 15) {
each_value = /*days*/ ctx[3];
let i;
for (i = 0; i < each_value.length; i += 1) {
const child_ctx = get_each_context$1(ctx, each_value, i);
if (each_blocks[i]) {
each_blocks[i].p(child_ctx, dirty);
transition_in(each_blocks[i], 1);
} else {
each_blocks[i] = create_each_block$1(child_ctx);
each_blocks[i].c();
transition_in(each_blocks[i], 1);
each_blocks[i].m(g, null);
}
}
group_outros();
for (i = each_value.length; i < each_blocks.length; i += 1) {
out(i);
}
check_outros();
}
if (!current || dirty & /*translation, monthLabelHeight*/ 48 && g_transform_value !== (g_transform_value = `translate(${/*translation*/ ctx[5]}, ${/*monthLabelHeight*/ ctx[4]})`)) {
attr(g, "transform", g_transform_value);
}
},
i(local) {
if (current) return;
for (let i = 0; i < each_value.length; i += 1) {
transition_in(each_blocks[i]);
}
current = true;
},
o(local) {
each_blocks = each_blocks.filter(Boolean);
for (let i = 0; i < each_blocks.length; i += 1) {
transition_out(each_blocks[i]);
}
current = false;
},
d(detaching) {
if (detaching) detach(g);
destroy_each(each_blocks, detaching);
}
};
}
function instance$2($$self, $$props, $$invalidate) {
let translation;
let { cellRadius } = $$props;
let { cellRect } = $$props;
let { cellSize } = $$props;
let { days } = $$props;
let { index } = $$props;
let { monthLabelHeight } = $$props;
$$self.$$set = $$props => {
if ("cellRadius" in $$props) $$invalidate(0, cellRadius = $$props.cellRadius);
if ("cellRect" in $$props) $$invalidate(1, cellRect = $$props.cellRect);
if ("cellSize" in $$props) $$invalidate(2, cellSize = $$props.cellSize);
if ("days" in $$props) $$invalidate(3, days = $$props.days);
if ("index" in $$props) $$invalidate(6, index = $$props.index);
if ("monthLabelHeight" in $$props) $$invalidate(4, monthLabelHeight = $$props.monthLabelHeight);
};
$$self.$$.update = () => {
if ($$self.$$.dirty & /*cellRect, index*/ 66) {
$$invalidate(5, translation = cellRect * index);
}
};
return [cellRadius, cellRect, cellSize, days, monthLabelHeight, translation, index];
}
class Week extends SvelteComponent {
constructor(options) {
super();
init(this, options, instance$2, create_fragment$2, safe_not_equal, {
cellRadius: 0,
cellRect: 1,
cellSize: 2,
days: 3,
index: 6,
monthLabelHeight: 4
});
}
}
/* node_modules/svelte-heatmap/src/SvelteHeatmap.svelte generated by Svelte v3.32.3 */
function get_each_context_1(ctx, list, i) {
const child_ctx = ctx.slice();
child_ctx[26] = list[i];
child_ctx[28] = i;
return child_ctx;
}
function get_each_context_2(ctx, list, i) {
const child_ctx = ctx.slice();
child_ctx[30] = list[i];
child_ctx[28] = i;
return child_ctx;
}
function get_each_context$2(ctx, list, i) {
const child_ctx = ctx.slice();
child_ctx[26] = list[i];
child_ctx[28] = i;
return child_ctx;
}
// (19:4) {:else}
function create_else_block(ctx) {
let g;
let g_transform_value;
let current;
let if_block = /*dayLabelWidth*/ ctx[3] > 0 && create_if_block_2(ctx);
let each_value_1 = /*chunks*/ ctx[13];
let each_blocks = [];
for (let i = 0; i < each_value_1.length; i += 1) {
each_blocks[i] = create_each_block_1(get_each_context_1(ctx, each_value_1, i));
}
const out = i => transition_out(each_blocks[i], 1, 1, () => {
each_blocks[i] = null;
});
return {
c() {
if (if_block) if_block.c();
g = svg_element("g");
for (let i = 0; i < each_blocks.length; i += 1) {
each_blocks[i].c();
}
attr(g, "transform", g_transform_value = `translate(${/*dayLabelWidth*/ ctx[3]})`);
},
m(target, anchor) {
if (if_block) if_block.m(target, anchor);
insert(target, g, anchor);
for (let i = 0; i < each_blocks.length; i += 1) {
each_blocks[i].m(g, null);
}
current = true;
},
p(ctx, dirty) {
if (/*dayLabelWidth*/ ctx[3] > 0) {
if (if_block) {
if_block.p(ctx, dirty);
} else {
if_block = create_if_block_2(ctx);
if_block.c();
if_block.m(g.parentNode, g);
}
} else if (if_block) {
if_block.d(1);
if_block = null;
}
if (dirty[0] & /*fontColor, fontFamily, fontSize, cellRect, monthLabels, chunks, monthLabelHeight, isNewMonth, cellRadius, cellSize*/ 145126) {
each_value_1 = /*chunks*/ ctx[13];
let i;
for (i = 0; i < each_value_1.length; i += 1) {
const child_ctx = get_each_context_1(ctx, each_value_1, i);
if (each_blocks[i]) {
each_blocks[i].p(child_ctx, dirty);
transition_in(each_blocks[i], 1);
} else {
each_blocks[i] = create_each_block_1(child_ctx);
each_blocks[i].c();
transition_in(each_blocks[i], 1);
each_blocks[i].m(g, null);
}
}
group_outros();
for (i = each_value_1.length; i < each_blocks.length; i += 1) {
out(i);
}
check_outros();
}
if (!current || dirty[0] & /*dayLabelWidth*/ 8 && g_transform_value !== (g_transform_value = `translate(${/*dayLabelWidth*/ ctx[3]})`)) {
attr(g, "transform", g_transform_value);
}
},
i(local) {
if (current) return;
for (let i = 0; i < each_value_1.length; i += 1) {
transition_in(each_blocks[i]);
}
current = true;
},
o(local) {
each_blocks = each_blocks.filter(Boolean);
for (let i = 0; i < each_blocks.length; i += 1) {
transition_out(each_blocks[i]);
}
current = false;
},
d(detaching) {
if (if_block) if_block.d(detaching);
if (detaching) detach(g);
destroy_each(each_blocks, detaching);
}
};
}
// (2:4) {#if view === 'monthly'}
function create_if_block$1(ctx) {
let each_1_anchor;
let current;
let each_value = /*chunks*/ ctx[13];
let each_blocks = [];
for (let i = 0; i < each_value.length; i += 1) {
each_blocks[i] = create_each_block$2(get_each_context$2(ctx, each_value, i));
}
const out = i => transition_out(each_blocks[i], 1, 1, () => {
each_blocks[i] = null;
});
return {
c() {
for (let i = 0; i < each_blocks.length; i += 1) {
each_blocks[i].c();
}
each_1_anchor = empty();
},
m(target, anchor) {
for (let i = 0; i < each_blocks.length; i += 1) {
each_blocks[i].m(target, anchor);
}
insert(target, each_1_anchor, anchor);
current = true;
},
p(ctx, dirty) {
if (dirty[0] & /*cellGap, cellRadius, cellRect, cellSize, chunks, fontColor, fontFamily, fontSize, monthGap, monthLabelHeight, monthLabels*/ 14311) {
each_value = /*chunks*/ ctx[13];
let i;
for (i = 0; i < each_value.length; i += 1) {
const child_ctx = get_each_context$2(ctx, each_value, i);
if (each_blocks[i]) {
each_blocks[i].p(child_ctx, dirty);
transition_in(each_blocks[i], 1);
} else {
each_blocks[i] = create_each_block$2(child_ctx);
each_blocks[i].c();
transition_in(each_blocks[i], 1);
each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor);
}
}
group_outros();
for (i = each_value.length; i < each_blocks.length; i += 1) {
out(i);
}
check_outros();
}
},
i(local) {
if (current) return;
for (let i = 0; i < each_value.length; i += 1) {
transition_in(each_blocks[i]);
}
current = true;
},
o(local) {
each_blocks = each_blocks.filter(Boolean);
for (let i = 0; i < each_blocks.length; i += 1) {
transition_out(each_blocks[i]);
}
current = false;
},
d(detaching) {
destroy_each(each_blocks, detaching);
if (detaching) detach(each_1_anchor);
}
};
}
// (20:8) {#if dayLabelWidth > 0}
function create_if_block_2(ctx) {
let each_1_anchor;
let each_value_2 = /*dayLabels*/ ctx[4];
let each_blocks = [];
for (let i = 0; i < each_value_2.length; i += 1) {
each_blocks[i] = create_each_block_2(get_each_context_2(ctx, each_value_2, i));
}
return {
c() {
for (let i = 0; i < each_blocks.length; i += 1) {
each_blocks[i].c();
}
each_1_anchor = empty();
},
m(target, anchor) {
for (let i = 0; i < each_blocks.length; i += 1) {
each_blocks[i].m(target, anchor);
}
insert(target, each_1_anchor, anchor);
},
p(ctx, dirty) {
if (dirty[0] & /*fontColor, fontFamily, fontSize, dayLabelPosition, dayLabels*/ 65776) {
each_value_2 = /*dayLabels*/ ctx[4];
let i;
for (i = 0; i < each_value_2.length; i += 1) {
const child_ctx = get_each_context_2(ctx, each_value_2, i);
if (each_blocks[i]) {
each_blocks[i].p(child_ctx, dirty);
} else {
each_blocks[i] = create_each_block_2(child_ctx);
each_blocks[i].c();
each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor);
}
}
for (; i < each_blocks.length; i += 1) {
each_blocks[i].d(1);
}
each_blocks.length = each_value_2.length;
}
},
d(detaching) {
destroy_each(each_blocks, detaching);
if (detaching) detach(each_1_anchor);
}
};
}
// (21:12) {#each dayLabels as label, index}
function create_each_block_2(ctx) {
let text_1;
let t_value = /*label*/ ctx[30] + "";
let t;
let text_1_y_value;
return {
c() {
text_1 = svg_element("text");
t = text(t_value);
attr(text_1, "alignment-baseline", "middle");
attr(text_1, "fill", /*fontColor*/ ctx[5]);
attr(text_1, "font-family", /*fontFamily*/ ctx[6]);
attr(text_1, "font-size", /*fontSize*/ ctx[7]);
attr(text_1, "x", "0");
attr(text_1, "y", text_1_y_value = /*dayLabelPosition*/ ctx[16](/*index*/ ctx[28]));
},
m(target, anchor) {
insert(target, text_1, anchor);
append(text_1, t);
},
p(ctx, dirty) {
if (dirty[0] & /*dayLabels*/ 16 && t_value !== (t_value = /*label*/ ctx[30] + "")) set_data(t, t_value);
if (dirty[0] & /*fontColor*/ 32) {
attr(text_1, "fill", /*fontColor*/ ctx[5]);
}
if (dirty[0] & /*fontFamily*/ 64) {
attr(text_1, "font-family", /*fontFamily*/ ctx[6]);
}
if (dirty[0] & /*fontSize*/ 128) {
attr(text_1, "font-size", /*fontSize*/ ctx[7]);
}
if (dirty[0] & /*dayLabelPosition*/ 65536 && text_1_y_value !== (text_1_y_value = /*dayLabelPosition*/ ctx[16](/*index*/ ctx[28]))) {
attr(text_1, "y", text_1_y_value);
}
},
d(detaching) {
if (detaching) detach(text_1);
}
};
}
// (43:16) {#if monthLabelHeight > 0 && isNewMonth(chunks, index)}
function create_if_block_1(ctx) {
let text_1;
let t_value = /*monthLabels*/ ctx[10][/*chunk*/ ctx[26][0].date.getMonth()] + "";
let t;
let text_1_x_value;
return {
c() {
text_1 = svg_element("text");
t = text(t_value);
attr(text_1, "alignment-baseline", "hanging");
attr(text_1, "fill", /*fontColor*/ ctx[5]);
attr(text_1, "font-family", /*fontFamily*/ ctx[6]);
attr(text_1, "font-size", /*fontSize*/ ctx[7]);
attr(text_1, "x", text_1_x_value = /*cellRect*/ ctx[12] * /*index*/ ctx[28]);
},
m(target, anchor) {
insert(target, text_1, anchor);
append(text_1, t);
},
p(ctx, dirty) {
if (dirty[0] & /*monthLabels, chunks*/ 9216 && t_value !== (t_value = /*monthLabels*/ ctx[10][/*chunk*/ ctx[26][0].date.getMonth()] + "")) set_data(t, t_value);
if (dirty[0] & /*fontColor*/ 32) {
attr(text_1, "fill", /*fontColor*/ ctx[5]);
}
if (dirty[0] & /*fontFamily*/ 64) {
attr(text_1, "font-family", /*fontFamily*/ ctx[6]);
}
if (dirty[0] & /*fontSize*/ 128) {
attr(text_1, "font-size", /*fontSize*/ ctx[7]);
}
if (dirty[0] & /*cellRect*/ 4096 && text_1_x_value !== (text_1_x_value = /*cellRect*/ ctx[12] * /*index*/ ctx[28])) {
attr(text_1, "x", text_1_x_value);
}
},
d(detaching) {
if (detaching) detach(text_1);
}
};
}
// (34:12) {#each chunks as chunk, index}
function create_each_block_1(ctx) {
let week;
let show_if = /*monthLabelHeight*/ ctx[9] > 0 && /*isNewMonth*/ ctx[17](/*chunks*/ ctx[13], /*index*/ ctx[28]);
let if_block_anchor;
let current;
week = new Week({
props: {
cellRadius: /*cellRadius*/ ctx[1],
cellRect: /*cellRect*/ ctx[12],
cellSize: /*cellSize*/ ctx[2],
days: /*chunk*/ ctx[26],
index: /*index*/ ctx[28],
monthLabelHeight: /*monthLabelHeight*/ ctx[9]
}
});
let if_block = show_if && create_if_block_1(ctx);
return {
c() {
create_component(week.$$.fragment);
if (if_block) if_block.c();
if_block_anchor = empty();
},
m(target, anchor) {
mount_component(week, target, anchor);
if (if_block) if_block.m(target, anchor);
insert(target, if_block_anchor, anchor);
current = true;
},
p(ctx, dirty) {
const week_changes = {};
if (dirty[0] & /*cellRadius*/ 2) week_changes.cellRadius = /*cellRadius*/ ctx[1];
if (dirty[0] & /*cellRect*/ 4096) week_changes.cellRect = /*cellRect*/ ctx[12];
if (dirty[0] & /*cellSize*/ 4) week_changes.cellSize = /*cellSize*/ ctx[2];
if (dirty[0] & /*chunks*/ 8192) week_changes.days = /*chunk*/ ctx[26];
if (dirty[0] & /*monthLabelHeight*/ 512) week_changes.monthLabelHeight = /*monthLabelHeight*/ ctx[9];
week.$set(week_changes);
if (dirty[0] & /*monthLabelHeight, chunks*/ 8704) show_if = /*monthLabelHeight*/ ctx[9] > 0 && /*isNewMonth*/ ctx[17](/*chunks*/ ctx[13], /*index*/ ctx[28]);
if (show_if) {
if (if_block) {
if_block.p(ctx, dirty);
} else {
if_block = create_if_block_1(ctx);
if_block.c();
if_block.m(if_block_anchor.parentNode, if_block_anchor);
}
} else if (if_block) {
if_block.d(1);
if_block = null;
}
},
i(local) {
if (current) return;
transition_in(week.$$.fragment, local);
current = true;
},
o(local) {
transition_out(week.$$.fragment, local);
current = false;
},
d(detaching) {
destroy_component(week, detaching);
if (if_block) if_block.d(detaching);
if (detaching) detach(if_block_anchor);
}
};
}
// (3:8) {#each chunks as chunk, index}
function create_each_block$2(ctx) {
let month;
let current;
month = new Month({
props: {
cellGap: /*cellGap*/ ctx[0],
cellRadius: /*cellRadius*/ ctx[1],
cellRect: /*cellRect*/ ctx[12],
cellSize: /*cellSize*/ ctx[2],
days: /*chunk*/ ctx[26],
fontColor: /*fontColor*/ ctx[5],
fontFamily: /*fontFamily*/ ctx[6],
fontSize: /*fontSize*/ ctx[7],
index: /*index*/ ctx[28],
monthGap: /*monthGap*/ ctx[8],
monthLabelHeight: /*monthLabelHeight*/ ctx[9],
monthLabels: /*monthLabels*/ ctx[10]
}
});
return {
c() {
create_component(month.$$.fragment);
},
m(target, anchor) {
mount_component(month, target, anchor);
current = true;
},
p(ctx, dirty) {
const month_changes = {};
if (dirty[0] & /*cellGap*/ 1) month_changes.cellGap = /*cellGap*/ ctx[0];
if (dirty[0] & /*cellRadius*/ 2) month_changes.cellRadius = /*cellRadius*/ ctx[1];
if (dirty[0] & /*cellRect*/ 4096) month_changes.cellRect = /*cellRect*/ ctx[12];
if (dirty[0] & /*cellSize*/ 4) month_changes.cellSize = /*cellSize*/ ctx[2];
if (dirty[0] & /*chunks*/ 8192) month_changes.days = /*chunk*/ ctx[26];
if (dirty[0] & /*fontColor*/ 32) month_changes.fontColor = /*fontColor*/ ctx[5];
if (dirty[0] & /*fontFamily*/ 64) month_changes.fontFamily = /*fontFamily*/ ctx[6];
if (dirty[0] & /*fontSize*/ 128) month_changes.fontSize = /*fontSize*/ ctx[7];
if (dirty[0] & /*monthGap*/ 256) month_changes.monthGap = /*monthGap*/ ctx[8];
if (dirty[0] & /*monthLabelHeight*/ 512) month_changes.monthLabelHeight = /*monthLabelHeight*/ ctx[9];
if (dirty[0] & /*monthLabels*/ 1024) month_changes.monthLabels = /*monthLabels*/ ctx[10];
month.$set(month_changes);
},
i(local) {
if (current) return;
transition_in(month.$$.fragment, local);
current = true;
},
o(local) {
transition_out(month.$$.fragment, local);
current = false;
},
d(detaching) {
destroy_component(month, detaching);
}
};
}
function create_fragment$3(ctx) {
let svg;
let current_block_type_index;
let if_block;
let svg_viewBox_value;
let current;
const if_block_creators = [create_if_block$1, create_else_block];
const if_blocks = [];
function select_block_type(ctx, dirty) {
if (/*view*/ ctx[11] === "monthly") return 0;
return 1;
}
current_block_type_index = select_block_type(ctx);
if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
return {
c() {
svg = svg_element("svg");
if_block.c();
attr(svg, "viewBox", svg_viewBox_value = `0 0 ${/*width*/ ctx[15]} ${/*height*/ ctx[14]}`);
},
m(target, anchor) {
insert(target, svg, anchor);
if_blocks[current_block_type_index].m(svg, null);
current = true;
},
p(ctx, dirty) {
let previous_block_index = current_block_type_index;
current_block_type_index = select_block_type(ctx);
if (current_block_type_index === previous_block_index) {
if_blocks[current_block_type_index].p(ctx, dirty);
} else {
group_outros();
transition_out(if_blocks[previous_block_index], 1, 1, () => {
if_blocks[previous_block_index] = null;
});
check_outros();
if_block = if_blocks[current_block_type_index];
if (!if_block) {
if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
if_block.c();
} else {
if_block.p(ctx, dirty);
}
transition_in(if_block, 1);
if_block.m(svg, null);
}
if (!current || dirty[0] & /*width, height*/ 49152 && svg_viewBox_value !== (svg_viewBox_value = `0 0 ${/*width*/ ctx[15]} ${/*height*/ ctx[14]}`)) {
attr(svg, "viewBox", svg_viewBox_value);
}
},
i(local) {
if (current) return;
transition_in(if_block);
current = true;
},
o(local) {
transition_out(if_block);
current = false;
},
d(detaching) {
if (detaching) detach(svg);
if_blocks[current_block_type_index].d();
}
};
}
function instance$3($$self, $$props, $$invalidate) {
let cellRect;
let calendar;
let chunks;
let weekRect;
let height;
let width;
let dayLabelPosition;
let { allowOverflow = false } = $$props;
let { cellGap = 2 } = $$props;
let { cellRadius = 0 } = $$props;
let { cellSize = 10 } = $$props;
let { colors = ["#c6e48b", "#7bc96f", "#239a3b", "#196127"] } = $$props;
let { data = [] } = $$props;
let { dayLabelWidth = 20 } = $$props;
let { dayLabels = ["", "Mon", "", "Wed", "", "Fri", ""] } = $$props;
let { emptyColor = "#ebedf0" } = $$props;
let { endDate = null } = $$props;
let { fontColor = "#333" } = $$props;
let { fontFamily = "sans-serif" } = $$props;
let { fontSize = 8 } = $$props;
let { monthGap = 2 } = $$props;
let { monthLabelHeight = 12 } = $$props;
let { monthLabels = [
"Jan",
"Feb",
"Mar",
"Apr",
"May",
"Jun",
"Jul",
"Aug",
"Sep",
"Oct",
"Nov",
"Dec"
] } = $$props;
let { startDate = null } = $$props;
let { view = "weekly" } = $$props;
const isNewMonth = (chunks, index) => {
const chunk = chunks[index];
const prev = chunks[index - 1];
if (!prev) {
return true;
}
if (!prev.length || !chunk.length) {
return false;
}
const currentIndex = chunk[0].date.getMonth();
const prevIndex = prev[0].date.getMonth();
return index < chunks.length && index < chunks.length - 1 && (currentIndex > prevIndex || currentIndex === 0 && prevIndex === 11);
};
$$self.$$set = $$props => {
if ("allowOverflow" in $$props) $$invalidate(18, allowOverflow = $$props.allowOverflow);
if ("cellGap" in $$props) $$invalidate(0, cellGap = $$props.cellGap);
if ("cellRadius" in $$props) $$invalidate(1, cellRadius = $$props.cellRadius);
if ("cellSize" in $$props) $$invalidate(2, cellSize = $$props.cellSize);
if ("colors" in $$props) $$invalidate(19, colors = $$props.colors);
if ("data" in $$props) $$invalidate(20, data = $$props.data);
if ("dayLabelWidth" in $$props) $$invalidate(3, dayLabelWidth = $$props.dayLabelWidth);
if ("dayLabels" in $$props) $$invalidate(4, dayLabels = $$props.dayLabels);
if ("emptyColor" in $$props) $$invalidate(21, emptyColor = $$props.emptyColor);
if ("endDate" in $$props) $$invalidate(22, endDate = $$props.endDate);
if ("fontColor" in $$props) $$invalidate(5, fontColor = $$props.fontColor);
if ("fontFamily" in $$props) $$invalidate(6, fontFamily = $$props.fontFamily);
if ("fontSize" in $$props) $$invalidate(7, fontSize = $$props.fontSize);
if ("monthGap" in $$props) $$invalidate(8, monthGap = $$props.monthGap);
if ("monthLabelHeight" in $$props) $$invalidate(9, monthLabelHeight = $$props.monthLabelHeight);
if ("monthLabels" in $$props) $$invalidate(10, monthLabels = $$props.monthLabels);
if ("startDate" in $$props) $$invalidate(23, startDate = $$props.startDate);
if ("view" in $$props) $$invalidate(11, view = $$props.view);
};
$$self.$$.update = () => {
if ($$self.$$.dirty[0] & /*cellSize, cellGap*/ 5) {
$$invalidate(12, cellRect = cellSize + cellGap);
}
if ($$self.$$.dirty[0] & /*allowOverflow, colors, data, emptyColor, endDate, startDate, view*/ 16517120) {
$$invalidate(24, calendar = getCalendar({
allowOverflow,
colors,
data,
emptyColor,
endDate,
startDate,
view
}));
}
if ($$self.$$.dirty[0] & /*view, allowOverflow, calendar, endDate, startDate*/ 29624320) {
$$invalidate(13, chunks = view === "monthly"
? chunkMonths({
allowOverflow,
calendar,
endDate,
startDate
})
: chunkWeeks({
allowOverflow,
calendar,
endDate,
startDate
}));
}
if ($$self.$$.dirty[0] & /*cellRect, cellGap*/ 4097) {
$$invalidate(25, weekRect = 7 * cellRect - cellGap);
}
if ($$self.$$.dirty[0] & /*view, cellRect, cellGap, monthLabelHeight, weekRect*/ 33561089) {
$$invalidate(14, height = view === "monthly"
? 6 * cellRect - cellGap + monthLabelHeight
: weekRect + monthLabelHeight); // <- max of 6 rows in monthly view
}
if ($$self.$$.dirty[0] & /*view, weekRect, monthGap, chunks, cellRect, cellGap, dayLabelWidth*/ 33569033) {
$$invalidate(15, width = view === "monthly"
? (weekRect + monthGap) * chunks.length - monthGap
: cellRect * chunks.length - cellGap + dayLabelWidth);
}
if ($$self.$$.dirty[0] & /*cellRect, monthLabelHeight*/ 4608) {
$$invalidate(16, dayLabelPosition = index => {
return cellRect * index + cellRect / 2 + monthLabelHeight;
});
}
};
return [
cellGap,
cellRadius,
cellSize,
dayLabelWidth,
dayLabels,
fontColor,
fontFamily,
fontSize,
monthGap,
monthLabelHeight,
monthLabels,
view,
cellRect,
chunks,
height,
width,
dayLabelPosition,
isNewMonth,
allowOverflow,
colors,
data,
emptyColor,
endDate,
startDate,
calendar,
weekRect
];
}
class SvelteHeatmap extends SvelteComponent {
constructor(options) {
super();
init(
this,
options,
instance$3,
create_fragment$3,
safe_not_equal,
{
allowOverflow: 18,
cellGap: 0,
cellRadius: 1,
cellSize: 2,
colors: 19,
data: 20,
dayLabelWidth: 3,
dayLabels: 4,
emptyColor: 21,
endDate: 22,
fontColor: 5,
fontFamily: 6,
fontSize: 7,
monthGap: 8,
monthLabelHeight: 9,
monthLabels: 10,
startDate: 23,
view: 11
},
[-1, -1]
);
}
}
SvelteHeatmap.VERSION = '1.0.2';
/* src/svelte/ActivityHeatmap.svelte generated by Svelte v3.32.3 */
function create_fragment$4(ctx) {
let svelteheatmap;
let current;
svelteheatmap = new SvelteHeatmap({
props: {
data: /*data*/ ctx[0],
view: /*type*/ ctx[5],
startDate: /*startDate*/ ctx[7],
endDate: /*endDate*/ ctx[8],
monthLabels: /*monthlabel*/ ctx[6],
allowOverflow: "true",
colors: /*colors*/ ctx[1],
fontColor: /*textColor*/ ctx[2],
emptyColor: /*emptyColor*/ ctx[3],
cellRadius: /*cellRadius*/ ctx[4]
}
});
return {
c() {
create_component(svelteheatmap.$$.fragment);
},
m(target, anchor) {
mount_component(svelteheatmap, target, anchor);
current = true;
},
p(ctx, [dirty]) {
const svelteheatmap_changes = {};
if (dirty & /*data*/ 1) svelteheatmap_changes.data = /*data*/ ctx[0];
if (dirty & /*type*/ 32) svelteheatmap_changes.view = /*type*/ ctx[5];
if (dirty & /*monthlabel*/ 64) svelteheatmap_changes.monthLabels = /*monthlabel*/ ctx[6];
if (dirty & /*colors*/ 2) svelteheatmap_changes.colors = /*colors*/ ctx[1];
if (dirty & /*textColor*/ 4) svelteheatmap_changes.fontColor = /*textColor*/ ctx[2];
if (dirty & /*emptyColor*/ 8) svelteheatmap_changes.emptyColor = /*emptyColor*/ ctx[3];
if (dirty & /*cellRadius*/ 16) svelteheatmap_changes.cellRadius = /*cellRadius*/ ctx[4];
svelteheatmap.$set(svelteheatmap_changes);
},
i(local) {
if (current) return;
transition_in(svelteheatmap.$$.fragment, local);
current = true;
},
o(local) {
transition_out(svelteheatmap.$$.fragment, local);
current = false;
},
d(detaching) {
destroy_component(svelteheatmap, detaching);
}
};
}
function instance$4($$self, $$props, $$invalidate) {
let { year } = $$props;
let { data } = $$props;
let { colors = ["#a1dab4", "#42b6c4", "#2c7fb9", "#263494"] } = $$props;
let { textColor } = $$props;
let { emptyColor = "#ecedf0" } = $$props;
let { cellRadius = 1 } = $$props;
let { type = "yearly" } = $$props;
let startDate = `${year}/01/01`;
let endDate = `${year}/12/31`;
let monthlabel = [
"",
"Feb",
"Mar",
"Apr",
"May",
"Jun",
"Jul",
"Aug",
"Sep",
"Oct",
"Nov",
"Dec"
];
if (type == "monthly") {
monthlabel = [
"Jan",
"Feb",
"Mar",
"Apr",
"May",
"Jun",
"Jul",
"Aug",
"Sep",
"Oct",
"Nov",
"Dec"
];
}
$$self.$$set = $$props => {
if ("year" in $$props) $$invalidate(9, year = $$props.year);
if ("data" in $$props) $$invalidate(0, data = $$props.data);
if ("colors" in $$props) $$invalidate(1, colors = $$props.colors);
if ("textColor" in $$props) $$invalidate(2, textColor = $$props.textColor);
if ("emptyColor" in $$props) $$invalidate(3, emptyColor = $$props.emptyColor);
if ("cellRadius" in $$props) $$invalidate(4, cellRadius = $$props.cellRadius);
if ("type" in $$props) $$invalidate(5, type = $$props.type);
};
return [
data,
colors,
textColor,
emptyColor,
cellRadius,
type,
monthlabel,
startDate,
endDate,
year
];
}
class ActivityHeatmap extends SvelteComponent {
constructor(options) {
super();
init(this, options, instance$4, create_fragment$4, safe_not_equal, {
year: 9,
data: 0,
colors: 1,
textColor: 2,
emptyColor: 3,
cellRadius: 4,
type: 5
});
}
}
/* src/svelte/SelectYear.svelte generated by Svelte v3.32.3 */
function get_each_context$3(ctx, list, i) {
const child_ctx = ctx.slice();
child_ctx[4] = list[i];
child_ctx[6] = i;
return child_ctx;
}
// (8:2) {#each options as option, i}
function create_each_block$3(ctx) {
let option;
let t_value = /*display_func*/ ctx[2](/*option*/ ctx[4]) + "";
let t;
return {
c() {
option = element("option");
t = text(t_value);
option.__value = /*i*/ ctx[6];
option.value = option.__value;
},
m(target, anchor) {
insert(target, option, anchor);
append(option, t);
},
p(ctx, dirty) {
if (dirty & /*display_func, options*/ 6 && t_value !== (t_value = /*display_func*/ ctx[2](/*option*/ ctx[4]) + "")) set_data(t, t_value);
},
d(detaching) {
if (detaching) detach(option);
}
};
}
function create_fragment$5(ctx) {
let select;
let mounted;
let dispose;
let each_value = /*options*/ ctx[1];
let each_blocks = [];
for (let i = 0; i < each_value.length; i += 1) {
each_blocks[i] = create_each_block$3(get_each_context$3(ctx, each_value, i));
}
return {
c() {
select = element("select");
for (let i = 0; i < each_blocks.length; i += 1) {
each_blocks[i].c();
}
attr(select, "class", "selectYear");
if (/*index*/ ctx[0] === void 0) add_render_callback(() => /*select_change_handler*/ ctx[3].call(select));
},
m(target, anchor) {
insert(target, select, anchor);
for (let i = 0; i < each_blocks.length; i += 1) {
each_blocks[i].m(select, null);
}
select_option(select, /*index*/ ctx[0]);
if (!mounted) {
dispose = listen(select, "change", /*select_change_handler*/ ctx[3]);
mounted = true;
}
},
p(ctx, [dirty]) {
if (dirty & /*display_func, options*/ 6) {
each_value = /*options*/ ctx[1];
let i;
for (i = 0; i < each_value.length; i += 1) {
const child_ctx = get_each_context$3(ctx, each_value, i);
if (each_blocks[i]) {
each_blocks[i].p(child_ctx, dirty);
} else {
each_blocks[i] = create_each_block$3(child_ctx);
each_blocks[i].c();
each_blocks[i].m(select, null);
}
}
for (; i < each_blocks.length; i += 1) {
each_blocks[i].d(1);
}
each_blocks.length = each_value.length;
}
if (dirty & /*index*/ 1) {
select_option(select, /*index*/ ctx[0]);
}
},
i: noop,
o: noop,
d(detaching) {
if (detaching) detach(select);
destroy_each(each_blocks, detaching);
mounted = false;
dispose();
}
};
}
function instance$5($$self, $$props, $$invalidate) {
let { options = [] } = $$props;
let { display_func = value => value } = $$props;
let { index = 0 } = $$props;
function select_change_handler() {
index = select_value(this);
$$invalidate(0, index);
}
$$self.$$set = $$props => {
if ("options" in $$props) $$invalidate(1, options = $$props.options);
if ("display_func" in $$props) $$invalidate(2, display_func = $$props.display_func);
if ("index" in $$props) $$invalidate(0, index = $$props.index);
};
return [index, options, display_func, select_change_handler];
}
class SelectYear extends SvelteComponent {
constructor(options) {
super();
init(this, options, instance$5, create_fragment$5, safe_not_equal, { options: 1, display_func: 2, index: 0 });
}
}
/* src/svelte/Year.svelte generated by Svelte v3.32.3 */
function create_fragment$6(ctx) {
let div;
let selectyear;
let updating_value;
let current;
function selectyear_value_binding(value) {
/*selectyear_value_binding*/ ctx[2](value);
}
let selectyear_props = {
options: /*options*/ ctx[0],
display_func: func
};
if (/*selected*/ ctx[1] !== void 0) {
selectyear_props.value = /*selected*/ ctx[1];
}
selectyear = new SelectYear({ props: selectyear_props });
binding_callbacks.push(() => bind(selectyear, "value", selectyear_value_binding));
return {
c() {
div = element("div");
create_component(selectyear.$$.fragment);
},
m(target, anchor) {
insert(target, div, anchor);
mount_component(selectyear, div, null);
current = true;
},
p(ctx, [dirty]) {
const selectyear_changes = {};
if (dirty & /*options*/ 1) selectyear_changes.options = /*options*/ ctx[0];
if (!updating_value && dirty & /*selected*/ 2) {
updating_value = true;
selectyear_changes.value = /*selected*/ ctx[1];
add_flush_callback(() => updating_value = false);
}
selectyear.$set(selectyear_changes);
},
i(local) {
if (current) return;
transition_in(selectyear.$$.fragment, local);
current = true;
},
o(local) {
transition_out(selectyear.$$.fragment, local);
current = false;
},
d(detaching) {
if (detaching) detach(div);
destroy_component(selectyear);
}
};
}
const func = o => o.year;
function instance$6($$self, $$props, $$invalidate) {
let { options = [
{
year: new Date().getFullYear().toString()
}
] } = $$props;
let selected;
function selectyear_value_binding(value) {
selected = value;
$$invalidate(1, selected);
}
$$self.$$set = $$props => {
if ("options" in $$props) $$invalidate(0, options = $$props.options);
};
return [options, selected, selectyear_value_binding];
}
class Year extends SvelteComponent {
constructor(options) {
super();
init(this, options, instance$6, create_fragment$6, safe_not_equal, { options: 0 });
}
}
class ActivityHistoryProcessor {
async run(source, el, settings) {
var _a;
source = source.trim();
let currentYear = new Date().getFullYear().toString();
let elCanvas = el.createDiv({ cls: 'ObsidianHistoryBlock' });
let yearSelect = elCanvas.createDiv({ attr: { id: 'SelectYear' } });
let boardEL = elCanvas.createDiv({ cls: 'HistoryBoard', attr: { id: 'HistoryBoard' } });
// Check if project is being tracked
if (!isTracked(source, settings.trackedProjects)) {
// Show warning message
boardEL.setText(`Specified project ${source} is not a tracked project.`);
return;
}
// Valid project, add the different svelte component
// Get year ranges for the specified object
let yearRange = getYearRange(source, settings.activityHistory);
// Add current year to the selection
if (yearRange.every(x => x.year != currentYear)) {
yearRange.unshift({ year: currentYear });
}
// Add svelte year selection element
new Year({
props: {
options: yearRange,
},
target: yearSelect
});
// Get activity history for specified project
let activity = (_a = getProjectActivityHistory(source, settings.activityHistory)) === null || _a === void 0 ? void 0 : _a.size;
// if no activity history available add placeholder
if (!activity) {
activity = [{ date: `${currentYear}-01-01`, value: 0 }];
}
// Add svelte activity heatmap element
new ActivityHeatmap({
props: {
year: new Date().getFullYear().toString(),
data: activity,
colors: [settings.activityColor1, settings.activityColor2, settings.activityColor3, settings.activityColor4],
textColor: settings.textColor,
emptyColor: settings.emptyColor,
cellRadius: settings.cellRadius,
type: settings.type
},
target: boardEL
});
// Add listener to update heatmap on Year Selection change
yearSelect.addEventListener('change', (event) => {
// Get selected year
let selectOption = yearSelect.querySelectorAll('option:checked')[0].innerHTML;
// Update the activity heatmap
boardEL.empty();
new ActivityHeatmap({
props: {
year: selectOption,
data: activity,
colors: [settings.activityColor1, settings.activityColor2, settings.activityColor3, settings.activityColor4],
textColor: settings.textColor,
emptyColor: settings.emptyColor,
cellRadius: settings.cellRadius
},
target: boardEL
});
});
el.appendChild(elCanvas);
}
}
const DEFAULT_SETTINGS = {
firstRun: true,
initialized: [{ path: '/', initialized: false }],
trackedProjects: ['/'],
checkpointList: [{ path: '/', date: getTimestamp(), size: 0 }],
activityHistory: [{ path: '/', size: [{ date: getTimestamp(), value: 0 }] }],
activityColor1: '#c6e48b',
activityColor2: '#7bc96f',
activityColor3: '#239a3b',
activityColor4: '#196127',
textColor: '#000000',
emptyColor: '#ecedf0',
cellRadius: 1,
type: 'yearly'
};
class ActivityHistoryPlugin extends obsidian.Plugin {
async onload() {
// Load message
await this.loadSettings();
console.log('Loaded Activity Plugin');
// Register activity history block renderer
this.registerMarkdownCodeBlockProcessor('ActivityHistory', async (source, el, ctx) => {
const proc = new ActivityHistoryProcessor();
await proc.run(source, el, this.settings);
});
// Update all tracked projects on events
setInterval(() => {
if (this.settings.firstRun) {
removeProject('/', this.settings);
addProject('/', this.settings, this.app.vault.getMarkdownFiles());
this.settings.firstRun = false;
this.saveSettings();
}
updateActivityAll(this.settings, this.app.vault.getMarkdownFiles());
this.saveSettings();
}, 200000);
this.addSettingTab(new ActivityHistorySettingTab(this.app, this));
}
onunload() {
console.log('unloading activity plugin');
}
async loadSettings() {
this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());
}
async saveSettings() {
await this.saveData(this.settings);
}
}
module.exports = ActivityHistoryPlugin;
Reference in New Issue View Git Blame Copy Permalink