diff --git a/.obsidian/command-palette.json b/.obsidian/command-palette.json
new file mode 100644
index 0000000..58f1227
--- /dev/null
+++ b/.obsidian/command-palette.json
@@ -0,0 +1,3 @@
+{
+ "pinned": null
+}
\ No newline at end of file
diff --git a/.obsidian/community-plugins.json b/.obsidian/community-plugins.json
index fe6546a..a6fc64c 100644
--- a/.obsidian/community-plugins.json
+++ b/.obsidian/community-plugins.json
@@ -8,5 +8,6 @@
"obsidian-dialogue-plugin",
"obsidian-pandoc",
"obsidian-image-toolkit",
- "obsidian-icons-plugin"
+ "obsidian-icons-plugin",
+ "periodic-notes"
]
\ No newline at end of file
diff --git a/.obsidian/core-plugins.json b/.obsidian/core-plugins.json
index be2348c..80aaae5 100644
--- a/.obsidian/core-plugins.json
+++ b/.obsidian/core-plugins.json
@@ -6,14 +6,12 @@
"outgoing-link",
"tag-pane",
"page-preview",
- "daily-notes",
"templates",
"note-composer",
"command-palette",
"slash-command",
"editor-status",
"starred",
- "markdown-importer",
"outline",
"word-count",
"open-with-default-app"
diff --git a/.obsidian/plugins/periodic-notes/data.json b/.obsidian/plugins/periodic-notes/data.json
new file mode 100644
index 0000000..c8a539f
--- /dev/null
+++ b/.obsidian/plugins/periodic-notes/data.json
@@ -0,0 +1,33 @@
+{
+ "showGettingStartedBanner": false,
+ "hasMigratedDailyNoteSettings": true,
+ "hasMigratedWeeklyNoteSettings": false,
+ "daily": {
+ "format": "DD.MM.YYYY",
+ "folder": "Periodische Notizen/Täglich",
+ "template": "Templates/t_DailyNote",
+ "enabled": true
+ },
+ "weekly": {
+ "format": "[KW]ww-yyyy",
+ "template": "",
+ "folder": "Periodische Notizen/Wöchentlich",
+ "enabled": true
+ },
+ "monthly": {
+ "format": "",
+ "template": "",
+ "folder": "",
+ "enabled": false
+ },
+ "quarterly": {
+ "format": "",
+ "template": "",
+ "folder": ""
+ },
+ "yearly": {
+ "format": "",
+ "template": "",
+ "folder": ""
+ }
+}
\ No newline at end of file
diff --git a/.obsidian/plugins/periodic-notes/main.js b/.obsidian/plugins/periodic-notes/main.js
new file mode 100644
index 0000000..8ea6df8
--- /dev/null
+++ b/.obsidian/plugins/periodic-notes/main.js
@@ -0,0 +1,5559 @@
+'use strict';
+
+var obsidian = require('obsidian');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var obsidian__default = /*#__PURE__*/_interopDefaultLegacy(obsidian);
+
+const DEFAULT_DAILY_NOTE_FORMAT = "YYYY-MM-DD";
+const DEFAULT_WEEKLY_NOTE_FORMAT = "gggg-[W]ww";
+const DEFAULT_MONTHLY_NOTE_FORMAT = "YYYY-MM";
+const DEFAULT_QUARTERLY_NOTE_FORMAT = "YYYY-[Q]Q";
+const DEFAULT_YEARLY_NOTE_FORMAT = "YYYY";
+
+function shouldUsePeriodicNotesSettings(periodicity) {
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ const periodicNotes = window.app.plugins.getPlugin("periodic-notes");
+ return periodicNotes && periodicNotes.settings?.[periodicity]?.enabled;
+}
+/**
+ * Read the user settings for the `daily-notes` plugin
+ * to keep behavior of creating a new note in-sync.
+ */
+function getDailyNoteSettings() {
+ try {
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ const { internalPlugins, plugins } = window.app;
+ if (shouldUsePeriodicNotesSettings("daily")) {
+ const { format, folder, template } = plugins.getPlugin("periodic-notes")?.settings?.daily || {};
+ return {
+ format: format || DEFAULT_DAILY_NOTE_FORMAT,
+ folder: folder?.trim() || "",
+ template: template?.trim() || "",
+ };
+ }
+ const { folder, format, template } = internalPlugins.getPluginById("daily-notes")?.instance?.options || {};
+ return {
+ format: format || DEFAULT_DAILY_NOTE_FORMAT,
+ folder: folder?.trim() || "",
+ template: template?.trim() || "",
+ };
+ }
+ catch (err) {
+ console.info("No custom daily note settings found!", err);
+ }
+}
+/**
+ * Read the user settings for the `weekly-notes` plugin
+ * to keep behavior of creating a new note in-sync.
+ */
+function getWeeklyNoteSettings() {
+ try {
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ const pluginManager = window.app.plugins;
+ const calendarSettings = pluginManager.getPlugin("calendar")?.options;
+ const periodicNotesSettings = pluginManager.getPlugin("periodic-notes")?.settings?.weekly;
+ if (shouldUsePeriodicNotesSettings("weekly")) {
+ return {
+ format: periodicNotesSettings.format || DEFAULT_WEEKLY_NOTE_FORMAT,
+ folder: periodicNotesSettings.folder?.trim() || "",
+ template: periodicNotesSettings.template?.trim() || "",
+ };
+ }
+ const settings = calendarSettings || {};
+ return {
+ format: settings.weeklyNoteFormat || DEFAULT_WEEKLY_NOTE_FORMAT,
+ folder: settings.weeklyNoteFolder?.trim() || "",
+ template: settings.weeklyNoteTemplate?.trim() || "",
+ };
+ }
+ catch (err) {
+ console.info("No custom weekly note settings found!", err);
+ }
+}
+/**
+ * Read the user settings for the `periodic-notes` plugin
+ * to keep behavior of creating a new note in-sync.
+ */
+function getMonthlyNoteSettings() {
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ const pluginManager = window.app.plugins;
+ try {
+ const settings = (shouldUsePeriodicNotesSettings("monthly") &&
+ pluginManager.getPlugin("periodic-notes")?.settings?.monthly) ||
+ {};
+ return {
+ format: settings.format || DEFAULT_MONTHLY_NOTE_FORMAT,
+ folder: settings.folder?.trim() || "",
+ template: settings.template?.trim() || "",
+ };
+ }
+ catch (err) {
+ console.info("No custom monthly note settings found!", err);
+ }
+}
+/**
+ * Read the user settings for the `periodic-notes` plugin
+ * to keep behavior of creating a new note in-sync.
+ */
+function getQuarterlyNoteSettings() {
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ const pluginManager = window.app.plugins;
+ try {
+ const settings = (shouldUsePeriodicNotesSettings("quarterly") &&
+ pluginManager.getPlugin("periodic-notes")?.settings?.quarterly) ||
+ {};
+ return {
+ format: settings.format || DEFAULT_QUARTERLY_NOTE_FORMAT,
+ folder: settings.folder?.trim() || "",
+ template: settings.template?.trim() || "",
+ };
+ }
+ catch (err) {
+ console.info("No custom quarterly note settings found!", err);
+ }
+}
+/**
+ * Read the user settings for the `periodic-notes` plugin
+ * to keep behavior of creating a new note in-sync.
+ */
+function getYearlyNoteSettings() {
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ const pluginManager = window.app.plugins;
+ try {
+ const settings = (shouldUsePeriodicNotesSettings("yearly") &&
+ pluginManager.getPlugin("periodic-notes")?.settings?.yearly) ||
+ {};
+ return {
+ format: settings.format || DEFAULT_YEARLY_NOTE_FORMAT,
+ folder: settings.folder?.trim() || "",
+ template: settings.template?.trim() || "",
+ };
+ }
+ catch (err) {
+ console.info("No custom yearly note settings found!", err);
+ }
+}
+
+// Credit: @creationix/path.js
+function join(...partSegments) {
+ // Split the inputs into a list of path commands.
+ let parts = [];
+ for (let i = 0, l = partSegments.length; i < l; i++) {
+ parts = parts.concat(partSegments[i].split("/"));
+ }
+ // Interpret the path commands to get the new resolved path.
+ const newParts = [];
+ for (let i = 0, l = parts.length; i < l; i++) {
+ const part = parts[i];
+ // Remove leading and trailing slashes
+ // Also remove "." segments
+ if (!part || part === ".")
+ continue;
+ // Push new path segments.
+ else
+ newParts.push(part);
+ }
+ // Preserve the initial slash if there was one.
+ if (parts[0] === "")
+ newParts.unshift("");
+ // Turn back into a single string path.
+ return newParts.join("/");
+}
+async function ensureFolderExists(path) {
+ const dirs = path.replace(/\\/g, "/").split("/");
+ dirs.pop(); // remove basename
+ if (dirs.length) {
+ const dir = join(...dirs);
+ if (!window.app.vault.getAbstractFileByPath(dir)) {
+ await window.app.vault.createFolder(dir);
+ }
+ }
+}
+async function getNotePath(directory, filename) {
+ if (!filename.endsWith(".md")) {
+ filename += ".md";
+ }
+ const path = obsidian__default['default'].normalizePath(join(directory, filename));
+ await ensureFolderExists(path);
+ return path;
+}
+async function getTemplateInfo(template) {
+ const { metadataCache, vault } = window.app;
+ const templatePath = obsidian__default['default'].normalizePath(template);
+ if (templatePath === "/") {
+ return Promise.resolve(["", null]);
+ }
+ try {
+ const templateFile = metadataCache.getFirstLinkpathDest(templatePath, "");
+ const contents = await vault.cachedRead(templateFile);
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ const IFoldInfo = window.app.foldManager.load(templateFile);
+ return [contents, IFoldInfo];
+ }
+ catch (err) {
+ console.error(`Failed to read the daily note template '${templatePath}'`, err);
+ new obsidian__default['default'].Notice("Failed to read the daily note template");
+ return ["", null];
+ }
+}
+
+/**
+ * dateUID is a way of weekly identifying daily/weekly/monthly notes.
+ * They are prefixed with the granularity to avoid ambiguity.
+ */
+function getDateUID(date, granularity = "day") {
+ const ts = date.clone().startOf(granularity).format();
+ return `${granularity}-${ts}`;
+}
+function removeEscapedCharacters(format) {
+ return format.replace(/\[[^\]]*\]/g, ""); // remove everything within brackets
+}
+/**
+ * XXX: When parsing dates that contain both week numbers and months,
+ * Moment choses to ignore the week numbers. For the week dateUID, we
+ * want the opposite behavior. Strip the MMM from the format to patch.
+ */
+function isFormatAmbiguous(format, granularity) {
+ if (granularity === "week") {
+ const cleanFormat = removeEscapedCharacters(format);
+ return (/w{1,2}/i.test(cleanFormat) &&
+ (/M{1,4}/.test(cleanFormat) || /D{1,4}/.test(cleanFormat)));
+ }
+ return false;
+}
+function getDateFromFile(file, granularity) {
+ return getDateFromFilename(file.basename, granularity);
+}
+function getDateFromFilename(filename, granularity) {
+ const getSettings = {
+ day: getDailyNoteSettings,
+ week: getWeeklyNoteSettings,
+ month: getMonthlyNoteSettings,
+ quarter: getQuarterlyNoteSettings,
+ year: getYearlyNoteSettings,
+ };
+ const format = getSettings[granularity]().format.split("/").pop();
+ const noteDate = window.moment(filename, format, true);
+ if (!noteDate.isValid()) {
+ return null;
+ }
+ if (isFormatAmbiguous(format, granularity)) {
+ if (granularity === "week") {
+ const cleanFormat = removeEscapedCharacters(format);
+ if (/w{1,2}/i.test(cleanFormat)) {
+ return window.moment(filename,
+ // If format contains week, remove day & month formatting
+ format.replace(/M{1,4}/g, "").replace(/D{1,4}/g, ""), false);
+ }
+ }
+ }
+ return noteDate;
+}
+
+class DailyNotesFolderMissingError extends Error {
+}
+/**
+ * This function mimics the behavior of the daily-notes plugin
+ * so it will replace {{date}}, {{title}}, and {{time}} with the
+ * formatted timestamp.
+ *
+ * Note: it has an added bonus that it's not 'today' specific.
+ */
+async function createDailyNote(date) {
+ const app = window.app;
+ const { vault } = app;
+ const moment = window.moment;
+ const { template, format, folder } = getDailyNoteSettings();
+ const [templateContents, IFoldInfo] = await getTemplateInfo(template);
+ const filename = date.format(format);
+ const normalizedPath = await getNotePath(folder, filename);
+ try {
+ const createdFile = await vault.create(normalizedPath, templateContents
+ .replace(/{{\s*date\s*}}/gi, filename)
+ .replace(/{{\s*time\s*}}/gi, moment().format("HH:mm"))
+ .replace(/{{\s*title\s*}}/gi, filename)
+ .replace(/{{\s*(date|time)\s*(([+-]\d+)([yqmwdhs]))?\s*(:.+?)?}}/gi, (_, _timeOrDate, calc, timeDelta, unit, momentFormat) => {
+ const now = moment();
+ const currentDate = date.clone().set({
+ hour: now.get("hour"),
+ minute: now.get("minute"),
+ second: now.get("second"),
+ });
+ if (calc) {
+ currentDate.add(parseInt(timeDelta, 10), unit);
+ }
+ if (momentFormat) {
+ return currentDate.format(momentFormat.substring(1).trim());
+ }
+ return currentDate.format(format);
+ })
+ .replace(/{{\s*yesterday\s*}}/gi, date.clone().subtract(1, "day").format(format))
+ .replace(/{{\s*tomorrow\s*}}/gi, date.clone().add(1, "d").format(format)));
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ app.foldManager.save(createdFile, IFoldInfo);
+ return createdFile;
+ }
+ catch (err) {
+ console.error(`Failed to create file: '${normalizedPath}'`, err);
+ new obsidian__default['default'].Notice("Unable to create new file.");
+ }
+}
+function getDailyNote(date, dailyNotes) {
+ return dailyNotes[getDateUID(date, "day")] ?? null;
+}
+function getAllDailyNotes() {
+ /**
+ * Find all daily notes in the daily note folder
+ */
+ const { vault } = window.app;
+ const { folder } = getDailyNoteSettings();
+ const dailyNotesFolder = vault.getAbstractFileByPath(obsidian__default['default'].normalizePath(folder));
+ if (!dailyNotesFolder) {
+ throw new DailyNotesFolderMissingError("Failed to find daily notes folder");
+ }
+ const dailyNotes = {};
+ obsidian__default['default'].Vault.recurseChildren(dailyNotesFolder, (note) => {
+ if (note instanceof obsidian__default['default'].TFile) {
+ const date = getDateFromFile(note, "day");
+ if (date) {
+ const dateString = getDateUID(date, "day");
+ dailyNotes[dateString] = note;
+ }
+ }
+ });
+ return dailyNotes;
+}
+
+class WeeklyNotesFolderMissingError extends Error {
+}
+function getDaysOfWeek() {
+ const { moment } = window;
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ let weekStart = moment.localeData()._week.dow;
+ const daysOfWeek = [
+ "sunday",
+ "monday",
+ "tuesday",
+ "wednesday",
+ "thursday",
+ "friday",
+ "saturday",
+ ];
+ while (weekStart) {
+ daysOfWeek.push(daysOfWeek.shift());
+ weekStart--;
+ }
+ return daysOfWeek;
+}
+function getDayOfWeekNumericalValue(dayOfWeekName) {
+ return getDaysOfWeek().indexOf(dayOfWeekName.toLowerCase());
+}
+async function createWeeklyNote(date) {
+ const { vault } = window.app;
+ const { template, format, folder } = getWeeklyNoteSettings();
+ const [templateContents, IFoldInfo] = await getTemplateInfo(template);
+ const filename = date.format(format);
+ const normalizedPath = await getNotePath(folder, filename);
+ try {
+ const createdFile = await vault.create(normalizedPath, templateContents
+ .replace(/{{\s*(date|time)\s*(([+-]\d+)([yqmwdhs]))?\s*(:.+?)?}}/gi, (_, _timeOrDate, calc, timeDelta, unit, momentFormat) => {
+ const now = window.moment();
+ const currentDate = date.clone().set({
+ hour: now.get("hour"),
+ minute: now.get("minute"),
+ second: now.get("second"),
+ });
+ if (calc) {
+ currentDate.add(parseInt(timeDelta, 10), unit);
+ }
+ if (momentFormat) {
+ return currentDate.format(momentFormat.substring(1).trim());
+ }
+ return currentDate.format(format);
+ })
+ .replace(/{{\s*title\s*}}/gi, filename)
+ .replace(/{{\s*time\s*}}/gi, window.moment().format("HH:mm"))
+ .replace(/{{\s*(sunday|monday|tuesday|wednesday|thursday|friday|saturday)\s*:(.*?)}}/gi, (_, dayOfWeek, momentFormat) => {
+ const day = getDayOfWeekNumericalValue(dayOfWeek);
+ return date.weekday(day).format(momentFormat.trim());
+ }));
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ window.app.foldManager.save(createdFile, IFoldInfo);
+ return createdFile;
+ }
+ catch (err) {
+ console.error(`Failed to create file: '${normalizedPath}'`, err);
+ new obsidian__default['default'].Notice("Unable to create new file.");
+ }
+}
+function getWeeklyNote(date, weeklyNotes) {
+ return weeklyNotes[getDateUID(date, "week")] ?? null;
+}
+function getAllWeeklyNotes() {
+ const weeklyNotes = {};
+ if (!appHasWeeklyNotesPluginLoaded()) {
+ return weeklyNotes;
+ }
+ const { vault } = window.app;
+ const { folder } = getWeeklyNoteSettings();
+ const weeklyNotesFolder = vault.getAbstractFileByPath(obsidian__default['default'].normalizePath(folder));
+ if (!weeklyNotesFolder) {
+ throw new WeeklyNotesFolderMissingError("Failed to find weekly notes folder");
+ }
+ obsidian__default['default'].Vault.recurseChildren(weeklyNotesFolder, (note) => {
+ if (note instanceof obsidian__default['default'].TFile) {
+ const date = getDateFromFile(note, "week");
+ if (date) {
+ const dateString = getDateUID(date, "week");
+ weeklyNotes[dateString] = note;
+ }
+ }
+ });
+ return weeklyNotes;
+}
+
+class MonthlyNotesFolderMissingError extends Error {
+}
+/**
+ * This function mimics the behavior of the daily-notes plugin
+ * so it will replace {{date}}, {{title}}, and {{time}} with the
+ * formatted timestamp.
+ *
+ * Note: it has an added bonus that it's not 'today' specific.
+ */
+async function createMonthlyNote(date) {
+ const { vault } = window.app;
+ const { template, format, folder } = getMonthlyNoteSettings();
+ const [templateContents, IFoldInfo] = await getTemplateInfo(template);
+ const filename = date.format(format);
+ const normalizedPath = await getNotePath(folder, filename);
+ try {
+ const createdFile = await vault.create(normalizedPath, templateContents
+ .replace(/{{\s*(date|time)\s*(([+-]\d+)([yqmwdhs]))?\s*(:.+?)?}}/gi, (_, _timeOrDate, calc, timeDelta, unit, momentFormat) => {
+ const now = window.moment();
+ const currentDate = date.clone().set({
+ hour: now.get("hour"),
+ minute: now.get("minute"),
+ second: now.get("second"),
+ });
+ if (calc) {
+ currentDate.add(parseInt(timeDelta, 10), unit);
+ }
+ if (momentFormat) {
+ return currentDate.format(momentFormat.substring(1).trim());
+ }
+ return currentDate.format(format);
+ })
+ .replace(/{{\s*date\s*}}/gi, filename)
+ .replace(/{{\s*time\s*}}/gi, window.moment().format("HH:mm"))
+ .replace(/{{\s*title\s*}}/gi, filename));
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ window.app.foldManager.save(createdFile, IFoldInfo);
+ return createdFile;
+ }
+ catch (err) {
+ console.error(`Failed to create file: '${normalizedPath}'`, err);
+ new obsidian__default['default'].Notice("Unable to create new file.");
+ }
+}
+function getMonthlyNote(date, monthlyNotes) {
+ return monthlyNotes[getDateUID(date, "month")] ?? null;
+}
+function getAllMonthlyNotes() {
+ const monthlyNotes = {};
+ if (!appHasMonthlyNotesPluginLoaded()) {
+ return monthlyNotes;
+ }
+ const { vault } = window.app;
+ const { folder } = getMonthlyNoteSettings();
+ const monthlyNotesFolder = vault.getAbstractFileByPath(obsidian__default['default'].normalizePath(folder));
+ if (!monthlyNotesFolder) {
+ throw new MonthlyNotesFolderMissingError("Failed to find monthly notes folder");
+ }
+ obsidian__default['default'].Vault.recurseChildren(monthlyNotesFolder, (note) => {
+ if (note instanceof obsidian__default['default'].TFile) {
+ const date = getDateFromFile(note, "month");
+ if (date) {
+ const dateString = getDateUID(date, "month");
+ monthlyNotes[dateString] = note;
+ }
+ }
+ });
+ return monthlyNotes;
+}
+
+class QuarterlyNotesFolderMissingError extends Error {
+}
+/**
+ * This function mimics the behavior of the daily-notes plugin
+ * so it will replace {{date}}, {{title}}, and {{time}} with the
+ * formatted timestamp.
+ *
+ * Note: it has an added bonus that it's not 'today' specific.
+ */
+async function createQuarterlyNote(date) {
+ const { vault } = window.app;
+ const { template, format, folder } = getQuarterlyNoteSettings();
+ const [templateContents, IFoldInfo] = await getTemplateInfo(template);
+ const filename = date.format(format);
+ const normalizedPath = await getNotePath(folder, filename);
+ try {
+ const createdFile = await vault.create(normalizedPath, templateContents
+ .replace(/{{\s*(date|time)\s*(([+-]\d+)([yqmwdhs]))?\s*(:.+?)?}}/gi, (_, _timeOrDate, calc, timeDelta, unit, momentFormat) => {
+ const now = window.moment();
+ const currentDate = date.clone().set({
+ hour: now.get("hour"),
+ minute: now.get("minute"),
+ second: now.get("second"),
+ });
+ if (calc) {
+ currentDate.add(parseInt(timeDelta, 10), unit);
+ }
+ if (momentFormat) {
+ return currentDate.format(momentFormat.substring(1).trim());
+ }
+ return currentDate.format(format);
+ })
+ .replace(/{{\s*date\s*}}/gi, filename)
+ .replace(/{{\s*time\s*}}/gi, window.moment().format("HH:mm"))
+ .replace(/{{\s*title\s*}}/gi, filename));
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ window.app.foldManager.save(createdFile, IFoldInfo);
+ return createdFile;
+ }
+ catch (err) {
+ console.error(`Failed to create file: '${normalizedPath}'`, err);
+ new obsidian__default['default'].Notice("Unable to create new file.");
+ }
+}
+function getQuarterlyNote(date, quarterly) {
+ return quarterly[getDateUID(date, "quarter")] ?? null;
+}
+function getAllQuarterlyNotes() {
+ const quarterly = {};
+ if (!appHasQuarterlyNotesPluginLoaded()) {
+ return quarterly;
+ }
+ const { vault } = window.app;
+ const { folder } = getQuarterlyNoteSettings();
+ const quarterlyFolder = vault.getAbstractFileByPath(obsidian__default['default'].normalizePath(folder));
+ if (!quarterlyFolder) {
+ throw new QuarterlyNotesFolderMissingError("Failed to find quarterly notes folder");
+ }
+ obsidian__default['default'].Vault.recurseChildren(quarterlyFolder, (note) => {
+ if (note instanceof obsidian__default['default'].TFile) {
+ const date = getDateFromFile(note, "quarter");
+ if (date) {
+ const dateString = getDateUID(date, "quarter");
+ quarterly[dateString] = note;
+ }
+ }
+ });
+ return quarterly;
+}
+
+class YearlyNotesFolderMissingError extends Error {
+}
+/**
+ * This function mimics the behavior of the daily-notes plugin
+ * so it will replace {{date}}, {{title}}, and {{time}} with the
+ * formatted timestamp.
+ *
+ * Note: it has an added bonus that it's not 'today' specific.
+ */
+async function createYearlyNote(date) {
+ const { vault } = window.app;
+ const { template, format, folder } = getYearlyNoteSettings();
+ const [templateContents, IFoldInfo] = await getTemplateInfo(template);
+ const filename = date.format(format);
+ const normalizedPath = await getNotePath(folder, filename);
+ try {
+ const createdFile = await vault.create(normalizedPath, templateContents
+ .replace(/{{\s*(date|time)\s*(([+-]\d+)([yqmwdhs]))?\s*(:.+?)?}}/gi, (_, _timeOrDate, calc, timeDelta, unit, momentFormat) => {
+ const now = window.moment();
+ const currentDate = date.clone().set({
+ hour: now.get("hour"),
+ minute: now.get("minute"),
+ second: now.get("second"),
+ });
+ if (calc) {
+ currentDate.add(parseInt(timeDelta, 10), unit);
+ }
+ if (momentFormat) {
+ return currentDate.format(momentFormat.substring(1).trim());
+ }
+ return currentDate.format(format);
+ })
+ .replace(/{{\s*date\s*}}/gi, filename)
+ .replace(/{{\s*time\s*}}/gi, window.moment().format("HH:mm"))
+ .replace(/{{\s*title\s*}}/gi, filename));
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ window.app.foldManager.save(createdFile, IFoldInfo);
+ return createdFile;
+ }
+ catch (err) {
+ console.error(`Failed to create file: '${normalizedPath}'`, err);
+ new obsidian__default['default'].Notice("Unable to create new file.");
+ }
+}
+function getYearlyNote(date, yearlyNotes) {
+ return yearlyNotes[getDateUID(date, "year")] ?? null;
+}
+function getAllYearlyNotes() {
+ const yearlyNotes = {};
+ if (!appHasYearlyNotesPluginLoaded()) {
+ return yearlyNotes;
+ }
+ const { vault } = window.app;
+ const { folder } = getYearlyNoteSettings();
+ const yearlyNotesFolder = vault.getAbstractFileByPath(obsidian__default['default'].normalizePath(folder));
+ if (!yearlyNotesFolder) {
+ throw new YearlyNotesFolderMissingError("Failed to find yearly notes folder");
+ }
+ obsidian__default['default'].Vault.recurseChildren(yearlyNotesFolder, (note) => {
+ if (note instanceof obsidian__default['default'].TFile) {
+ const date = getDateFromFile(note, "year");
+ if (date) {
+ const dateString = getDateUID(date, "year");
+ yearlyNotes[dateString] = note;
+ }
+ }
+ });
+ return yearlyNotes;
+}
+
+function appHasDailyNotesPluginLoaded() {
+ const { app } = window;
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ const dailyNotesPlugin = app.internalPlugins.plugins["daily-notes"];
+ if (dailyNotesPlugin && dailyNotesPlugin.enabled) {
+ return true;
+ }
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ const periodicNotes = app.plugins.getPlugin("periodic-notes");
+ return periodicNotes && periodicNotes.settings?.daily?.enabled;
+}
+/**
+ * XXX: "Weekly Notes" live in either the Calendar plugin or the periodic-notes plugin.
+ * Check both until the weekly notes feature is removed from the Calendar plugin.
+ */
+function appHasWeeklyNotesPluginLoaded() {
+ const { app } = window;
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ if (app.plugins.getPlugin("calendar")) {
+ return true;
+ }
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ const periodicNotes = app.plugins.getPlugin("periodic-notes");
+ return periodicNotes && periodicNotes.settings?.weekly?.enabled;
+}
+function appHasMonthlyNotesPluginLoaded() {
+ const { app } = window;
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ const periodicNotes = app.plugins.getPlugin("periodic-notes");
+ return periodicNotes && periodicNotes.settings?.monthly?.enabled;
+}
+function appHasQuarterlyNotesPluginLoaded() {
+ const { app } = window;
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ const periodicNotes = app.plugins.getPlugin("periodic-notes");
+ return periodicNotes && periodicNotes.settings?.quarterly?.enabled;
+}
+function appHasYearlyNotesPluginLoaded() {
+ const { app } = window;
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ const periodicNotes = app.plugins.getPlugin("periodic-notes");
+ return periodicNotes && periodicNotes.settings?.yearly?.enabled;
+}
+
+var DEFAULT_DAILY_NOTE_FORMAT_1 = DEFAULT_DAILY_NOTE_FORMAT;
+var DEFAULT_MONTHLY_NOTE_FORMAT_1 = DEFAULT_MONTHLY_NOTE_FORMAT;
+var DEFAULT_QUARTERLY_NOTE_FORMAT_1 = DEFAULT_QUARTERLY_NOTE_FORMAT;
+var DEFAULT_WEEKLY_NOTE_FORMAT_1 = DEFAULT_WEEKLY_NOTE_FORMAT;
+var DEFAULT_YEARLY_NOTE_FORMAT_1 = DEFAULT_YEARLY_NOTE_FORMAT;
+var appHasDailyNotesPluginLoaded_1 = appHasDailyNotesPluginLoaded;
+var createDailyNote_1 = createDailyNote;
+var createMonthlyNote_1 = createMonthlyNote;
+var createQuarterlyNote_1 = createQuarterlyNote;
+var createWeeklyNote_1 = createWeeklyNote;
+var createYearlyNote_1 = createYearlyNote;
+var getAllDailyNotes_1 = getAllDailyNotes;
+var getAllMonthlyNotes_1 = getAllMonthlyNotes;
+var getAllQuarterlyNotes_1 = getAllQuarterlyNotes;
+var getAllWeeklyNotes_1 = getAllWeeklyNotes;
+var getAllYearlyNotes_1 = getAllYearlyNotes;
+var getDailyNote_1 = getDailyNote;
+var getDateFromFile_1 = getDateFromFile;
+var getMonthlyNote_1 = getMonthlyNote;
+var getQuarterlyNote_1 = getQuarterlyNote;
+var getWeeklyNote_1 = getWeeklyNote;
+var getYearlyNote_1 = getYearlyNote;
+
+const wrapAround = (value, size) => {
+ return ((value % size) + size) % size;
+};
+function orderedValues(unordered) {
+ return Object.keys(unordered)
+ .sort()
+ .reduce((acc, key) => {
+ acc.push(unordered[key]);
+ return acc;
+ }, []);
+}
+function getCalendarPlugin() {
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ return window.app.plugins.getPlugin("calendar");
+}
+function getDailyNotesPlugin() {
+ var _a;
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ const { internalPlugins } = window.app;
+ return (_a = internalPlugins.getPluginById("daily-notes")) === null || _a === void 0 ? void 0 : _a.instance;
+}
+function capitalize(text) {
+ return text.charAt(0).toUpperCase() + text.slice(1);
+}
+function hasLegacyDailyNoteSettings() {
+ var _a;
+ if (!appHasDailyNotesPluginLoaded_1()) {
+ return false;
+ }
+ const options = (_a = getDailyNotesPlugin()) === null || _a === void 0 ? void 0 : _a.options;
+ return !!(options.format || options.folder || options.template);
+}
+function getLegacyDailyNoteSettings() {
+ var _a, _b;
+ const options = getDailyNotesPlugin().options || {};
+ return {
+ format: options.format,
+ folder: (_a = options.folder) === null || _a === void 0 ? void 0 : _a.trim(),
+ template: (_b = options.template) === null || _b === void 0 ? void 0 : _b.trim(),
+ };
+}
+function hasLegacyWeeklyNoteSettings() {
+ const calendarPlugin = getCalendarPlugin();
+ if (!calendarPlugin) {
+ return false;
+ }
+ const options = calendarPlugin.options || {};
+ return !!(options.weeklyNoteFormat ||
+ options.weeklyNoteFolder ||
+ options.weeklyNoteTemplate);
+}
+function getLegacyWeeklyNoteSettings() {
+ var _a, _b;
+ const options = getCalendarPlugin().options || {};
+ return {
+ format: options.weeklyNoteFormat || "",
+ folder: ((_a = options.weeklyNoteFolder) === null || _a === void 0 ? void 0 : _a.trim()) || "",
+ template: ((_b = options.weeklyNoteTemplate) === null || _b === void 0 ? void 0 : _b.trim()) || "",
+ };
+}
+function isMacOS() {
+ return navigator.appVersion.indexOf("Mac") !== -1;
+}
+function isMetaPressed(e) {
+ return isMacOS() ? e.metaKey : e.ctrlKey;
+}
+
+const periodConfigs = {
+ daily: {
+ unitOfTime: "day",
+ relativeUnit: "today",
+ createNote: createDailyNote_1,
+ getNote: getDailyNote_1,
+ getAllNotes: getAllDailyNotes_1,
+ },
+ weekly: {
+ unitOfTime: "week",
+ relativeUnit: "this week",
+ createNote: createWeeklyNote_1,
+ getNote: getWeeklyNote_1,
+ getAllNotes: getAllWeeklyNotes_1,
+ },
+ monthly: {
+ unitOfTime: "month",
+ relativeUnit: "this month",
+ createNote: createMonthlyNote_1,
+ getNote: getMonthlyNote_1,
+ getAllNotes: getAllMonthlyNotes_1,
+ },
+ quarterly: {
+ unitOfTime: "quarter",
+ relativeUnit: "this quarter",
+ createNote: createQuarterlyNote_1,
+ getNote: getQuarterlyNote_1,
+ getAllNotes: getAllQuarterlyNotes_1,
+ },
+ yearly: {
+ unitOfTime: "year",
+ relativeUnit: "this year",
+ createNote: createYearlyNote_1,
+ getNote: getYearlyNote_1,
+ getAllNotes: getAllYearlyNotes_1,
+ },
+};
+async function openPeriodicNote(periodicity, date, inNewSplit) {
+ const config = periodConfigs[periodicity];
+ const startOfPeriod = date.clone().startOf(config.unitOfTime);
+ let allNotes;
+ try {
+ allNotes = config.getAllNotes();
+ }
+ catch (err) {
+ console.error(`failed to find your ${periodicity} notes folder`, err);
+ new obsidian.Notice(`Failed to find your ${periodicity} notes folder`);
+ return;
+ }
+ let periodicNote = config.getNote(startOfPeriod, allNotes);
+ if (!periodicNote) {
+ periodicNote = await config.createNote(startOfPeriod);
+ }
+ await openFile(periodicNote, inNewSplit);
+}
+function getActiveFile() {
+ const { workspace } = window.app;
+ const activeView = workspace.getActiveViewOfType(obsidian.MarkdownView);
+ return activeView === null || activeView === void 0 ? void 0 : activeView.file;
+}
+async function openFile(file, inNewSplit) {
+ const { workspace } = window.app;
+ const leaf = inNewSplit
+ ? workspace.splitActiveLeaf()
+ : workspace.getUnpinnedLeaf();
+ await leaf.openFile(file, { active: true });
+}
+async function openNextNote(periodicity) {
+ const config = periodConfigs[periodicity];
+ const activeFile = getActiveFile();
+ try {
+ const allNotes = orderedValues(config.getAllNotes());
+ const activeNoteIndex = allNotes.findIndex((file) => file === activeFile);
+ const nextNote = allNotes[activeNoteIndex + 1];
+ if (nextNote) {
+ await openFile(nextNote, false);
+ }
+ }
+ catch (err) {
+ console.error(`failed to find your ${periodicity} notes folder`, err);
+ new obsidian.Notice(`Failed to find your ${periodicity} notes folder`);
+ }
+}
+async function openPrevNote(periodicity) {
+ const config = periodConfigs[periodicity];
+ const activeFile = getActiveFile();
+ try {
+ const allNotes = orderedValues(config.getAllNotes());
+ const activeNoteIndex = allNotes.findIndex((file) => file === activeFile);
+ const prevNote = allNotes[activeNoteIndex - 1];
+ if (prevNote) {
+ await openFile(prevNote, false);
+ }
+ }
+ catch (err) {
+ console.error(`failed to find your ${periodicity} notes folder`, err);
+ new obsidian.Notice(`Failed to find your ${periodicity} notes folder`);
+ }
+}
+function getCommands(periodicity) {
+ const config = periodConfigs[periodicity];
+ return [
+ {
+ id: `open-${periodicity}-note`,
+ name: `Open ${periodicity} note`,
+ callback: () => openPeriodicNote(periodicity, window.moment(), false),
+ },
+ {
+ id: `next-${periodicity}-note`,
+ name: `Open next ${periodicity} note`,
+ checkCallback: (checking) => {
+ if (checking) {
+ const activeFile = getActiveFile();
+ return !!(activeFile && getDateFromFile_1(activeFile, config.unitOfTime));
+ }
+ openNextNote(periodicity);
+ },
+ },
+ {
+ id: `prev-${periodicity}-note`,
+ name: `Open previous ${periodicity} note`,
+ checkCallback: (checking) => {
+ if (checking) {
+ const activeFile = getActiveFile();
+ return !!(activeFile && getDateFromFile_1(activeFile, config.unitOfTime));
+ }
+ openPrevNote(periodicity);
+ },
+ },
+ ];
+}
+
+const SETTINGS_UPDATED = "periodic-notes:settings-updated";
+
+const calendarDayIcon = `
+
If you have an custom hotkeys for daily notes, make sure to update
+ them to use the new "Periodic Notes" commands.`;
+
+ attr(p, "class", "setting-item-description");
+ },
+ m(target, anchor) {
+ insert(target, p, anchor);
+ },
+ d(detaching) {
+ if (detaching) detach(p);
+ }
+ };
+}
+
+// (42:8) {:else}
+function create_else_block_1(ctx) {
+ let button;
+ let mounted;
+ let dispose;
+
+ return {
+ c() {
+ button = element("button");
+ button.textContent = "Migrate";
+ attr(button, "class", "mod-cta svelte-1alo0m9");
+ },
+ m(target, anchor) {
+ insert(target, button, anchor);
+
+ if (!mounted) {
+ dispose = listen(button, "click", function () {
+ if (is_function(/*migrateDailyNoteSettings*/ ctx[2])) /*migrateDailyNoteSettings*/ ctx[2].apply(this, arguments);
+ });
+
+ mounted = true;
+ }
+ },
+ p(new_ctx, dirty) {
+ ctx = new_ctx;
+ },
+ i: noop,
+ o: noop,
+ d(detaching) {
+ if (detaching) detach(button);
+ mounted = false;
+ dispose();
+ }
+ };
+}
+
+// (40:8) {#if $settings.hasMigratedDailyNoteSettings}
+function create_if_block_4(ctx) {
+ let button;
+ let t;
+ let checkmark;
+ let current;
+ checkmark = new Checkmark({});
+
+ return {
+ c() {
+ button = element("button");
+ t = text("Migrated ");
+ create_component(checkmark.$$.fragment);
+ button.disabled = true;
+ attr(button, "class", "svelte-1alo0m9");
+ },
+ m(target, anchor) {
+ insert(target, button, anchor);
+ append(button, t);
+ mount_component(checkmark, button, null);
+ current = true;
+ },
+ p: noop,
+ i(local) {
+ if (current) return;
+ transition_in(checkmark.$$.fragment, local);
+ current = true;
+ },
+ o(local) {
+ transition_out(checkmark.$$.fragment, local);
+ current = false;
+ },
+ d(detaching) {
+ if (detaching) detach(button);
+ destroy_component(checkmark);
+ }
+ };
+}
+
+// (51:2) {#if hasWeeklyNoteSettings}
+function create_if_block_1$2(ctx) {
+ let div2;
+ let div0;
+ let t3;
+ let div1;
+ let current_block_type_index;
+ let if_block;
+ let current;
+ const if_block_creators = [create_if_block_2, create_else_block];
+ const if_blocks = [];
+
+ function select_block_type_2(ctx, dirty) {
+ if (/*$settings*/ ctx[5].hasMigratedWeeklyNoteSettings) return 0;
+ return 1;
+ }
+
+ current_block_type_index = select_block_type_2(ctx);
+ if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
+
+ return {
+ c() {
+ div2 = element("div");
+ div0 = element("div");
+
+ div0.innerHTML = `
Your existing weekly-note settings from the Calendar plugin have been + migrated over automatically. The functionality will be removed from + the Calendar plugin in the future.
`; + + t3 = space(); + div1 = element("div"); + if_block.c(); + attr(div0, "class", "setting-item-info"); + attr(div1, "class", "setting-item-control"); + attr(div2, "class", "setting-item"); + }, + m(target, anchor) { + insert(target, div2, anchor); + append(div2, div0); + append(div2, t3); + append(div2, div1); + if_blocks[current_block_type_index].m(div1, null); + current = true; + }, + p(ctx, dirty) { + let previous_block_index = current_block_type_index; + current_block_type_index = select_block_type_2(ctx); + + if (current_block_type_index !== previous_block_index) { + 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(); + } + + transition_in(if_block, 1); + if_block.m(div1, null); + } + }, + i(local) { + if (current) return; + transition_in(if_block); + current = true; + }, + o(local) { + transition_out(if_block); + current = false; + }, + d(detaching) { + if (detaching) detach(div2); + if_blocks[current_block_type_index].d(); + } + }; +} + +// (67:8) {:else} +function create_else_block(ctx) { + let button; + + return { + c() { + button = element("button"); + button.textContent = "Migrate"; + attr(button, "class", "mod-cta svelte-1alo0m9"); + }, + m(target, anchor) { + insert(target, button, anchor); + }, + i: noop, + o: noop, + d(detaching) { + if (detaching) detach(button); + } + }; +} + +// (62:8) {#if $settings.hasMigratedWeeklyNoteSettings} +function create_if_block_2(ctx) { + let button; + let t; + let checkmark; + let current; + checkmark = new Checkmark({}); + + return { + c() { + button = element("button"); + t = text("Migrated\n "); + create_component(checkmark.$$.fragment); + button.disabled = true; + attr(button, "class", "svelte-1alo0m9"); + }, + m(target, anchor) { + insert(target, button, anchor); + append(button, t); + mount_component(checkmark, button, null); + current = true; + }, + i(local) { + if (current) return; + transition_in(checkmark.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(checkmark.$$.fragment, local); + current = false; + }, + d(detaching) { + if (detaching) detach(button); + destroy_component(checkmark); + } + }; +} + +// (74:2) {#if !hasDailyNoteSettings && !hasWeeklyNoteSettings} +function create_if_block$4(ctx) { + let p; + + return { + c() { + p = element("p"); + p.textContent = "With this plugin, you can quickly create and navigate to daily, weekly,\n and monthly notes. Enable them below to get started."; + }, + m(target, anchor) { + insert(target, p, anchor); + }, + d(detaching) { + if (detaching) detach(p); + } + }; +} + +function create_fragment$4(ctx) { + let div; + let h3; + let t1; + let t2; + let t3; + let t4; + let button; + let div_outro; + let current; + let mounted; + let dispose; + let if_block0 = /*hasDailyNoteSettings*/ ctx[3] && create_if_block_3(ctx); + let if_block1 = /*hasWeeklyNoteSettings*/ ctx[4] && create_if_block_1$2(ctx); + let if_block2 = !/*hasDailyNoteSettings*/ ctx[3] && !/*hasWeeklyNoteSettings*/ ctx[4] && create_if_block$4(); + + return { + c() { + div = element("div"); + h3 = element("h3"); + h3.textContent = "Getting Started"; + t1 = space(); + if (if_block0) if_block0.c(); + t2 = space(); + if (if_block1) if_block1.c(); + t3 = space(); + if (if_block2) if_block2.c(); + t4 = space(); + button = element("button"); + button.textContent = "Dismiss"; + attr(button, "class", "svelte-1alo0m9"); + attr(div, "class", "settings-banner"); + }, + m(target, anchor) { + insert(target, div, anchor); + append(div, h3); + append(div, t1); + if (if_block0) if_block0.m(div, null); + append(div, t2); + if (if_block1) if_block1.m(div, null); + append(div, t3); + if (if_block2) if_block2.m(div, null); + append(div, t4); + append(div, button); + current = true; + + if (!mounted) { + dispose = listen(button, "click", function () { + if (is_function(/*handleTeardown*/ ctx[1])) /*handleTeardown*/ ctx[1].apply(this, arguments); + }); + + mounted = true; + } + }, + p(new_ctx, [dirty]) { + ctx = new_ctx; + + if (/*hasDailyNoteSettings*/ ctx[3]) { + if (if_block0) { + if_block0.p(ctx, dirty); + + if (dirty & /*hasDailyNoteSettings*/ 8) { + transition_in(if_block0, 1); + } + } else { + if_block0 = create_if_block_3(ctx); + if_block0.c(); + transition_in(if_block0, 1); + if_block0.m(div, t2); + } + } else if (if_block0) { + group_outros(); + + transition_out(if_block0, 1, 1, () => { + if_block0 = null; + }); + + check_outros(); + } + + if (/*hasWeeklyNoteSettings*/ ctx[4]) { + if (if_block1) { + if_block1.p(ctx, dirty); + + if (dirty & /*hasWeeklyNoteSettings*/ 16) { + transition_in(if_block1, 1); + } + } else { + if_block1 = create_if_block_1$2(ctx); + if_block1.c(); + transition_in(if_block1, 1); + if_block1.m(div, t3); + } + } else if (if_block1) { + group_outros(); + + transition_out(if_block1, 1, 1, () => { + if_block1 = null; + }); + + check_outros(); + } + + if (!/*hasDailyNoteSettings*/ ctx[3] && !/*hasWeeklyNoteSettings*/ ctx[4]) { + if (if_block2) ; else { + if_block2 = create_if_block$4(); + if_block2.c(); + if_block2.m(div, t4); + } + } else if (if_block2) { + if_block2.d(1); + if_block2 = null; + } + }, + i(local) { + if (current) return; + transition_in(if_block0); + transition_in(if_block1); + if (div_outro) div_outro.end(1); + current = true; + }, + o(local) { + transition_out(if_block0); + transition_out(if_block1); + div_outro = create_out_transition(div, slide, {}); + current = false; + }, + d(detaching) { + if (detaching) detach(div); + if (if_block0) if_block0.d(); + if (if_block1) if_block1.d(); + if (if_block2) if_block2.d(); + if (detaching && div_outro) div_outro.end(); + mounted = false; + dispose(); + } + }; +} + +function instance$4($$self, $$props, $$invalidate) { + let $settings, + $$unsubscribe_settings = noop, + $$subscribe_settings = () => ($$unsubscribe_settings(), $$unsubscribe_settings = subscribe(settings, $$value => $$invalidate(5, $settings = $$value)), settings); + + $$self.$$.on_destroy.push(() => $$unsubscribe_settings()); + + + let { settings } = $$props; + $$subscribe_settings(); + let { handleTeardown } = $$props; + let { migrateDailyNoteSettings } = $$props; + let hasDailyNoteSettings; + let hasWeeklyNoteSettings; + + $$self.$$set = $$props => { + if ("settings" in $$props) $$subscribe_settings($$invalidate(0, settings = $$props.settings)); + if ("handleTeardown" in $$props) $$invalidate(1, handleTeardown = $$props.handleTeardown); + if ("migrateDailyNoteSettings" in $$props) $$invalidate(2, migrateDailyNoteSettings = $$props.migrateDailyNoteSettings); + }; + + { + $$invalidate(3, hasDailyNoteSettings = hasLegacyDailyNoteSettings()); + $$invalidate(4, hasWeeklyNoteSettings = hasLegacyWeeklyNoteSettings()); + } + + return [ + settings, + handleTeardown, + migrateDailyNoteSettings, + hasDailyNoteSettings, + hasWeeklyNoteSettings, + $settings + ]; +} + +class GettingStartedBanner extends SvelteComponent { + constructor(options) { + super(); + if (!document.getElementById("svelte-1alo0m9-style")) add_css(); + + init(this, options, instance$4, create_fragment$4, safe_not_equal, { + settings: 0, + handleTeardown: 1, + migrateDailyNoteSettings: 2 + }); + } +} + +function getBasename(format) { + const isTemplateNested = format.indexOf("/") !== -1; + return isTemplateNested ? format.split("/").pop() : format; +} +function isValidFilename(filename) { + const illegalRe = /[?<>\\:*|"]/g; + const controlRe = /[\x00-\x1f\x80-\x9f]/g; + const reservedRe = /^\.+$/; + const windowsReservedRe = /^(con|prn|aux|nul|com[0-9]|lpt[0-9])(\..*)?$/i; + return (!illegalRe.test(filename) && + !controlRe.test(filename) && + !reservedRe.test(filename) && + !windowsReservedRe.test(filename)); +} +function validateFormat(format, periodicity) { + if (!format) { + return ""; + } + if (!isValidFilename(format)) { + return "Format contains illegal characters"; + } + if (periodicity === "daily" && + !["m", "d", "y"].every((requiredChar) => getBasename(format) + .replace(/\[[^\]]*\]/g, "") // remove everything within brackets + .toLowerCase() + .indexOf(requiredChar) !== -1)) { + return "Filename must be unique"; + } +} +function validateTemplate(template) { + if (!template) { + return ""; + } + const { metadataCache } = window.app; + const file = metadataCache.getFirstLinkpathDest(template, ""); + if (!file) { + return "Template file not found"; + } + return ""; +} +function validateFolder(folder) { + if (!folder || folder === "/") { + return ""; + } + const { vault } = window.app; + if (!vault.getAbstractFileByPath(obsidian.normalizePath(folder))) { + return "Folder not found in vault"; + } + return ""; +} + +/* src/settings/NoteFormatSetting.svelte generated by Svelte v3.35.0 */ + +function create_if_block_1$1(ctx) { + let div; + let t0; + let strong0; + let t1; + let br; + let t2; + let strong1; + let t3; + + return { + c() { + div = element("div"); + t0 = text("New files will be created at "); + strong0 = element("strong"); + t1 = text(/*value*/ ctx[2]); + br = element("br"); + t2 = text("\n Format: "); + strong1 = element("strong"); + t3 = text(/*basename*/ ctx[7]); + }, + m(target, anchor) { + insert(target, div, anchor); + append(div, t0); + append(div, strong0); + append(strong0, t1); + append(div, br); + append(div, t2); + append(div, strong1); + append(strong1, t3); + }, + p(ctx, dirty) { + if (dirty & /*value*/ 4) set_data(t1, /*value*/ ctx[2]); + if (dirty & /*basename*/ 128) set_data(t3, /*basename*/ ctx[7]); + }, + d(detaching) { + if (detaching) detach(div); + } + }; +} + +// (56:4) {#if error} +function create_if_block$3(ctx) { + let div; + let t; + + return { + c() { + div = element("div"); + t = text(/*error*/ ctx[5]); + attr(div, "class", "has-error"); + }, + m(target, anchor) { + insert(target, div, anchor); + append(div, t); + }, + p(ctx, dirty) { + if (dirty & /*error*/ 32) set_data(t, /*error*/ ctx[5]); + }, + d(detaching) { + if (detaching) detach(div); + } + }; +} + +function create_fragment$3(ctx) { + let div5; + let div3; + let div0; + let t1; + let div2; + let a; + let t3; + let div1; + let t4; + let b; + let t5_value = window.moment().format(/*value*/ ctx[2] || /*defaultFormat*/ ctx[8]) + ""; + let t5; + let t6; + let t7; + let t8; + let div4; + let input; + let mounted; + let dispose; + let if_block0 = /*isTemplateNested*/ ctx[6] && create_if_block_1$1(ctx); + let if_block1 = /*error*/ ctx[5] && create_if_block$3(ctx); + + return { + c() { + div5 = element("div"); + div3 = element("div"); + div0 = element("div"); + div0.textContent = "Format"; + t1 = space(); + div2 = element("div"); + a = element("a"); + a.textContent = "Syntax Reference"; + t3 = space(); + div1 = element("div"); + t4 = text("Your current syntax looks like this: "); + b = element("b"); + t5 = text(t5_value); + t6 = space(); + if (if_block0) if_block0.c(); + t7 = space(); + if (if_block1) if_block1.c(); + t8 = space(); + div4 = element("div"); + input = element("input"); + attr(div0, "class", "setting-item-name"); + attr(a, "href", "https://momentjs.com/docs/#/displaying/format/"); + attr(b, "class", "u-pop"); + attr(div2, "class", "setting-item-description"); + attr(div3, "class", "setting-item-info"); + attr(input, "type", "text"); + attr(input, "spellcheck", false); + attr(input, "placeholder", /*defaultFormat*/ ctx[8]); + toggle_class(input, "has-error", !!/*error*/ ctx[5]); + attr(div4, "class", "setting-item-control"); + attr(div5, "class", "setting-item"); + }, + m(target, anchor) { + insert(target, div5, anchor); + append(div5, div3); + append(div3, div0); + append(div3, t1); + append(div3, div2); + append(div2, a); + append(div2, t3); + append(div2, div1); + append(div1, t4); + append(div1, b); + append(b, t5); + append(div2, t6); + if (if_block0) if_block0.m(div2, null); + append(div3, t7); + if (if_block1) if_block1.m(div3, null); + append(div5, t8); + append(div5, div4); + append(div4, input); + set_input_value(input, /*$settings*/ ctx[3][/*periodicity*/ ctx[1]].format); + /*input_binding*/ ctx[12](input); + + if (!mounted) { + dispose = [ + listen(input, "input", /*input_input_handler*/ ctx[11]), + listen(input, "change", /*onChange*/ ctx[10]), + listen(input, "input", /*clearError*/ ctx[9]) + ]; + + mounted = true; + } + }, + p(ctx, [dirty]) { + if (dirty & /*value*/ 4 && t5_value !== (t5_value = window.moment().format(/*value*/ ctx[2] || /*defaultFormat*/ ctx[8]) + "")) set_data(t5, t5_value); + + if (/*isTemplateNested*/ ctx[6]) { + if (if_block0) { + if_block0.p(ctx, dirty); + } else { + if_block0 = create_if_block_1$1(ctx); + if_block0.c(); + if_block0.m(div2, null); + } + } else if (if_block0) { + if_block0.d(1); + if_block0 = null; + } + + if (/*error*/ ctx[5]) { + if (if_block1) { + if_block1.p(ctx, dirty); + } else { + if_block1 = create_if_block$3(ctx); + if_block1.c(); + if_block1.m(div3, null); + } + } else if (if_block1) { + if_block1.d(1); + if_block1 = null; + } + + if (dirty & /*$settings, periodicity*/ 10 && input.value !== /*$settings*/ ctx[3][/*periodicity*/ ctx[1]].format) { + set_input_value(input, /*$settings*/ ctx[3][/*periodicity*/ ctx[1]].format); + } + + if (dirty & /*error*/ 32) { + toggle_class(input, "has-error", !!/*error*/ ctx[5]); + } + }, + i: noop, + o: noop, + d(detaching) { + if (detaching) detach(div5); + if (if_block0) if_block0.d(); + if (if_block1) if_block1.d(); + /*input_binding*/ ctx[12](null); + mounted = false; + run_all(dispose); + } + }; +} + +function instance$3($$self, $$props, $$invalidate) { + let $settings, + $$unsubscribe_settings = noop, + $$subscribe_settings = () => ($$unsubscribe_settings(), $$unsubscribe_settings = subscribe(settings, $$value => $$invalidate(3, $settings = $$value)), settings); + + $$self.$$.on_destroy.push(() => $$unsubscribe_settings()); + + + let { settings } = $$props; + $$subscribe_settings(); + let { periodicity } = $$props; + + const DEFAULT_FORMATS = { + daily: DEFAULT_DAILY_NOTE_FORMAT_1, + weekly: DEFAULT_WEEKLY_NOTE_FORMAT_1, + monthly: DEFAULT_MONTHLY_NOTE_FORMAT_1, + quarterly: DEFAULT_QUARTERLY_NOTE_FORMAT_1, + yearly: DEFAULT_YEARLY_NOTE_FORMAT_1 + }; + + const defaultFormat = DEFAULT_FORMATS[periodicity]; + let inputEl; + let value; + let error; + let isTemplateNested; + let basename; + + onMount(() => { + $$invalidate(5, error = validateFormat(inputEl.value, periodicity)); + }); + + function clearError() { + $$invalidate(5, error = ""); + } + + function onChange() { + $$invalidate(5, error = validateFormat(inputEl.value, periodicity)); + } + + function input_input_handler() { + $settings[periodicity].format = this.value; + settings.set($settings); + $$invalidate(1, periodicity); + } + + function input_binding($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + inputEl = $$value; + $$invalidate(4, inputEl); + }); + } + + $$self.$$set = $$props => { + if ("settings" in $$props) $$subscribe_settings($$invalidate(0, settings = $$props.settings)); + if ("periodicity" in $$props) $$invalidate(1, periodicity = $$props.periodicity); + }; + + $$self.$$.update = () => { + if ($$self.$$.dirty & /*$settings, periodicity, value*/ 14) { + { + $$invalidate(2, value = $settings[periodicity].format || ""); + $$invalidate(6, isTemplateNested = value.indexOf("/") !== -1); + $$invalidate(7, basename = getBasename(value)); + } + } + }; + + return [ + settings, + periodicity, + value, + $settings, + inputEl, + error, + isTemplateNested, + basename, + defaultFormat, + clearError, + onChange, + input_input_handler, + input_binding + ]; +} + +class NoteFormatSetting extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$3, create_fragment$3, safe_not_equal, { settings: 0, periodicity: 1 }); + } +} + +var top = 'top'; +var bottom = 'bottom'; +var right = 'right'; +var left = 'left'; +var auto = 'auto'; +var basePlacements = [top, bottom, right, left]; +var start = 'start'; +var end = 'end'; +var clippingParents = 'clippingParents'; +var viewport = 'viewport'; +var popper = 'popper'; +var reference = 'reference'; +var variationPlacements = /*#__PURE__*/basePlacements.reduce(function (acc, placement) { + return acc.concat([placement + "-" + start, placement + "-" + end]); +}, []); +var placements = /*#__PURE__*/[].concat(basePlacements, [auto]).reduce(function (acc, placement) { + return acc.concat([placement, placement + "-" + start, placement + "-" + end]); +}, []); // modifiers that need to read the DOM + +var beforeRead = 'beforeRead'; +var read = 'read'; +var afterRead = 'afterRead'; // pure-logic modifiers + +var beforeMain = 'beforeMain'; +var main = 'main'; +var afterMain = 'afterMain'; // modifier with the purpose to write to the DOM (or write into a framework state) + +var beforeWrite = 'beforeWrite'; +var write = 'write'; +var afterWrite = 'afterWrite'; +var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite]; + +function getNodeName(element) { + return element ? (element.nodeName || '').toLowerCase() : null; +} + +function getWindow(node) { + if (node == null) { + return window; + } + + if (node.toString() !== '[object Window]') { + var ownerDocument = node.ownerDocument; + return ownerDocument ? ownerDocument.defaultView || window : window; + } + + return node; +} + +function isElement(node) { + var OwnElement = getWindow(node).Element; + return node instanceof OwnElement || node instanceof Element; +} + +function isHTMLElement(node) { + var OwnElement = getWindow(node).HTMLElement; + return node instanceof OwnElement || node instanceof HTMLElement; +} + +function isShadowRoot(node) { + // IE 11 has no ShadowRoot + if (typeof ShadowRoot === 'undefined') { + return false; + } + + var OwnElement = getWindow(node).ShadowRoot; + return node instanceof OwnElement || node instanceof ShadowRoot; +} + +// and applies them to the HTMLElements such as popper and arrow + +function applyStyles(_ref) { + var state = _ref.state; + Object.keys(state.elements).forEach(function (name) { + var style = state.styles[name] || {}; + var attributes = state.attributes[name] || {}; + var element = state.elements[name]; // arrow is optional + virtual elements + + if (!isHTMLElement(element) || !getNodeName(element)) { + return; + } // Flow doesn't support to extend this property, but it's the most + // effective way to apply styles to an HTMLElement + // $FlowFixMe[cannot-write] + + + Object.assign(element.style, style); + Object.keys(attributes).forEach(function (name) { + var value = attributes[name]; + + if (value === false) { + element.removeAttribute(name); + } else { + element.setAttribute(name, value === true ? '' : value); + } + }); + }); +} + +function effect$2(_ref2) { + var state = _ref2.state; + var initialStyles = { + popper: { + position: state.options.strategy, + left: '0', + top: '0', + margin: '0' + }, + arrow: { + position: 'absolute' + }, + reference: {} + }; + Object.assign(state.elements.popper.style, initialStyles.popper); + state.styles = initialStyles; + + if (state.elements.arrow) { + Object.assign(state.elements.arrow.style, initialStyles.arrow); + } + + return function () { + Object.keys(state.elements).forEach(function (name) { + var element = state.elements[name]; + var attributes = state.attributes[name] || {}; + var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]); // Set all values to an empty string to unset them + + var style = styleProperties.reduce(function (style, property) { + style[property] = ''; + return style; + }, {}); // arrow is optional + virtual elements + + if (!isHTMLElement(element) || !getNodeName(element)) { + return; + } + + Object.assign(element.style, style); + Object.keys(attributes).forEach(function (attribute) { + element.removeAttribute(attribute); + }); + }); + }; +} // eslint-disable-next-line import/no-unused-modules + + +var applyStyles$1 = { + name: 'applyStyles', + enabled: true, + phase: 'write', + fn: applyStyles, + effect: effect$2, + requires: ['computeStyles'] +}; + +function getBasePlacement(placement) { + return placement.split('-')[0]; +} + +function getBoundingClientRect(element) { + var rect = element.getBoundingClientRect(); + return { + width: rect.width, + height: rect.height, + top: rect.top, + right: rect.right, + bottom: rect.bottom, + left: rect.left, + x: rect.left, + y: rect.top + }; +} + +// means it doesn't take into account transforms. + +function getLayoutRect(element) { + var clientRect = getBoundingClientRect(element); // Use the clientRect sizes if it's not been transformed. + // Fixes https://github.com/popperjs/popper-core/issues/1223 + + var width = element.offsetWidth; + var height = element.offsetHeight; + + if (Math.abs(clientRect.width - width) <= 1) { + width = clientRect.width; + } + + if (Math.abs(clientRect.height - height) <= 1) { + height = clientRect.height; + } + + return { + x: element.offsetLeft, + y: element.offsetTop, + width: width, + height: height + }; +} + +function contains(parent, child) { + var rootNode = child.getRootNode && child.getRootNode(); // First, attempt with faster native method + + if (parent.contains(child)) { + return true; + } // then fallback to custom implementation with Shadow DOM support + else if (rootNode && isShadowRoot(rootNode)) { + var next = child; + + do { + if (next && parent.isSameNode(next)) { + return true; + } // $FlowFixMe[prop-missing]: need a better way to handle this... + + + next = next.parentNode || next.host; + } while (next); + } // Give up, the result is false + + + return false; +} + +function getComputedStyle$1(element) { + return getWindow(element).getComputedStyle(element); +} + +function isTableElement(element) { + return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0; +} + +function getDocumentElement(element) { + // $FlowFixMe[incompatible-return]: assume body is always available + return ((isElement(element) ? element.ownerDocument : // $FlowFixMe[prop-missing] + element.document) || window.document).documentElement; +} + +function getParentNode(element) { + if (getNodeName(element) === 'html') { + return element; + } + + return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle + // $FlowFixMe[incompatible-return] + // $FlowFixMe[prop-missing] + element.assignedSlot || // step into the shadow DOM of the parent of a slotted node + element.parentNode || ( // DOM Element detected + isShadowRoot(element) ? element.host : null) || // ShadowRoot detected + // $FlowFixMe[incompatible-call]: HTMLElement is a Node + getDocumentElement(element) // fallback + + ); +} + +function getTrueOffsetParent(element) { + if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837 + getComputedStyle$1(element).position === 'fixed') { + return null; + } + + return element.offsetParent; +} // `.offsetParent` reports `null` for fixed elements, while absolute elements +// return the containing block + + +function getContainingBlock(element) { + var isFirefox = navigator.userAgent.toLowerCase().indexOf('firefox') !== -1; + var currentNode = getParentNode(element); + + while (isHTMLElement(currentNode) && ['html', 'body'].indexOf(getNodeName(currentNode)) < 0) { + var css = getComputedStyle$1(currentNode); // This is non-exhaustive but covers the most common CSS properties that + // create a containing block. + // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block + + if (css.transform !== 'none' || css.perspective !== 'none' || css.contain === 'paint' || ['transform', 'perspective'].indexOf(css.willChange) !== -1 || isFirefox && css.willChange === 'filter' || isFirefox && css.filter && css.filter !== 'none') { + return currentNode; + } else { + currentNode = currentNode.parentNode; + } + } + + return null; +} // Gets the closest ancestor positioned element. Handles some edge cases, +// such as table ancestors and cross browser bugs. + + +function getOffsetParent(element) { + var window = getWindow(element); + var offsetParent = getTrueOffsetParent(element); + + while (offsetParent && isTableElement(offsetParent) && getComputedStyle$1(offsetParent).position === 'static') { + offsetParent = getTrueOffsetParent(offsetParent); + } + + if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle$1(offsetParent).position === 'static')) { + return window; + } + + return offsetParent || getContainingBlock(element) || window; +} + +function getMainAxisFromPlacement(placement) { + return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y'; +} + +var max = Math.max; +var min = Math.min; +var round = Math.round; + +function within(min$1, value, max$1) { + return max(min$1, min(value, max$1)); +} + +function getFreshSideObject() { + return { + top: 0, + right: 0, + bottom: 0, + left: 0 + }; +} + +function mergePaddingObject(paddingObject) { + return Object.assign({}, getFreshSideObject(), paddingObject); +} + +function expandToHashMap(value, keys) { + return keys.reduce(function (hashMap, key) { + hashMap[key] = value; + return hashMap; + }, {}); +} + +var toPaddingObject = function toPaddingObject(padding, state) { + padding = typeof padding === 'function' ? padding(Object.assign({}, state.rects, { + placement: state.placement + })) : padding; + return mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements)); +}; + +function arrow(_ref) { + var _state$modifiersData$; + + var state = _ref.state, + name = _ref.name, + options = _ref.options; + var arrowElement = state.elements.arrow; + var popperOffsets = state.modifiersData.popperOffsets; + var basePlacement = getBasePlacement(state.placement); + var axis = getMainAxisFromPlacement(basePlacement); + var isVertical = [left, right].indexOf(basePlacement) >= 0; + var len = isVertical ? 'height' : 'width'; + + if (!arrowElement || !popperOffsets) { + return; + } + + var paddingObject = toPaddingObject(options.padding, state); + var arrowRect = getLayoutRect(arrowElement); + var minProp = axis === 'y' ? top : left; + var maxProp = axis === 'y' ? bottom : right; + var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len]; + var startDiff = popperOffsets[axis] - state.rects.reference[axis]; + var arrowOffsetParent = getOffsetParent(arrowElement); + var clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0; + var centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the popper if the center point is + // outside of the popper bounds + + var min = paddingObject[minProp]; + var max = clientSize - arrowRect[len] - paddingObject[maxProp]; + var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference; + var offset = within(min, center, max); // Prevents breaking syntax highlighting... + + var axisProp = axis; + state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset, _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$); +} + +function effect$1(_ref2) { + var state = _ref2.state, + options = _ref2.options; + var _options$element = options.element, + arrowElement = _options$element === void 0 ? '[data-popper-arrow]' : _options$element; + + if (arrowElement == null) { + return; + } // CSS selector + + + if (typeof arrowElement === 'string') { + arrowElement = state.elements.popper.querySelector(arrowElement); + + if (!arrowElement) { + return; + } + } + + if (process.env.NODE_ENV !== "production") { + if (!isHTMLElement(arrowElement)) { + console.error(['Popper: "arrow" element must be an HTMLElement (not an SVGElement).', 'To use an SVG arrow, wrap it in an HTMLElement that will be used as', 'the arrow.'].join(' ')); + } + } + + if (!contains(state.elements.popper, arrowElement)) { + if (process.env.NODE_ENV !== "production") { + console.error(['Popper: "arrow" modifier\'s `element` must be a child of the popper', 'element.'].join(' ')); + } + + return; + } + + state.elements.arrow = arrowElement; +} // eslint-disable-next-line import/no-unused-modules + + +var arrow$1 = { + name: 'arrow', + enabled: true, + phase: 'main', + fn: arrow, + effect: effect$1, + requires: ['popperOffsets'], + requiresIfExists: ['preventOverflow'] +}; + +var unsetSides = { + top: 'auto', + right: 'auto', + bottom: 'auto', + left: 'auto' +}; // Round the offsets to the nearest suitable subpixel based on the DPR. +// Zooming can change the DPR, but it seems to report a value that will +// cleanly divide the values into the appropriate subpixels. + +function roundOffsetsByDPR(_ref) { + var x = _ref.x, + y = _ref.y; + var win = window; + var dpr = win.devicePixelRatio || 1; + return { + x: round(round(x * dpr) / dpr) || 0, + y: round(round(y * dpr) / dpr) || 0 + }; +} + +function mapToStyles(_ref2) { + var _Object$assign2; + + var popper = _ref2.popper, + popperRect = _ref2.popperRect, + placement = _ref2.placement, + offsets = _ref2.offsets, + position = _ref2.position, + gpuAcceleration = _ref2.gpuAcceleration, + adaptive = _ref2.adaptive, + roundOffsets = _ref2.roundOffsets; + + var _ref3 = roundOffsets === true ? roundOffsetsByDPR(offsets) : typeof roundOffsets === 'function' ? roundOffsets(offsets) : offsets, + _ref3$x = _ref3.x, + x = _ref3$x === void 0 ? 0 : _ref3$x, + _ref3$y = _ref3.y, + y = _ref3$y === void 0 ? 0 : _ref3$y; + + var hasX = offsets.hasOwnProperty('x'); + var hasY = offsets.hasOwnProperty('y'); + var sideX = left; + var sideY = top; + var win = window; + + if (adaptive) { + var offsetParent = getOffsetParent(popper); + var heightProp = 'clientHeight'; + var widthProp = 'clientWidth'; + + if (offsetParent === getWindow(popper)) { + offsetParent = getDocumentElement(popper); + + if (getComputedStyle$1(offsetParent).position !== 'static') { + heightProp = 'scrollHeight'; + widthProp = 'scrollWidth'; + } + } // $FlowFixMe[incompatible-cast]: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it + + + offsetParent = offsetParent; + + if (placement === top) { + sideY = bottom; // $FlowFixMe[prop-missing] + + y -= offsetParent[heightProp] - popperRect.height; + y *= gpuAcceleration ? 1 : -1; + } + + if (placement === left) { + sideX = right; // $FlowFixMe[prop-missing] + + x -= offsetParent[widthProp] - popperRect.width; + x *= gpuAcceleration ? 1 : -1; + } + } + + var commonStyles = Object.assign({ + position: position + }, adaptive && unsetSides); + + if (gpuAcceleration) { + var _Object$assign; + + return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? '0' : '', _Object$assign[sideX] = hasX ? '0' : '', _Object$assign.transform = (win.devicePixelRatio || 1) < 2 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", _Object$assign)); + } + + return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : '', _Object$assign2[sideX] = hasX ? x + "px" : '', _Object$assign2.transform = '', _Object$assign2)); +} + +function computeStyles(_ref4) { + var state = _ref4.state, + options = _ref4.options; + var _options$gpuAccelerat = options.gpuAcceleration, + gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat, + _options$adaptive = options.adaptive, + adaptive = _options$adaptive === void 0 ? true : _options$adaptive, + _options$roundOffsets = options.roundOffsets, + roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets; + + if (process.env.NODE_ENV !== "production") { + var transitionProperty = getComputedStyle$1(state.elements.popper).transitionProperty || ''; + + if (adaptive && ['transform', 'top', 'right', 'bottom', 'left'].some(function (property) { + return transitionProperty.indexOf(property) >= 0; + })) { + console.warn(['Popper: Detected CSS transitions on at least one of the following', 'CSS properties: "transform", "top", "right", "bottom", "left".', '\n\n', 'Disable the "computeStyles" modifier\'s `adaptive` option to allow', 'for smooth transitions, or remove these properties from the CSS', 'transition declaration on the popper element if only transitioning', 'opacity or background-color for example.', '\n\n', 'We recommend using the popper element as a wrapper around an inner', 'element that can have any CSS property transitioned for animations.'].join(' ')); + } + } + + var commonStyles = { + placement: getBasePlacement(state.placement), + popper: state.elements.popper, + popperRect: state.rects.popper, + gpuAcceleration: gpuAcceleration + }; + + if (state.modifiersData.popperOffsets != null) { + state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, { + offsets: state.modifiersData.popperOffsets, + position: state.options.strategy, + adaptive: adaptive, + roundOffsets: roundOffsets + }))); + } + + if (state.modifiersData.arrow != null) { + state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, { + offsets: state.modifiersData.arrow, + position: 'absolute', + adaptive: false, + roundOffsets: roundOffsets + }))); + } + + state.attributes.popper = Object.assign({}, state.attributes.popper, { + 'data-popper-placement': state.placement + }); +} // eslint-disable-next-line import/no-unused-modules + + +var computeStyles$1 = { + name: 'computeStyles', + enabled: true, + phase: 'beforeWrite', + fn: computeStyles, + data: {} +}; + +var passive = { + passive: true +}; + +function effect(_ref) { + var state = _ref.state, + instance = _ref.instance, + options = _ref.options; + var _options$scroll = options.scroll, + scroll = _options$scroll === void 0 ? true : _options$scroll, + _options$resize = options.resize, + resize = _options$resize === void 0 ? true : _options$resize; + var window = getWindow(state.elements.popper); + var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper); + + if (scroll) { + scrollParents.forEach(function (scrollParent) { + scrollParent.addEventListener('scroll', instance.update, passive); + }); + } + + if (resize) { + window.addEventListener('resize', instance.update, passive); + } + + return function () { + if (scroll) { + scrollParents.forEach(function (scrollParent) { + scrollParent.removeEventListener('scroll', instance.update, passive); + }); + } + + if (resize) { + window.removeEventListener('resize', instance.update, passive); + } + }; +} // eslint-disable-next-line import/no-unused-modules + + +var eventListeners = { + name: 'eventListeners', + enabled: true, + phase: 'write', + fn: function fn() {}, + effect: effect, + data: {} +}; + +var hash$1 = { + left: 'right', + right: 'left', + bottom: 'top', + top: 'bottom' +}; +function getOppositePlacement(placement) { + return placement.replace(/left|right|bottom|top/g, function (matched) { + return hash$1[matched]; + }); +} + +var hash = { + start: 'end', + end: 'start' +}; +function getOppositeVariationPlacement(placement) { + return placement.replace(/start|end/g, function (matched) { + return hash[matched]; + }); +} + +function getWindowScroll(node) { + var win = getWindow(node); + var scrollLeft = win.pageXOffset; + var scrollTop = win.pageYOffset; + return { + scrollLeft: scrollLeft, + scrollTop: scrollTop + }; +} + +function getWindowScrollBarX(element) { + // If has a CSS width greater than the viewport, then this will be + // incorrect for RTL. + // Popper 1 is broken in this case and never had a bug report so let's assume + // it's not an issue. I don't think anyone ever specifies width on + // anyway. + // Browsers where the left scrollbar doesn't cause an issue report `0` for + // this (e.g. Edge 2019, IE11, Safari) + return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft; +} + +function getViewportRect(element) { + var win = getWindow(element); + var html = getDocumentElement(element); + var visualViewport = win.visualViewport; + var width = html.clientWidth; + var height = html.clientHeight; + var x = 0; + var y = 0; // NB: This isn't supported on iOS <= 12. If the keyboard is open, the popper + // can be obscured underneath it. + // Also, `html.clientHeight` adds the bottom bar height in Safari iOS, even + // if it isn't open, so if this isn't available, the popper will be detected + // to overflow the bottom of the screen too early. + + if (visualViewport) { + width = visualViewport.width; + height = visualViewport.height; // Uses Layout Viewport (like Chrome; Safari does not currently) + // In Chrome, it returns a value very close to 0 (+/-) but contains rounding + // errors due to floating point numbers, so we need to check precision. + // Safari returns a number <= 0, usually < -1 when pinch-zoomed + // Feature detection fails in mobile emulation mode in Chrome. + // Math.abs(win.innerWidth / visualViewport.scale - visualViewport.width) < + // 0.001 + // Fallback here: "Not Safari" userAgent + + if (!/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) { + x = visualViewport.offsetLeft; + y = visualViewport.offsetTop; + } + } + + return { + width: width, + height: height, + x: x + getWindowScrollBarX(element), + y: y + }; +} + +// of the `` and `` rect bounds if horizontally scrollable + +function getDocumentRect(element) { + var _element$ownerDocumen; + + var html = getDocumentElement(element); + var winScroll = getWindowScroll(element); + var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body; + var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0); + var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0); + var x = -winScroll.scrollLeft + getWindowScrollBarX(element); + var y = -winScroll.scrollTop; + + if (getComputedStyle$1(body || html).direction === 'rtl') { + x += max(html.clientWidth, body ? body.clientWidth : 0) - width; + } + + return { + width: width, + height: height, + x: x, + y: y + }; +} + +function isScrollParent(element) { + // Firefox wants us to check `-x` and `-y` variations as well + var _getComputedStyle = getComputedStyle$1(element), + overflow = _getComputedStyle.overflow, + overflowX = _getComputedStyle.overflowX, + overflowY = _getComputedStyle.overflowY; + + return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX); +} + +function getScrollParent(node) { + if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) { + // $FlowFixMe[incompatible-return]: assume body is always available + return node.ownerDocument.body; + } + + if (isHTMLElement(node) && isScrollParent(node)) { + return node; + } + + return getScrollParent(getParentNode(node)); +} + +/* +given a DOM element, return the list of all scroll parents, up the list of ancesors +until we get to the top window object. This list is what we attach scroll listeners +to, because if any of these parent elements scroll, we'll need to re-calculate the +reference element's position. +*/ + +function listScrollParents(element, list) { + var _element$ownerDocumen; + + if (list === void 0) { + list = []; + } + + var scrollParent = getScrollParent(element); + var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body); + var win = getWindow(scrollParent); + var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent; + var updatedList = list.concat(target); + return isBody ? updatedList : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here + updatedList.concat(listScrollParents(getParentNode(target))); +} + +function rectToClientRect(rect) { + return Object.assign({}, rect, { + left: rect.x, + top: rect.y, + right: rect.x + rect.width, + bottom: rect.y + rect.height + }); +} + +function getInnerBoundingClientRect(element) { + var rect = getBoundingClientRect(element); + rect.top = rect.top + element.clientTop; + rect.left = rect.left + element.clientLeft; + rect.bottom = rect.top + element.clientHeight; + rect.right = rect.left + element.clientWidth; + rect.width = element.clientWidth; + rect.height = element.clientHeight; + rect.x = rect.left; + rect.y = rect.top; + return rect; +} + +function getClientRectFromMixedType(element, clippingParent) { + return clippingParent === viewport ? rectToClientRect(getViewportRect(element)) : isHTMLElement(clippingParent) ? getInnerBoundingClientRect(clippingParent) : rectToClientRect(getDocumentRect(getDocumentElement(element))); +} // A "clipping parent" is an overflowable container with the characteristic of +// clipping (or hiding) overflowing elements with a position different from +// `initial` + + +function getClippingParents(element) { + var clippingParents = listScrollParents(getParentNode(element)); + var canEscapeClipping = ['absolute', 'fixed'].indexOf(getComputedStyle$1(element).position) >= 0; + var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element; + + if (!isElement(clipperElement)) { + return []; + } // $FlowFixMe[incompatible-return]: https://github.com/facebook/flow/issues/1414 + + + return clippingParents.filter(function (clippingParent) { + return isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== 'body'; + }); +} // Gets the maximum area that the element is visible in due to any number of +// clipping parents + + +function getClippingRect(element, boundary, rootBoundary) { + var mainClippingParents = boundary === 'clippingParents' ? getClippingParents(element) : [].concat(boundary); + var clippingParents = [].concat(mainClippingParents, [rootBoundary]); + var firstClippingParent = clippingParents[0]; + var clippingRect = clippingParents.reduce(function (accRect, clippingParent) { + var rect = getClientRectFromMixedType(element, clippingParent); + accRect.top = max(rect.top, accRect.top); + accRect.right = min(rect.right, accRect.right); + accRect.bottom = min(rect.bottom, accRect.bottom); + accRect.left = max(rect.left, accRect.left); + return accRect; + }, getClientRectFromMixedType(element, firstClippingParent)); + clippingRect.width = clippingRect.right - clippingRect.left; + clippingRect.height = clippingRect.bottom - clippingRect.top; + clippingRect.x = clippingRect.left; + clippingRect.y = clippingRect.top; + return clippingRect; +} + +function getVariation(placement) { + return placement.split('-')[1]; +} + +function computeOffsets(_ref) { + var reference = _ref.reference, + element = _ref.element, + placement = _ref.placement; + var basePlacement = placement ? getBasePlacement(placement) : null; + var variation = placement ? getVariation(placement) : null; + var commonX = reference.x + reference.width / 2 - element.width / 2; + var commonY = reference.y + reference.height / 2 - element.height / 2; + var offsets; + + switch (basePlacement) { + case top: + offsets = { + x: commonX, + y: reference.y - element.height + }; + break; + + case bottom: + offsets = { + x: commonX, + y: reference.y + reference.height + }; + break; + + case right: + offsets = { + x: reference.x + reference.width, + y: commonY + }; + break; + + case left: + offsets = { + x: reference.x - element.width, + y: commonY + }; + break; + + default: + offsets = { + x: reference.x, + y: reference.y + }; + } + + var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null; + + if (mainAxis != null) { + var len = mainAxis === 'y' ? 'height' : 'width'; + + switch (variation) { + case start: + offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2); + break; + + case end: + offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2); + break; + } + } + + return offsets; +} + +function detectOverflow(state, options) { + if (options === void 0) { + options = {}; + } + + var _options = options, + _options$placement = _options.placement, + placement = _options$placement === void 0 ? state.placement : _options$placement, + _options$boundary = _options.boundary, + boundary = _options$boundary === void 0 ? clippingParents : _options$boundary, + _options$rootBoundary = _options.rootBoundary, + rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary, + _options$elementConte = _options.elementContext, + elementContext = _options$elementConte === void 0 ? popper : _options$elementConte, + _options$altBoundary = _options.altBoundary, + altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary, + _options$padding = _options.padding, + padding = _options$padding === void 0 ? 0 : _options$padding; + var paddingObject = mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements)); + var altContext = elementContext === popper ? reference : popper; + var referenceElement = state.elements.reference; + var popperRect = state.rects.popper; + var element = state.elements[altBoundary ? altContext : elementContext]; + var clippingClientRect = getClippingRect(isElement(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary); + var referenceClientRect = getBoundingClientRect(referenceElement); + var popperOffsets = computeOffsets({ + reference: referenceClientRect, + element: popperRect, + strategy: 'absolute', + placement: placement + }); + var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets)); + var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect; // positive = overflowing the clipping rect + // 0 or negative = within the clipping rect + + var overflowOffsets = { + top: clippingClientRect.top - elementClientRect.top + paddingObject.top, + bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom, + left: clippingClientRect.left - elementClientRect.left + paddingObject.left, + right: elementClientRect.right - clippingClientRect.right + paddingObject.right + }; + var offsetData = state.modifiersData.offset; // Offsets can be applied only to the popper element + + if (elementContext === popper && offsetData) { + var offset = offsetData[placement]; + Object.keys(overflowOffsets).forEach(function (key) { + var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1; + var axis = [top, bottom].indexOf(key) >= 0 ? 'y' : 'x'; + overflowOffsets[key] += offset[axis] * multiply; + }); + } + + return overflowOffsets; +} + +function computeAutoPlacement(state, options) { + if (options === void 0) { + options = {}; + } + + var _options = options, + placement = _options.placement, + boundary = _options.boundary, + rootBoundary = _options.rootBoundary, + padding = _options.padding, + flipVariations = _options.flipVariations, + _options$allowedAutoP = _options.allowedAutoPlacements, + allowedAutoPlacements = _options$allowedAutoP === void 0 ? placements : _options$allowedAutoP; + var variation = getVariation(placement); + var placements$1 = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function (placement) { + return getVariation(placement) === variation; + }) : basePlacements; + var allowedPlacements = placements$1.filter(function (placement) { + return allowedAutoPlacements.indexOf(placement) >= 0; + }); + + if (allowedPlacements.length === 0) { + allowedPlacements = placements$1; + + if (process.env.NODE_ENV !== "production") { + console.error(['Popper: The `allowedAutoPlacements` option did not allow any', 'placements. Ensure the `placement` option matches the variation', 'of the allowed placements.', 'For example, "auto" cannot be used to allow "bottom-start".', 'Use "auto-start" instead.'].join(' ')); + } + } // $FlowFixMe[incompatible-type]: Flow seems to have problems with two array unions... + + + var overflows = allowedPlacements.reduce(function (acc, placement) { + acc[placement] = detectOverflow(state, { + placement: placement, + boundary: boundary, + rootBoundary: rootBoundary, + padding: padding + })[getBasePlacement(placement)]; + return acc; + }, {}); + return Object.keys(overflows).sort(function (a, b) { + return overflows[a] - overflows[b]; + }); +} + +function getExpandedFallbackPlacements(placement) { + if (getBasePlacement(placement) === auto) { + return []; + } + + var oppositePlacement = getOppositePlacement(placement); + return [getOppositeVariationPlacement(placement), oppositePlacement, getOppositeVariationPlacement(oppositePlacement)]; +} + +function flip(_ref) { + var state = _ref.state, + options = _ref.options, + name = _ref.name; + + if (state.modifiersData[name]._skip) { + return; + } + + var _options$mainAxis = options.mainAxis, + checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, + _options$altAxis = options.altAxis, + checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis, + specifiedFallbackPlacements = options.fallbackPlacements, + padding = options.padding, + boundary = options.boundary, + rootBoundary = options.rootBoundary, + altBoundary = options.altBoundary, + _options$flipVariatio = options.flipVariations, + flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio, + allowedAutoPlacements = options.allowedAutoPlacements; + var preferredPlacement = state.options.placement; + var basePlacement = getBasePlacement(preferredPlacement); + var isBasePlacement = basePlacement === preferredPlacement; + var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [getOppositePlacement(preferredPlacement)] : getExpandedFallbackPlacements(preferredPlacement)); + var placements = [preferredPlacement].concat(fallbackPlacements).reduce(function (acc, placement) { + return acc.concat(getBasePlacement(placement) === auto ? computeAutoPlacement(state, { + placement: placement, + boundary: boundary, + rootBoundary: rootBoundary, + padding: padding, + flipVariations: flipVariations, + allowedAutoPlacements: allowedAutoPlacements + }) : placement); + }, []); + var referenceRect = state.rects.reference; + var popperRect = state.rects.popper; + var checksMap = new Map(); + var makeFallbackChecks = true; + var firstFittingPlacement = placements[0]; + + for (var i = 0; i < placements.length; i++) { + var placement = placements[i]; + + var _basePlacement = getBasePlacement(placement); + + var isStartVariation = getVariation(placement) === start; + var isVertical = [top, bottom].indexOf(_basePlacement) >= 0; + var len = isVertical ? 'width' : 'height'; + var overflow = detectOverflow(state, { + placement: placement, + boundary: boundary, + rootBoundary: rootBoundary, + altBoundary: altBoundary, + padding: padding + }); + var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top; + + if (referenceRect[len] > popperRect[len]) { + mainVariationSide = getOppositePlacement(mainVariationSide); + } + + var altVariationSide = getOppositePlacement(mainVariationSide); + var checks = []; + + if (checkMainAxis) { + checks.push(overflow[_basePlacement] <= 0); + } + + if (checkAltAxis) { + checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0); + } + + if (checks.every(function (check) { + return check; + })) { + firstFittingPlacement = placement; + makeFallbackChecks = false; + break; + } + + checksMap.set(placement, checks); + } + + if (makeFallbackChecks) { + // `2` may be desired in some cases – research later + var numberOfChecks = flipVariations ? 3 : 1; + + var _loop = function _loop(_i) { + var fittingPlacement = placements.find(function (placement) { + var checks = checksMap.get(placement); + + if (checks) { + return checks.slice(0, _i).every(function (check) { + return check; + }); + } + }); + + if (fittingPlacement) { + firstFittingPlacement = fittingPlacement; + return "break"; + } + }; + + for (var _i = numberOfChecks; _i > 0; _i--) { + var _ret = _loop(_i); + + if (_ret === "break") break; + } + } + + if (state.placement !== firstFittingPlacement) { + state.modifiersData[name]._skip = true; + state.placement = firstFittingPlacement; + state.reset = true; + } +} // eslint-disable-next-line import/no-unused-modules + + +var flip$1 = { + name: 'flip', + enabled: true, + phase: 'main', + fn: flip, + requiresIfExists: ['offset'], + data: { + _skip: false + } +}; + +function getSideOffsets(overflow, rect, preventedOffsets) { + if (preventedOffsets === void 0) { + preventedOffsets = { + x: 0, + y: 0 + }; + } + + return { + top: overflow.top - rect.height - preventedOffsets.y, + right: overflow.right - rect.width + preventedOffsets.x, + bottom: overflow.bottom - rect.height + preventedOffsets.y, + left: overflow.left - rect.width - preventedOffsets.x + }; +} + +function isAnySideFullyClipped(overflow) { + return [top, right, bottom, left].some(function (side) { + return overflow[side] >= 0; + }); +} + +function hide(_ref) { + var state = _ref.state, + name = _ref.name; + var referenceRect = state.rects.reference; + var popperRect = state.rects.popper; + var preventedOffsets = state.modifiersData.preventOverflow; + var referenceOverflow = detectOverflow(state, { + elementContext: 'reference' + }); + var popperAltOverflow = detectOverflow(state, { + altBoundary: true + }); + var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect); + var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets); + var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets); + var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets); + state.modifiersData[name] = { + referenceClippingOffsets: referenceClippingOffsets, + popperEscapeOffsets: popperEscapeOffsets, + isReferenceHidden: isReferenceHidden, + hasPopperEscaped: hasPopperEscaped + }; + state.attributes.popper = Object.assign({}, state.attributes.popper, { + 'data-popper-reference-hidden': isReferenceHidden, + 'data-popper-escaped': hasPopperEscaped + }); +} // eslint-disable-next-line import/no-unused-modules + + +var hide$1 = { + name: 'hide', + enabled: true, + phase: 'main', + requiresIfExists: ['preventOverflow'], + fn: hide +}; + +function distanceAndSkiddingToXY(placement, rects, offset) { + var basePlacement = getBasePlacement(placement); + var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1; + + var _ref = typeof offset === 'function' ? offset(Object.assign({}, rects, { + placement: placement + })) : offset, + skidding = _ref[0], + distance = _ref[1]; + + skidding = skidding || 0; + distance = (distance || 0) * invertDistance; + return [left, right].indexOf(basePlacement) >= 0 ? { + x: distance, + y: skidding + } : { + x: skidding, + y: distance + }; +} + +function offset(_ref2) { + var state = _ref2.state, + options = _ref2.options, + name = _ref2.name; + var _options$offset = options.offset, + offset = _options$offset === void 0 ? [0, 0] : _options$offset; + var data = placements.reduce(function (acc, placement) { + acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset); + return acc; + }, {}); + var _data$state$placement = data[state.placement], + x = _data$state$placement.x, + y = _data$state$placement.y; + + if (state.modifiersData.popperOffsets != null) { + state.modifiersData.popperOffsets.x += x; + state.modifiersData.popperOffsets.y += y; + } + + state.modifiersData[name] = data; +} // eslint-disable-next-line import/no-unused-modules + + +var offset$1 = { + name: 'offset', + enabled: true, + phase: 'main', + requires: ['popperOffsets'], + fn: offset +}; + +function popperOffsets(_ref) { + var state = _ref.state, + name = _ref.name; + // Offsets are the actual position the popper needs to have to be + // properly positioned near its reference element + // This is the most basic placement, and will be adjusted by + // the modifiers in the next step + state.modifiersData[name] = computeOffsets({ + reference: state.rects.reference, + element: state.rects.popper, + strategy: 'absolute', + placement: state.placement + }); +} // eslint-disable-next-line import/no-unused-modules + + +var popperOffsets$1 = { + name: 'popperOffsets', + enabled: true, + phase: 'read', + fn: popperOffsets, + data: {} +}; + +function getAltAxis(axis) { + return axis === 'x' ? 'y' : 'x'; +} + +function preventOverflow(_ref) { + var state = _ref.state, + options = _ref.options, + name = _ref.name; + var _options$mainAxis = options.mainAxis, + checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, + _options$altAxis = options.altAxis, + checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis, + boundary = options.boundary, + rootBoundary = options.rootBoundary, + altBoundary = options.altBoundary, + padding = options.padding, + _options$tether = options.tether, + tether = _options$tether === void 0 ? true : _options$tether, + _options$tetherOffset = options.tetherOffset, + tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset; + var overflow = detectOverflow(state, { + boundary: boundary, + rootBoundary: rootBoundary, + padding: padding, + altBoundary: altBoundary + }); + var basePlacement = getBasePlacement(state.placement); + var variation = getVariation(state.placement); + var isBasePlacement = !variation; + var mainAxis = getMainAxisFromPlacement(basePlacement); + var altAxis = getAltAxis(mainAxis); + var popperOffsets = state.modifiersData.popperOffsets; + var referenceRect = state.rects.reference; + var popperRect = state.rects.popper; + var tetherOffsetValue = typeof tetherOffset === 'function' ? tetherOffset(Object.assign({}, state.rects, { + placement: state.placement + })) : tetherOffset; + var data = { + x: 0, + y: 0 + }; + + if (!popperOffsets) { + return; + } + + if (checkMainAxis || checkAltAxis) { + var mainSide = mainAxis === 'y' ? top : left; + var altSide = mainAxis === 'y' ? bottom : right; + var len = mainAxis === 'y' ? 'height' : 'width'; + var offset = popperOffsets[mainAxis]; + var min$1 = popperOffsets[mainAxis] + overflow[mainSide]; + var max$1 = popperOffsets[mainAxis] - overflow[altSide]; + var additive = tether ? -popperRect[len] / 2 : 0; + var minLen = variation === start ? referenceRect[len] : popperRect[len]; + var maxLen = variation === start ? -popperRect[len] : -referenceRect[len]; // We need to include the arrow in the calculation so the arrow doesn't go + // outside the reference bounds + + var arrowElement = state.elements.arrow; + var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : { + width: 0, + height: 0 + }; + var arrowPaddingObject = state.modifiersData['arrow#persistent'] ? state.modifiersData['arrow#persistent'].padding : getFreshSideObject(); + var arrowPaddingMin = arrowPaddingObject[mainSide]; + var arrowPaddingMax = arrowPaddingObject[altSide]; // If the reference length is smaller than the arrow length, we don't want + // to include its full size in the calculation. If the reference is small + // and near the edge of a boundary, the popper can overflow even if the + // reference is not overflowing as well (e.g. virtual elements with no + // width or height) + + var arrowLen = within(0, referenceRect[len], arrowRect[len]); + var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - tetherOffsetValue : minLen - arrowLen - arrowPaddingMin - tetherOffsetValue; + var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + tetherOffsetValue : maxLen + arrowLen + arrowPaddingMax + tetherOffsetValue; + var arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow); + var clientOffset = arrowOffsetParent ? mainAxis === 'y' ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0; + var offsetModifierValue = state.modifiersData.offset ? state.modifiersData.offset[state.placement][mainAxis] : 0; + var tetherMin = popperOffsets[mainAxis] + minOffset - offsetModifierValue - clientOffset; + var tetherMax = popperOffsets[mainAxis] + maxOffset - offsetModifierValue; + + if (checkMainAxis) { + var preventedOffset = within(tether ? min(min$1, tetherMin) : min$1, offset, tether ? max(max$1, tetherMax) : max$1); + popperOffsets[mainAxis] = preventedOffset; + data[mainAxis] = preventedOffset - offset; + } + + if (checkAltAxis) { + var _mainSide = mainAxis === 'x' ? top : left; + + var _altSide = mainAxis === 'x' ? bottom : right; + + var _offset = popperOffsets[altAxis]; + + var _min = _offset + overflow[_mainSide]; + + var _max = _offset - overflow[_altSide]; + + var _preventedOffset = within(tether ? min(_min, tetherMin) : _min, _offset, tether ? max(_max, tetherMax) : _max); + + popperOffsets[altAxis] = _preventedOffset; + data[altAxis] = _preventedOffset - _offset; + } + } + + state.modifiersData[name] = data; +} // eslint-disable-next-line import/no-unused-modules + + +var preventOverflow$1 = { + name: 'preventOverflow', + enabled: true, + phase: 'main', + fn: preventOverflow, + requiresIfExists: ['offset'] +}; + +function getHTMLElementScroll(element) { + return { + scrollLeft: element.scrollLeft, + scrollTop: element.scrollTop + }; +} + +function getNodeScroll(node) { + if (node === getWindow(node) || !isHTMLElement(node)) { + return getWindowScroll(node); + } else { + return getHTMLElementScroll(node); + } +} + +// Composite means it takes into account transforms as well as layout. + +function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) { + if (isFixed === void 0) { + isFixed = false; + } + + var documentElement = getDocumentElement(offsetParent); + var rect = getBoundingClientRect(elementOrVirtualElement); + var isOffsetParentAnElement = isHTMLElement(offsetParent); + var scroll = { + scrollLeft: 0, + scrollTop: 0 + }; + var offsets = { + x: 0, + y: 0 + }; + + if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) { + if (getNodeName(offsetParent) !== 'body' || // https://github.com/popperjs/popper-core/issues/1078 + isScrollParent(documentElement)) { + scroll = getNodeScroll(offsetParent); + } + + if (isHTMLElement(offsetParent)) { + offsets = getBoundingClientRect(offsetParent); + offsets.x += offsetParent.clientLeft; + offsets.y += offsetParent.clientTop; + } else if (documentElement) { + offsets.x = getWindowScrollBarX(documentElement); + } + } + + return { + x: rect.left + scroll.scrollLeft - offsets.x, + y: rect.top + scroll.scrollTop - offsets.y, + width: rect.width, + height: rect.height + }; +} + +function order(modifiers) { + var map = new Map(); + var visited = new Set(); + var result = []; + modifiers.forEach(function (modifier) { + map.set(modifier.name, modifier); + }); // On visiting object, check for its dependencies and visit them recursively + + function sort(modifier) { + visited.add(modifier.name); + var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []); + requires.forEach(function (dep) { + if (!visited.has(dep)) { + var depModifier = map.get(dep); + + if (depModifier) { + sort(depModifier); + } + } + }); + result.push(modifier); + } + + modifiers.forEach(function (modifier) { + if (!visited.has(modifier.name)) { + // check for visited object + sort(modifier); + } + }); + return result; +} + +function orderModifiers(modifiers) { + // order based on dependencies + var orderedModifiers = order(modifiers); // order based on phase + + return modifierPhases.reduce(function (acc, phase) { + return acc.concat(orderedModifiers.filter(function (modifier) { + return modifier.phase === phase; + })); + }, []); +} + +function debounce(fn) { + var pending; + return function () { + if (!pending) { + pending = new Promise(function (resolve) { + Promise.resolve().then(function () { + pending = undefined; + resolve(fn()); + }); + }); + } + + return pending; + }; +} + +function format(str) { + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + return [].concat(args).reduce(function (p, c) { + return p.replace(/%s/, c); + }, str); +} + +var INVALID_MODIFIER_ERROR = 'Popper: modifier "%s" provided an invalid %s property, expected %s but got %s'; +var MISSING_DEPENDENCY_ERROR = 'Popper: modifier "%s" requires "%s", but "%s" modifier is not available'; +var VALID_PROPERTIES = ['name', 'enabled', 'phase', 'fn', 'effect', 'requires', 'options']; +function validateModifiers(modifiers) { + modifiers.forEach(function (modifier) { + Object.keys(modifier).forEach(function (key) { + switch (key) { + case 'name': + if (typeof modifier.name !== 'string') { + console.error(format(INVALID_MODIFIER_ERROR, String(modifier.name), '"name"', '"string"', "\"" + String(modifier.name) + "\"")); + } + + break; + + case 'enabled': + if (typeof modifier.enabled !== 'boolean') { + console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"enabled"', '"boolean"', "\"" + String(modifier.enabled) + "\"")); + } + + case 'phase': + if (modifierPhases.indexOf(modifier.phase) < 0) { + console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"phase"', "either " + modifierPhases.join(', '), "\"" + String(modifier.phase) + "\"")); + } + + break; + + case 'fn': + if (typeof modifier.fn !== 'function') { + console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"fn"', '"function"', "\"" + String(modifier.fn) + "\"")); + } + + break; + + case 'effect': + if (typeof modifier.effect !== 'function') { + console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"effect"', '"function"', "\"" + String(modifier.fn) + "\"")); + } + + break; + + case 'requires': + if (!Array.isArray(modifier.requires)) { + console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"requires"', '"array"', "\"" + String(modifier.requires) + "\"")); + } + + break; + + case 'requiresIfExists': + if (!Array.isArray(modifier.requiresIfExists)) { + console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"requiresIfExists"', '"array"', "\"" + String(modifier.requiresIfExists) + "\"")); + } + + break; + + case 'options': + case 'data': + break; + + default: + console.error("PopperJS: an invalid property has been provided to the \"" + modifier.name + "\" modifier, valid properties are " + VALID_PROPERTIES.map(function (s) { + return "\"" + s + "\""; + }).join(', ') + "; but \"" + key + "\" was provided."); + } + + modifier.requires && modifier.requires.forEach(function (requirement) { + if (modifiers.find(function (mod) { + return mod.name === requirement; + }) == null) { + console.error(format(MISSING_DEPENDENCY_ERROR, String(modifier.name), requirement, requirement)); + } + }); + }); + }); +} + +function uniqueBy(arr, fn) { + var identifiers = new Set(); + return arr.filter(function (item) { + var identifier = fn(item); + + if (!identifiers.has(identifier)) { + identifiers.add(identifier); + return true; + } + }); +} + +function mergeByName(modifiers) { + var merged = modifiers.reduce(function (merged, current) { + var existing = merged[current.name]; + merged[current.name] = existing ? Object.assign({}, existing, current, { + options: Object.assign({}, existing.options, current.options), + data: Object.assign({}, existing.data, current.data) + }) : current; + return merged; + }, {}); // IE11 does not support Object.values + + return Object.keys(merged).map(function (key) { + return merged[key]; + }); +} + +var INVALID_ELEMENT_ERROR = 'Popper: Invalid reference or popper argument provided. They must be either a DOM element or virtual element.'; +var INFINITE_LOOP_ERROR = 'Popper: An infinite loop in the modifiers cycle has been detected! The cycle has been interrupted to prevent a browser crash.'; +var DEFAULT_OPTIONS = { + placement: 'bottom', + modifiers: [], + strategy: 'absolute' +}; + +function areValidElements() { + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + return !args.some(function (element) { + return !(element && typeof element.getBoundingClientRect === 'function'); + }); +} + +function popperGenerator(generatorOptions) { + if (generatorOptions === void 0) { + generatorOptions = {}; + } + + var _generatorOptions = generatorOptions, + _generatorOptions$def = _generatorOptions.defaultModifiers, + defaultModifiers = _generatorOptions$def === void 0 ? [] : _generatorOptions$def, + _generatorOptions$def2 = _generatorOptions.defaultOptions, + defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2; + return function createPopper(reference, popper, options) { + if (options === void 0) { + options = defaultOptions; + } + + var state = { + placement: 'bottom', + orderedModifiers: [], + options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions), + modifiersData: {}, + elements: { + reference: reference, + popper: popper + }, + attributes: {}, + styles: {} + }; + var effectCleanupFns = []; + var isDestroyed = false; + var instance = { + state: state, + setOptions: function setOptions(options) { + cleanupModifierEffects(); + state.options = Object.assign({}, defaultOptions, state.options, options); + state.scrollParents = { + reference: isElement(reference) ? listScrollParents(reference) : reference.contextElement ? listScrollParents(reference.contextElement) : [], + popper: listScrollParents(popper) + }; // Orders the modifiers based on their dependencies and `phase` + // properties + + var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers, state.options.modifiers))); // Strip out disabled modifiers + + state.orderedModifiers = orderedModifiers.filter(function (m) { + return m.enabled; + }); // Validate the provided modifiers so that the consumer will get warned + // if one of the modifiers is invalid for any reason + + if (process.env.NODE_ENV !== "production") { + var modifiers = uniqueBy([].concat(orderedModifiers, state.options.modifiers), function (_ref) { + var name = _ref.name; + return name; + }); + validateModifiers(modifiers); + + if (getBasePlacement(state.options.placement) === auto) { + var flipModifier = state.orderedModifiers.find(function (_ref2) { + var name = _ref2.name; + return name === 'flip'; + }); + + if (!flipModifier) { + console.error(['Popper: "auto" placements require the "flip" modifier be', 'present and enabled to work.'].join(' ')); + } + } + + var _getComputedStyle = getComputedStyle$1(popper), + marginTop = _getComputedStyle.marginTop, + marginRight = _getComputedStyle.marginRight, + marginBottom = _getComputedStyle.marginBottom, + marginLeft = _getComputedStyle.marginLeft; // We no longer take into account `margins` on the popper, and it can + // cause bugs with positioning, so we'll warn the consumer + + + if ([marginTop, marginRight, marginBottom, marginLeft].some(function (margin) { + return parseFloat(margin); + })) { + console.warn(['Popper: CSS "margin" styles cannot be used to apply padding', 'between the popper and its reference element or boundary.', 'To replicate margin, use the `offset` modifier, as well as', 'the `padding` option in the `preventOverflow` and `flip`', 'modifiers.'].join(' ')); + } + } + + runModifierEffects(); + return instance.update(); + }, + // Sync update – it will always be executed, even if not necessary. This + // is useful for low frequency updates where sync behavior simplifies the + // logic. + // For high frequency updates (e.g. `resize` and `scroll` events), always + // prefer the async Popper#update method + forceUpdate: function forceUpdate() { + if (isDestroyed) { + return; + } + + var _state$elements = state.elements, + reference = _state$elements.reference, + popper = _state$elements.popper; // Don't proceed if `reference` or `popper` are not valid elements + // anymore + + if (!areValidElements(reference, popper)) { + if (process.env.NODE_ENV !== "production") { + console.error(INVALID_ELEMENT_ERROR); + } + + return; + } // Store the reference and popper rects to be read by modifiers + + + state.rects = { + reference: getCompositeRect(reference, getOffsetParent(popper), state.options.strategy === 'fixed'), + popper: getLayoutRect(popper) + }; // Modifiers have the ability to reset the current update cycle. The + // most common use case for this is the `flip` modifier changing the + // placement, which then needs to re-run all the modifiers, because the + // logic was previously ran for the previous placement and is therefore + // stale/incorrect + + state.reset = false; + state.placement = state.options.placement; // On each update cycle, the `modifiersData` property for each modifier + // is filled with the initial data specified by the modifier. This means + // it doesn't persist and is fresh on each update. + // To ensure persistent data, use `${name}#persistent` + + state.orderedModifiers.forEach(function (modifier) { + return state.modifiersData[modifier.name] = Object.assign({}, modifier.data); + }); + var __debug_loops__ = 0; + + for (var index = 0; index < state.orderedModifiers.length; index++) { + if (process.env.NODE_ENV !== "production") { + __debug_loops__ += 1; + + if (__debug_loops__ > 100) { + console.error(INFINITE_LOOP_ERROR); + break; + } + } + + if (state.reset === true) { + state.reset = false; + index = -1; + continue; + } + + var _state$orderedModifie = state.orderedModifiers[index], + fn = _state$orderedModifie.fn, + _state$orderedModifie2 = _state$orderedModifie.options, + _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2, + name = _state$orderedModifie.name; + + if (typeof fn === 'function') { + state = fn({ + state: state, + options: _options, + name: name, + instance: instance + }) || state; + } + } + }, + // Async and optimistically optimized update – it will not be executed if + // not necessary (debounced to run at most once-per-tick) + update: debounce(function () { + return new Promise(function (resolve) { + instance.forceUpdate(); + resolve(state); + }); + }), + destroy: function destroy() { + cleanupModifierEffects(); + isDestroyed = true; + } + }; + + if (!areValidElements(reference, popper)) { + if (process.env.NODE_ENV !== "production") { + console.error(INVALID_ELEMENT_ERROR); + } + + return instance; + } + + instance.setOptions(options).then(function (state) { + if (!isDestroyed && options.onFirstUpdate) { + options.onFirstUpdate(state); + } + }); // Modifiers have the ability to execute arbitrary code before the first + // update cycle runs. They will be executed in the same order as the update + // cycle. This is useful when a modifier adds some persistent data that + // other modifiers need to use, but the modifier is run after the dependent + // one. + + function runModifierEffects() { + state.orderedModifiers.forEach(function (_ref3) { + var name = _ref3.name, + _ref3$options = _ref3.options, + options = _ref3$options === void 0 ? {} : _ref3$options, + effect = _ref3.effect; + + if (typeof effect === 'function') { + var cleanupFn = effect({ + state: state, + name: name, + instance: instance, + options: options + }); + + var noopFn = function noopFn() {}; + + effectCleanupFns.push(cleanupFn || noopFn); + } + }); + } + + function cleanupModifierEffects() { + effectCleanupFns.forEach(function (fn) { + return fn(); + }); + effectCleanupFns = []; + } + + return instance; + }; +} + +var defaultModifiers = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1, offset$1, flip$1, preventOverflow$1, arrow$1, hide$1]; +var createPopper = /*#__PURE__*/popperGenerator({ + defaultModifiers: defaultModifiers +}); // eslint-disable-next-line import/no-unused-modules + +class Suggest { + constructor(owner, containerEl, scope) { + this.owner = owner; + this.containerEl = containerEl; + containerEl.on("click", ".suggestion-item", this.onSuggestionClick.bind(this)); + containerEl.on("mousemove", ".suggestion-item", this.onSuggestionMouseover.bind(this)); + scope.register([], "ArrowUp", (event) => { + if (!event.isComposing) { + this.setSelectedItem(this.selectedItem - 1, true); + return false; + } + }); + scope.register([], "ArrowDown", (event) => { + if (!event.isComposing) { + this.setSelectedItem(this.selectedItem + 1, true); + return false; + } + }); + scope.register([], "Enter", (event) => { + if (!event.isComposing) { + this.useSelectedItem(event); + return false; + } + }); + } + onSuggestionClick(event, el) { + event.preventDefault(); + const item = this.suggestions.indexOf(el); + this.setSelectedItem(item, false); + this.useSelectedItem(event); + } + onSuggestionMouseover(_event, el) { + const item = this.suggestions.indexOf(el); + this.setSelectedItem(item, false); + } + setSuggestions(values) { + this.containerEl.empty(); + const suggestionEls = []; + values.forEach((value) => { + const suggestionEl = this.containerEl.createDiv("suggestion-item"); + this.owner.renderSuggestion(value, suggestionEl); + suggestionEls.push(suggestionEl); + }); + this.values = values; + this.suggestions = suggestionEls; + this.setSelectedItem(0, false); + } + useSelectedItem(event) { + const currentValue = this.values[this.selectedItem]; + if (currentValue) { + this.owner.selectSuggestion(currentValue, event); + } + } + setSelectedItem(selectedIndex, scrollIntoView) { + const normalizedIndex = wrapAround(selectedIndex, this.suggestions.length); + const prevSelectedSuggestion = this.suggestions[this.selectedItem]; + const selectedSuggestion = this.suggestions[normalizedIndex]; + prevSelectedSuggestion === null || prevSelectedSuggestion === void 0 ? void 0 : prevSelectedSuggestion.removeClass("is-selected"); + selectedSuggestion === null || selectedSuggestion === void 0 ? void 0 : selectedSuggestion.addClass("is-selected"); + this.selectedItem = normalizedIndex; + if (scrollIntoView) { + selectedSuggestion.scrollIntoView(false); + } + } +} +class TextInputSuggest { + constructor(app, inputEl) { + this.app = app; + this.inputEl = inputEl; + this.scope = new obsidian.Scope(); + this.suggestEl = createDiv("suggestion-container"); + const suggestion = this.suggestEl.createDiv("suggestion"); + this.suggest = new Suggest(this, suggestion, this.scope); + this.scope.register([], "Escape", this.close.bind(this)); + this.inputEl.addEventListener("input", this.onInputChanged.bind(this)); + this.inputEl.addEventListener("focus", this.onInputChanged.bind(this)); + this.inputEl.addEventListener("blur", this.close.bind(this)); + this.suggestEl.on("mousedown", ".suggestion-container", (event) => { + event.preventDefault(); + }); + } + onInputChanged() { + const inputStr = this.inputEl.value; + const suggestions = this.getSuggestions(inputStr); + if (suggestions.length > 0) { + this.suggest.setSuggestions(suggestions); + // eslint-disable-next-line @typescript-eslint/no-explicit-any + this.open(this.app.dom.appContainerEl, this.inputEl); + } + } + open(container, inputEl) { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + this.app.keymap.pushScope(this.scope); + container.appendChild(this.suggestEl); + this.popper = createPopper(inputEl, this.suggestEl, { + placement: "bottom-start", + modifiers: [ + { + name: "sameWidth", + enabled: true, + fn: ({ state, instance }) => { + // Note: positioning needs to be calculated twice - + // first pass - positioning it according to the width of the popper + // second pass - position it with the width bound to the reference element + // we need to early exit to avoid an infinite loop + const targetWidth = `${state.rects.reference.width}px`; + if (state.styles.popper.width === targetWidth) { + return; + } + state.styles.popper.width = targetWidth; + instance.update(); + }, + phase: "beforeWrite", + requires: ["computeStyles"], + }, + ], + }); + } + close() { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + this.app.keymap.popScope(this.scope); + this.suggest.setSuggestions([]); + this.popper.destroy(); + this.suggestEl.detach(); + } +} + +class FileSuggest extends TextInputSuggest { + getSuggestions(inputStr) { + const abstractFiles = this.app.vault.getAllLoadedFiles(); + const files = []; + const lowerCaseInputStr = inputStr.toLowerCase(); + abstractFiles.forEach((file) => { + if (file instanceof obsidian.TFile && + file.extension === "md" && + file.path.toLowerCase().contains(lowerCaseInputStr)) { + files.push(file); + } + }); + return files; + } + renderSuggestion(file, el) { + el.setText(file.path); + } + selectSuggestion(file) { + this.inputEl.value = file.path; + this.inputEl.trigger("input"); + this.close(); + } +} +class FolderSuggest extends TextInputSuggest { + getSuggestions(inputStr) { + const abstractFiles = this.app.vault.getAllLoadedFiles(); + const folders = []; + const lowerCaseInputStr = inputStr.toLowerCase(); + abstractFiles.forEach((folder) => { + if (folder instanceof obsidian.TFolder && + folder.path.toLowerCase().contains(lowerCaseInputStr)) { + folders.push(folder); + } + }); + return folders; + } + renderSuggestion(file, el) { + el.setText(file.path); + } + selectSuggestion(file) { + this.inputEl.value = file.path; + this.inputEl.trigger("input"); + this.close(); + } +} + +/* src/settings/NoteTemplateSetting.svelte generated by Svelte v3.35.0 */ + +function create_if_block$2(ctx) { + let div; + let t; + + return { + c() { + div = element("div"); + t = text(/*error*/ ctx[3]); + attr(div, "class", "has-error"); + }, + m(target, anchor) { + insert(target, div, anchor); + append(div, t); + }, + p(ctx, dirty) { + if (dirty & /*error*/ 8) set_data(t, /*error*/ ctx[3]); + }, + d(detaching) { + if (detaching) detach(div); + } + }; +} + +function create_fragment$2(ctx) { + let div4; + let div2; + let div0; + let t0_value = capitalize(/*periodicity*/ ctx[1]) + ""; + let t0; + let t1; + let t2; + let div1; + let t4; + let t5; + let div3; + let input; + let mounted; + let dispose; + let if_block = /*error*/ ctx[3] && create_if_block$2(ctx); + + return { + c() { + div4 = element("div"); + div2 = element("div"); + div0 = element("div"); + t0 = text(t0_value); + t1 = text(" Note Template"); + t2 = space(); + div1 = element("div"); + div1.textContent = "Choose the file to use as a template"; + t4 = space(); + if (if_block) if_block.c(); + t5 = space(); + div3 = element("div"); + input = element("input"); + attr(div0, "class", "setting-item-name"); + attr(div1, "class", "setting-item-description"); + attr(div2, "class", "setting-item-info"); + attr(input, "type", "text"); + attr(input, "spellcheck", false); + attr(input, "placeholder", "Example: folder/note"); + toggle_class(input, "has-error", !!/*error*/ ctx[3]); + attr(div3, "class", "setting-item-control"); + attr(div4, "class", "setting-item"); + }, + m(target, anchor) { + insert(target, div4, anchor); + append(div4, div2); + append(div2, div0); + append(div0, t0); + append(div0, t1); + append(div2, t2); + append(div2, div1); + append(div2, t4); + if (if_block) if_block.m(div2, null); + append(div4, t5); + append(div4, div3); + append(div3, input); + /*input_binding*/ ctx[7](input); + set_input_value(input, /*$settings*/ ctx[2][/*periodicity*/ ctx[1]].template); + + if (!mounted) { + dispose = [ + listen(input, "input", /*input_input_handler*/ ctx[8]), + listen(input, "change", /*validateOnBlur*/ ctx[5]), + listen(input, "input", /*clearError*/ ctx[6]) + ]; + + mounted = true; + } + }, + p(ctx, [dirty]) { + if (dirty & /*periodicity*/ 2 && t0_value !== (t0_value = capitalize(/*periodicity*/ ctx[1]) + "")) set_data(t0, t0_value); + + if (/*error*/ ctx[3]) { + if (if_block) { + if_block.p(ctx, dirty); + } else { + if_block = create_if_block$2(ctx); + if_block.c(); + if_block.m(div2, null); + } + } else if (if_block) { + if_block.d(1); + if_block = null; + } + + if (dirty & /*$settings, periodicity*/ 6 && input.value !== /*$settings*/ ctx[2][/*periodicity*/ ctx[1]].template) { + set_input_value(input, /*$settings*/ ctx[2][/*periodicity*/ ctx[1]].template); + } + + if (dirty & /*error*/ 8) { + toggle_class(input, "has-error", !!/*error*/ ctx[3]); + } + }, + i: noop, + o: noop, + d(detaching) { + if (detaching) detach(div4); + if (if_block) if_block.d(); + /*input_binding*/ ctx[7](null); + mounted = false; + run_all(dispose); + } + }; +} + +function instance$2($$self, $$props, $$invalidate) { + let $settings, + $$unsubscribe_settings = noop, + $$subscribe_settings = () => ($$unsubscribe_settings(), $$unsubscribe_settings = subscribe(settings, $$value => $$invalidate(2, $settings = $$value)), settings); + + $$self.$$.on_destroy.push(() => $$unsubscribe_settings()); + + + let { settings } = $$props; + $$subscribe_settings(); + let { periodicity } = $$props; + let error; + let inputEl; + + function validateOnBlur() { + $$invalidate(3, error = validateTemplate(inputEl.value)); + } + + function clearError() { + $$invalidate(3, error = ""); + } + + onMount(() => { + $$invalidate(3, error = validateTemplate(inputEl.value)); + new FileSuggest(window.app, inputEl); + }); + + function input_binding($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + inputEl = $$value; + $$invalidate(4, inputEl); + }); + } + + function input_input_handler() { + $settings[periodicity].template = this.value; + settings.set($settings); + $$invalidate(1, periodicity); + } + + $$self.$$set = $$props => { + if ("settings" in $$props) $$subscribe_settings($$invalidate(0, settings = $$props.settings)); + if ("periodicity" in $$props) $$invalidate(1, periodicity = $$props.periodicity); + }; + + $$self.$$.update = () => { + if ($$self.$$.dirty & /*$settings, periodicity*/ 6) { + $settings[periodicity].template || ""; + } + }; + + return [ + settings, + periodicity, + $settings, + error, + inputEl, + validateOnBlur, + clearError, + input_binding, + input_input_handler + ]; +} + +class NoteTemplateSetting extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$2, create_fragment$2, safe_not_equal, { settings: 0, periodicity: 1 }); + } +} + +/* src/settings/NoteFolderSetting.svelte generated by Svelte v3.35.0 */ + +function create_if_block$1(ctx) { + let div; + let t; + + return { + c() { + div = element("div"); + t = text(/*error*/ ctx[4]); + attr(div, "class", "has-error"); + }, + m(target, anchor) { + insert(target, div, anchor); + append(div, t); + }, + p(ctx, dirty) { + if (dirty & /*error*/ 16) set_data(t, /*error*/ ctx[4]); + }, + d(detaching) { + if (detaching) detach(div); + } + }; +} + +function create_fragment$1(ctx) { + let div4; + let div2; + let div0; + let t1; + let div1; + let t2; + let t3; + let t4; + let t5; + let t6; + let div3; + let input; + let mounted; + let dispose; + let if_block = /*error*/ ctx[4] && create_if_block$1(ctx); + + return { + c() { + div4 = element("div"); + div2 = element("div"); + div0 = element("div"); + div0.textContent = "Note Folder"; + t1 = space(); + div1 = element("div"); + t2 = text("New "); + t3 = text(/*periodicity*/ ctx[1]); + t4 = text(" notes will be placed here"); + t5 = space(); + if (if_block) if_block.c(); + t6 = space(); + div3 = element("div"); + input = element("input"); + attr(div0, "class", "setting-item-name"); + attr(div1, "class", "setting-item-description"); + attr(div2, "class", "setting-item-info"); + attr(input, "type", "text"); + attr(input, "spellcheck", false); + attr(input, "placeholder", "Example: folder 1/folder 2"); + toggle_class(input, "has-error", !!/*error*/ ctx[4]); + attr(div3, "class", "setting-item-control"); + attr(div4, "class", "setting-item"); + }, + m(target, anchor) { + insert(target, div4, anchor); + append(div4, div2); + append(div2, div0); + append(div2, t1); + append(div2, div1); + append(div1, t2); + append(div1, t3); + append(div1, t4); + append(div2, t5); + if (if_block) if_block.m(div2, null); + append(div4, t6); + append(div4, div3); + append(div3, input); + set_input_value(input, /*$settings*/ ctx[2][/*periodicity*/ ctx[1]].folder); + /*input_binding*/ ctx[8](input); + + if (!mounted) { + dispose = [ + listen(input, "input", /*input_input_handler*/ ctx[7]), + listen(input, "change", /*onChange*/ ctx[5]), + listen(input, "input", /*clearError*/ ctx[6]) + ]; + + mounted = true; + } + }, + p(ctx, [dirty]) { + if (dirty & /*periodicity*/ 2) set_data(t3, /*periodicity*/ ctx[1]); + + if (/*error*/ ctx[4]) { + if (if_block) { + if_block.p(ctx, dirty); + } else { + if_block = create_if_block$1(ctx); + if_block.c(); + if_block.m(div2, null); + } + } else if (if_block) { + if_block.d(1); + if_block = null; + } + + if (dirty & /*$settings, periodicity*/ 6 && input.value !== /*$settings*/ ctx[2][/*periodicity*/ ctx[1]].folder) { + set_input_value(input, /*$settings*/ ctx[2][/*periodicity*/ ctx[1]].folder); + } + + if (dirty & /*error*/ 16) { + toggle_class(input, "has-error", !!/*error*/ ctx[4]); + } + }, + i: noop, + o: noop, + d(detaching) { + if (detaching) detach(div4); + if (if_block) if_block.d(); + /*input_binding*/ ctx[8](null); + mounted = false; + run_all(dispose); + } + }; +} + +function instance$1($$self, $$props, $$invalidate) { + let $settings, + $$unsubscribe_settings = noop, + $$subscribe_settings = () => ($$unsubscribe_settings(), $$unsubscribe_settings = subscribe(settings, $$value => $$invalidate(2, $settings = $$value)), settings); + + $$self.$$.on_destroy.push(() => $$unsubscribe_settings()); + + + let { settings } = $$props; + $$subscribe_settings(); + let { periodicity } = $$props; + let inputEl; + let error; + + function onChange() { + $$invalidate(4, error = validateFolder(inputEl.value)); + } + + function clearError() { + $$invalidate(4, error = ""); + } + + onMount(() => { + $$invalidate(4, error = validateFolder(inputEl.value)); + new FolderSuggest(window.app, inputEl); + }); + + function input_input_handler() { + $settings[periodicity].folder = this.value; + settings.set($settings); + $$invalidate(1, periodicity); + } + + function input_binding($$value) { + binding_callbacks[$$value ? "unshift" : "push"](() => { + inputEl = $$value; + $$invalidate(3, inputEl); + }); + } + + $$self.$$set = $$props => { + if ("settings" in $$props) $$subscribe_settings($$invalidate(0, settings = $$props.settings)); + if ("periodicity" in $$props) $$invalidate(1, periodicity = $$props.periodicity); + }; + + $$self.$$.update = () => { + if ($$self.$$.dirty & /*$settings, periodicity*/ 6) { + $settings[periodicity].folder || ""; + } + }; + + return [ + settings, + periodicity, + $settings, + inputEl, + error, + onChange, + clearError, + input_input_handler, + input_binding + ]; +} + +class NoteFolderSetting extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$1, create_fragment$1, safe_not_equal, { settings: 0, periodicity: 1 }); + } +} + +/* src/settings/SettingsTab.svelte generated by Svelte v3.35.0 */ + +function get_each_context(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[9] = list[i]; + return child_ctx; +} + +// (33:0) {#if $settingsStore.showGettingStartedBanner} +function create_if_block_1(ctx) { + let gettingstartedbanner; + let current; + + gettingstartedbanner = new GettingStartedBanner({ + props: { + migrateDailyNoteSettings: /*migrateDailyNoteSettings*/ ctx[2], + settings: /*settingsStore*/ ctx[1], + handleTeardown: /*func*/ ctx[6] + } + }); + + return { + c() { + create_component(gettingstartedbanner.$$.fragment); + }, + m(target, anchor) { + mount_component(gettingstartedbanner, target, anchor); + current = true; + }, + p(ctx, dirty) { + const gettingstartedbanner_changes = {}; + if (dirty & /*$settingsStore*/ 1) gettingstartedbanner_changes.handleTeardown = /*func*/ ctx[6]; + gettingstartedbanner.$set(gettingstartedbanner_changes); + }, + i(local) { + if (current) return; + transition_in(gettingstartedbanner.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(gettingstartedbanner.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(gettingstartedbanner, detaching); + } + }; +} + +// (62:2) {#if $settingsStore[periodicity].enabled} +function create_if_block(ctx) { + let div; + let noteformatsetting; + let t0; + let notetemplatesetting; + let t1; + let notefoldersetting; + let t2; + let div_intro; + let div_outro; + let current; + + noteformatsetting = new NoteFormatSetting({ + props: { + periodicity: /*periodicity*/ ctx[9], + settings: /*settingsStore*/ ctx[1] + } + }); + + notetemplatesetting = new NoteTemplateSetting({ + props: { + periodicity: /*periodicity*/ ctx[9], + settings: /*settingsStore*/ ctx[1] + } + }); + + notefoldersetting = new NoteFolderSetting({ + props: { + periodicity: /*periodicity*/ ctx[9], + settings: /*settingsStore*/ ctx[1] + } + }); + + return { + c() { + div = element("div"); + create_component(noteformatsetting.$$.fragment); + t0 = space(); + create_component(notetemplatesetting.$$.fragment); + t1 = space(); + create_component(notefoldersetting.$$.fragment); + t2 = space(); + }, + m(target, anchor) { + insert(target, div, anchor); + mount_component(noteformatsetting, div, null); + append(div, t0); + mount_component(notetemplatesetting, div, null); + append(div, t1); + mount_component(notefoldersetting, div, null); + append(div, t2); + current = true; + }, + p: noop, + i(local) { + if (current) return; + transition_in(noteformatsetting.$$.fragment, local); + transition_in(notetemplatesetting.$$.fragment, local); + transition_in(notefoldersetting.$$.fragment, local); + + add_render_callback(() => { + if (div_outro) div_outro.end(1); + if (!div_intro) div_intro = create_in_transition(div, slide, {}); + div_intro.start(); + }); + + current = true; + }, + o(local) { + transition_out(noteformatsetting.$$.fragment, local); + transition_out(notetemplatesetting.$$.fragment, local); + transition_out(notefoldersetting.$$.fragment, local); + if (div_intro) div_intro.invalidate(); + div_outro = create_out_transition(div, slide, {}); + current = false; + }, + d(detaching) { + if (detaching) detach(div); + destroy_component(noteformatsetting); + destroy_component(notetemplatesetting); + destroy_component(notefoldersetting); + if (detaching && div_outro) div_outro.end(); + } + }; +} + +// (42:0) {#each periodicities as periodicity} +function create_each_block(ctx) { + let div4; + let div1; + let div0; + let h3; + let t0_value = capitalize(/*periodicity*/ ctx[9]) + ""; + let t0; + let t1; + let t2; + let div3; + let div2; + let t3; + let if_block_anchor; + let current; + let mounted; + let dispose; + + function click_handler() { + return /*click_handler*/ ctx[7](/*periodicity*/ ctx[9]); + } + + let if_block = /*$settingsStore*/ ctx[0][/*periodicity*/ ctx[9]].enabled && create_if_block(ctx); + + return { + c() { + div4 = element("div"); + div1 = element("div"); + div0 = element("div"); + h3 = element("h3"); + t0 = text(t0_value); + t1 = text(" Notes"); + t2 = space(); + div3 = element("div"); + div2 = element("div"); + t3 = space(); + if (if_block) if_block.c(); + if_block_anchor = empty(); + attr(div0, "class", "setting-item-name"); + attr(div1, "class", "setting-item-info"); + attr(div2, "class", "checkbox-container"); + toggle_class(div2, "is-enabled", /*$settingsStore*/ ctx[0][/*periodicity*/ ctx[9]].enabled); + attr(div3, "class", "setting-item-control"); + attr(div4, "class", "setting-item setting-item-heading"); + }, + m(target, anchor) { + insert(target, div4, anchor); + append(div4, div1); + append(div1, div0); + append(div0, h3); + append(h3, t0); + append(h3, t1); + append(div4, t2); + append(div4, div3); + append(div3, div2); + insert(target, t3, anchor); + if (if_block) if_block.m(target, anchor); + insert(target, if_block_anchor, anchor); + current = true; + + if (!mounted) { + dispose = listen(div2, "click", click_handler); + mounted = true; + } + }, + p(new_ctx, dirty) { + ctx = new_ctx; + + if (dirty & /*$settingsStore, periodicities*/ 9) { + toggle_class(div2, "is-enabled", /*$settingsStore*/ ctx[0][/*periodicity*/ ctx[9]].enabled); + } + + if (/*$settingsStore*/ ctx[0][/*periodicity*/ ctx[9]].enabled) { + if (if_block) { + if_block.p(ctx, dirty); + + if (dirty & /*$settingsStore*/ 1) { + transition_in(if_block, 1); + } + } else { + if_block = create_if_block(ctx); + if_block.c(); + transition_in(if_block, 1); + if_block.m(if_block_anchor.parentNode, if_block_anchor); + } + } else if (if_block) { + group_outros(); + + transition_out(if_block, 1, 1, () => { + if_block = null; + }); + + check_outros(); + } + }, + i(local) { + if (current) return; + transition_in(if_block); + current = true; + }, + o(local) { + transition_out(if_block); + current = false; + }, + d(detaching) { + if (detaching) detach(div4); + if (detaching) detach(t3); + if (if_block) if_block.d(detaching); + if (detaching) detach(if_block_anchor); + mounted = false; + dispose(); + } + }; +} + +function create_fragment(ctx) { + let t; + let each_1_anchor; + let current; + let if_block = /*$settingsStore*/ ctx[0].showGettingStartedBanner && create_if_block_1(ctx); + let each_value = /*periodicities*/ 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; + }); + + return { + c() { + if (if_block) if_block.c(); + t = space(); + + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + + each_1_anchor = empty(); + }, + m(target, anchor) { + if (if_block) if_block.m(target, anchor); + insert(target, t, 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 (/*$settingsStore*/ ctx[0].showGettingStartedBanner) { + if (if_block) { + if_block.p(ctx, dirty); + + if (dirty & /*$settingsStore*/ 1) { + transition_in(if_block, 1); + } + } else { + if_block = create_if_block_1(ctx); + if_block.c(); + transition_in(if_block, 1); + if_block.m(t.parentNode, t); + } + } else if (if_block) { + group_outros(); + + transition_out(if_block, 1, 1, () => { + if_block = null; + }); + + check_outros(); + } + + if (dirty & /*periodicities, settingsStore, $settingsStore, capitalize*/ 11) { + each_value = /*periodicities*/ 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(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; + transition_in(if_block); + + for (let i = 0; i < each_value.length; i += 1) { + transition_in(each_blocks[i]); + } + + current = true; + }, + o(local) { + transition_out(if_block); + 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(t); + destroy_each(each_blocks, detaching); + if (detaching) detach(each_1_anchor); + } + }; +} + +function instance($$self, $$props, $$invalidate) { + let $settingsStore; + + let { settings } = $$props; + let { onUpdateSettings } = $$props; + let settingsStore = writable(settings); + component_subscribe($$self, settingsStore, value => $$invalidate(0, $settingsStore = value)); + const unsubscribeFromSettings = settingsStore.subscribe(onUpdateSettings); + + function migrateDailyNoteSettings() { + const dailyNoteSettings = getLegacyDailyNoteSettings(); + + settingsStore.update(old => Object.assign(Object.assign({}, old), { + daily: Object.assign(Object.assign({}, dailyNoteSettings), { enabled: true }), + hasMigratedDailyNoteSettings: true + })); + } + + const periodicities = ["daily", "weekly", "monthly", "quarterly", "yearly"]; + + onDestroy(() => { + unsubscribeFromSettings(); + }); + + const func = () => { + set_store_value(settingsStore, $settingsStore.showGettingStartedBanner = false, $settingsStore); + }; + + const click_handler = periodicity => { + set_store_value(settingsStore, $settingsStore[periodicity].enabled = !$settingsStore[periodicity].enabled, $settingsStore); + }; + + $$self.$$set = $$props => { + if ("settings" in $$props) $$invalidate(4, settings = $$props.settings); + if ("onUpdateSettings" in $$props) $$invalidate(5, onUpdateSettings = $$props.onUpdateSettings); + }; + + return [ + $settingsStore, + settingsStore, + migrateDailyNoteSettings, + periodicities, + settings, + onUpdateSettings, + func, + click_handler + ]; +} + +class SettingsTab extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance, create_fragment, safe_not_equal, { settings: 4, onUpdateSettings: 5 }); + } +} + +const DEFAULT_SETTINGS = Object.freeze({ + format: "", + template: "", + folder: "", +}); +class PeriodicNotesSettingsTab extends obsidian.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + this.plugin = plugin; + } + display() { + this.containerEl.empty(); + this.view = new SettingsTab({ + target: this.containerEl, + props: { + settings: this.plugin.settings, + onUpdateSettings: this.plugin.updateSettings, + }, + }); + } +} + +class PeriodicNotesPlugin extends obsidian.Plugin { + async onload() { + this.ribbonEl = null; + this.updateSettings = this.updateSettings.bind(this); + await this.loadSettings(); + this.addSettingTab(new PeriodicNotesSettingsTab(this.app, this)); + this.app.workspace.onLayoutReady(this.onLayoutReady.bind(this)); + obsidian.addIcon("calendar-day", calendarDayIcon); + obsidian.addIcon("calendar-week", calendarWeekIcon); + obsidian.addIcon("calendar-month", calendarMonthIcon); + obsidian.addIcon("calendar-quarter", calendarQuarterIcon); + obsidian.addIcon("calendar-year", calendarYearIcon); + } + onLayoutReady() { + // If the user has Calendar Weekly Notes settings, migrate them automatically, + // since the functionality will be deprecated. + if (this.isInitialLoad && hasLegacyWeeklyNoteSettings()) { + this.migrateWeeklySettings(); + this.settings.weekly.enabled = true; + } + this.configureRibbonIcons(); + this.configureCommands(); + } + migrateWeeklySettings() { + const calendarSettings = getLegacyWeeklyNoteSettings(); + this.updateSettings(Object.assign(Object.assign({}, this.settings), { + weekly: Object.assign(Object.assign({}, calendarSettings), { enabled: true }), + hasMigratedWeeklyNoteSettings: true, + })); + } + configureRibbonIcons() { + var _a; + (_a = this.ribbonEl) === null || _a === void 0 ? void 0 : _a.detach(); + const configuredPeriodicities = [ + "daily", + "weekly", + "monthly", + "quarterly", + "yearly", + ].filter((periodicity) => this.settings[periodicity].enabled); + if (configuredPeriodicities.length) { + const periodicity = configuredPeriodicities[0]; + const config = periodConfigs[periodicity]; + this.ribbonEl = this.addRibbonIcon(`calendar-${config.unitOfTime}`, `Open ${config.relativeUnit}`, (event) => openPeriodicNote(periodicity, window.moment(), isMetaPressed(event))); + this.ribbonEl.addEventListener("contextmenu", (ev) => { + showFileMenu(this.app, this.settings, { + x: ev.pageX, + y: ev.pageY, + }); + }); + } + } + configureCommands() { + // Remove disabled commands + ["daily", "weekly", "monthly", "quarterly", "yearly"] + .filter((periodicity) => !this.settings[periodicity].enabled) + .forEach((periodicity) => { + getCommands(periodicity).forEach((command) => + // eslint-disable-next-line @typescript-eslint/no-explicit-any + this.app.commands.removeCommand(`periodic-notes:${command.id}`)); + }); + // register enabled commands + ["daily", "weekly", "monthly", "quarterly", "yearly"] + .filter((periodicity) => this.settings[periodicity].enabled) + .forEach((periodicity) => { + getCommands(periodicity).forEach(this.addCommand.bind(this)); + }); + } + async loadSettings() { + const settings = await this.loadData(); + if (!settings) { + this.isInitialLoad = true; + } + this.settings = Object.assign({}, { + showGettingStartedBanner: true, + hasMigratedDailyNoteSettings: false, + hasMigratedWeeklyNoteSettings: false, + daily: Object.assign({}, DEFAULT_SETTINGS), + weekly: Object.assign({}, DEFAULT_SETTINGS), + monthly: Object.assign({}, DEFAULT_SETTINGS), + quarterly: Object.assign({}, DEFAULT_SETTINGS), + yearly: Object.assign({}, DEFAULT_SETTINGS), + }, settings || {}); + } + onSettingsUpdate() { + this.configureCommands(); + this.configureRibbonIcons(); + // Integrations (i.e. Calendar Plugin) can listen for changes to settings + this.app.workspace.trigger(SETTINGS_UPDATED); + } + async updateSettings(val) { + this.settings = val; + await this.saveData(this.settings); + this.onSettingsUpdate(); + } +} + +module.exports = PeriodicNotesPlugin; diff --git a/.obsidian/plugins/periodic-notes/manifest.json b/.obsidian/plugins/periodic-notes/manifest.json new file mode 100644 index 0000000..f34394e --- /dev/null +++ b/.obsidian/plugins/periodic-notes/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "periodic-notes", + "name": "Periodic Notes", + "description": "Create/manage your daily, weekly, and monthly notes", + "version": "0.0.17", + "author": "Liam Cain", + "authorUrl": "https://github.com/liamcain/", + "isDesktopOnly": false, + "minAppVersion": "0.10.11" +} diff --git a/.obsidian/plugins/periodic-notes/styles.css b/.obsidian/plugins/periodic-notes/styles.css new file mode 100644 index 0000000..d388888 --- /dev/null +++ b/.obsidian/plugins/periodic-notes/styles.css @@ -0,0 +1,30 @@ +.periodic-modal { + min-width: 40vw; +} + +.settings-banner { + background-color: var(--background-primary-alt); + border-radius: 8px; + border: 1px solid var(--background-modifier-border); + margin-bottom: 1em; + margin-top: 1em; + padding: 1.5em; + text-align: left; +} + +.settings-banner h3 { + margin-top: 0; +} + +.settings-banner h4 { + margin-bottom: 0.25em; +} + +.has-error { + color: var(--text-error); +} + +input.has-error { + color: var(--text-error); + border-color: var(--text-error); +} diff --git a/.obsidian/plugins/table-editor-obsidian/data.json b/.obsidian/plugins/table-editor-obsidian/data.json index 9009465..6484fc0 100644 --- a/.obsidian/plugins/table-editor-obsidian/data.json +++ b/.obsidian/plugins/table-editor-obsidian/data.json @@ -1,6 +1,6 @@ { "formatType": "normal", - "showRibbonIcon": true, + "showRibbonIcon": false, "bindEnter": true, "bindTab": true } \ No newline at end of file diff --git a/.obsidian/workspace b/.obsidian/workspace index 22a99ca..05f7f28 100644 --- a/.obsidian/workspace +++ b/.obsidian/workspace @@ -9,7 +9,7 @@ "state": { "type": "markdown", "state": { - "file": "Templates/t_DailyNote.md", + "file": "Periodische Notizen/Täglich/06.07.2022.md", "mode": "source", "source": false } @@ -62,7 +62,7 @@ "state": { "type": "backlink", "state": { - "file": "Templates/t_DailyNote.md", + "file": "Periodische Notizen/Täglich/06.07.2022.md", "collapseAll": false, "extraContext": false, "sortOrder": "alphabetical", @@ -79,7 +79,7 @@ "state": { "type": "outgoing-link", "state": { - "file": "Templates/t_DailyNote.md", + "file": "Periodische Notizen/Täglich/06.07.2022.md", "linksCollapsed": false, "unlinkedCollapsed": true } @@ -117,7 +117,7 @@ "state": { "type": "outline", "state": { - "file": "Templates/t_DailyNote.md" + "file": "Periodische Notizen/Täglich/06.07.2022.md" } } }, @@ -130,7 +130,7 @@ } } ], - "currentTab": 2 + "currentTab": 5 }, { "id": "7804475bf051d7e7", @@ -161,15 +161,15 @@ }, "active": "624fc6cedfec68e9", "lastOpenFiles": [ + "Periodische Notizen/Täglich/06.07.2022.md", + "Periodische Notizen/Wöchentlich/KW27-2022.md", + "Periodische Notizen/Täglich/04.07.2022.md", "Templates/t_DailyNote.md", "Templates/t_NewProblem.md", "Firmen/Steinemann Technology/Tickets/Monica Garcia/Penta Belege termin definieren.md", - "Daily/30.06.2022.md", - "Daily/01.07.2022.md", + "Periodische Notizen/Täglich/30.06.2022.md", + "Periodische Notizen/Täglich/01.07.2022.md", "Firmen/Steinemann Technology/Tickets/Stefanie Weilenmann/Installation von Monitor.md", - "Daily/04.07.2022.md", - "Daily/28.06.2022.md", - "Daily/27.06.2022.md", - "Firmen/Steinemann Technology/tickets/Monica Garcia/Erstellung der Penta Belege.md" + "Periodische Notizen/Täglich/28.06.2022.md" ] } \ No newline at end of file diff --git a/Daily/01.07.2022.md b/Periodische Notizen/Täglich/01.07.2022.md similarity index 100% rename from Daily/01.07.2022.md rename to Periodische Notizen/Täglich/01.07.2022.md diff --git a/Daily/04.07.2022.md b/Periodische Notizen/Täglich/04.07.2022.md similarity index 72% rename from Daily/04.07.2022.md rename to Periodische Notizen/Täglich/04.07.2022.md index 03fa639..8ced825 100644 --- a/Daily/04.07.2022.md +++ b/Periodische Notizen/Täglich/04.07.2022.md @@ -2,17 +2,20 @@ [[01.07.2022|Vorherige Notiz]] # Work ## Generell +### Eingabe aller Badges der Fehlenden User +> Ugh + +--- + ### Stundennotation > Die Übernahme der Stunden hat noch gar nicht funktioniert. Da ich befürchte, alle Zeiten manuell nachtragen zu müssen, werde ich das hier nun niederschreiben - [ ] Eintritt: 07:09 -- [ ] Pause/Mittag: -- [ ] Eintritt: +- [ ] Pause/Mittag: 11:47 +- [ ] Eintritt: 12:17 - [ ] Austritt: -1. Lösungsansatz -2. Lösungsansatz #lösung +## Tags ---- # Privat - +## Tags \ No newline at end of file diff --git a/Daily/05.07.2022.md b/Periodische Notizen/Täglich/05.07.2022.md similarity index 100% rename from Daily/05.07.2022.md rename to Periodische Notizen/Täglich/05.07.2022.md diff --git a/Periodische Notizen/Täglich/06.07.2022.md b/Periodische Notizen/Täglich/06.07.2022.md new file mode 100644 index 0000000..b7ebd75 --- /dev/null +++ b/Periodische Notizen/Täglich/06.07.2022.md @@ -0,0 +1,27 @@ +#daily +[[PREVIOUS DAY|Vorherige Notiz]] + +# Work +## User +### Problem +> + +- [ ] +- [ ] + +1. Lösungsansatz +2. Lösungsansatz #lösung + +### Tags + +--- +# Privat +## Tätigkeit +## Mood Tracker +Heute gieng es mir: +- [ ] Super! +- [ ] Okay +- [ ] Gut +- [ +### Tags +--- \ No newline at end of file diff --git a/Daily/27.06.2022.md b/Periodische Notizen/Täglich/27.06.2022.md similarity index 100% rename from Daily/27.06.2022.md rename to Periodische Notizen/Täglich/27.06.2022.md diff --git a/Daily/28.06.2022.md b/Periodische Notizen/Täglich/28.06.2022.md similarity index 100% rename from Daily/28.06.2022.md rename to Periodische Notizen/Täglich/28.06.2022.md diff --git a/Daily/30.06.2022.md b/Periodische Notizen/Täglich/30.06.2022.md similarity index 100% rename from Daily/30.06.2022.md rename to Periodische Notizen/Täglich/30.06.2022.md diff --git a/Periodische Notizen/Wöchentlich/KW27-2022.md b/Periodische Notizen/Wöchentlich/KW27-2022.md new file mode 100644 index 0000000..356ebaa --- /dev/null +++ b/Periodische Notizen/Wöchentlich/KW27-2022.md @@ -0,0 +1,2 @@ +[[04.07.2022]] +[[05.07.2022]] \ No newline at end of file diff --git a/Templates/t_DailyNote.md b/Templates/t_DailyNote.md index d9b49d0..b7ebd75 100644 --- a/Templates/t_DailyNote.md +++ b/Templates/t_DailyNote.md @@ -17,5 +17,11 @@ --- # Privat ## Tätigkeit +## Mood Tracker +Heute gieng es mir: +- [ ] Super! +- [ ] Okay +- [ ] Gut +- [ ### Tags --- \ No newline at end of file