feat: support short-form date aliases

Add configurable date aliases for natural language date inputs.

Includes normalization in parsing/VDATE, settings UI for aliases, and expandable alias hints in date prompts.

Author: chhoumann

docs/docs/Advanced/onePageInputs.md

@@ -23,6 +23,7 @@ This feature is currently in Beta.
 
 ## Date UX
 - Date fields support natural language (e.g., “today”, “next friday”).
+- Short aliases like `t` (today), `tm` (tomorrow), and `yd` (yesterday) are supported and configurable in settings.
 - The modal shows a formatted preview and stores a normalized `@date:ISO` internally.
 
 ## FIELD UX

docs/docs/FormatSyntax.md

@@ -6,8 +6,8 @@ title: Format syntax
 | ------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `{{DATE}}`                                 | Outputs the current date in `YYYY-MM-DD` format. You could write `{{DATE+3}}` to offset the date with 3 days. You can use `+-3` to offset with `-3` days.                                                                                                                                                                                                                                    |
 | `{{DATE:<DATEFORMAT>}}`                    | Replace `<DATEFORMAT>` with a [Moment.js date format](https://momentjs.com/docs/#/displaying/format/). You could write `{{DATE<DATEFORMAT>+3}}` to offset the date with 3 days.                                                                                                                                                                              |
-| `{{VDATE:<variable name>, <date format>}}` | You'll get prompted to enter a date and it'll be parsed to the given date format. You could write 'today' or 'in two weeks' and it'll give you the date for that. Works like variables, so you can use the date in multiple places with different formats - enter once, format many times! Example: `{{VDATE:date,YYYY}}/{{VDATE:date,MM}}/{{VDATE:date,DD}}` |
-| `{{VDATE:<variable name>, <date format>\|<default>}}` | Same as above, but with a default value. If you leave the prompt empty, the default value will be used instead. Example: `{{VDATE:date,YYYY-MM-DD\|today}}` will use "today" if no input is provided. Default values can be any natural language date like "tomorrow", "next monday", "+7 days", etc. **Note:** If your date format contains pipe characters (`|`), you'll need to escape them as `\|` or use square brackets like `[|]` to avoid conflicts with the default value separator. |
+| `{{VDATE:<variable name>, <date format>}}` | You'll get prompted to enter a date and it'll be parsed to the given date format. You could write 'today' or 'in two weeks' and it'll give you the date for that. Short aliases like `t` (today), `tm` (tomorrow), and `yd` (yesterday) are also supported and configurable in settings. Works like variables, so you can use the date in multiple places with different formats - enter once, format many times! Example: `{{VDATE:date,YYYY}}/{{VDATE:date,MM}}/{{VDATE:date,DD}}` |
+| `{{VDATE:<variable name>, <date format>\|<default>}}` | Same as above, but with a default value. If you leave the prompt empty, the default value will be used instead. Example: `{{VDATE:date,YYYY-MM-DD\|today}}` will use "today" if no input is provided. Default values can be any natural language date like "tomorrow", "next monday", "+7 days", etc. Short aliases like `t`, `tm`, and `yd` work here too. **Note:** If your date format contains pipe characters (`|`), you'll need to escape them as `\|` or use square brackets like `[|]` to avoid conflicts with the default value separator. |
 | `{{VALUE}}` or `{{NAME}}`                  | Interchangeable. Represents the value given in an input prompt. If text is selected in the current editor, it will be used as the value. When using the QuickAdd API, this can be passed programmatically using the reserved variable name 'value'.                                                                                                                                             |
 | `{{VALUE:<variable name>}}`                  | You can now use variable names in values. They'll get saved and inserted just like values, but the difference is that you can have as many of them as you want. Use comma separation to get a suggester rather than a prompt.                                                       |
 | `{{VALUE:<variable name>\|<default>}}`        | Same as above, but with a default value. For single-value prompts (e.g., `{{VALUE:name\|Anonymous}}`), the default is pre-populated in the input field - press Enter to accept or clear/edit it. For multi-value suggesters without `\|custom`, you must select one of the provided options (no default applies).                                                                                  |

docs/docs/QuickAddAPI.md

@@ -44,7 +44,7 @@ Opens a one-page modal to collect multiple inputs in one go. Values already pres
 - `text`: Single-line text input
 - `textarea`: Multi-line text input
 - `dropdown`: Fixed dropdown menu (no search, must select from list)
-- `date`: Date input with natural language support
+- `date`: Date input with natural language support (short aliases like `t`, `tm`, `yd` are supported and configurable in settings)
 - `field-suggest`: Vault field suggestions (uses `{{FIELD:...}}` syntax)
 - `suggester`: **NEW** - Searchable autocomplete with custom options (allows custom input)
   - Supports multi-select mode via `suggesterConfig.multiSelect: true` for comma-separated selections

src/formatters/formatter.ts

@@ -24,6 +24,8 @@ import { getDate } from "../utilityObsidian";
 import type { IDateParser } from "../parsers/IDateParser";
 import { log } from "../logger/logManager";
 import { TemplatePropertyCollector } from "../utils/TemplatePropertyCollector";
+import { settingsStore } from "../settingsStore";
+import { normalizeDateInput } from "../utils/dateAliases";
 
 export type LinkToCurrentFileBehavior = "required" | "optional";
 
@@ -444,7 +446,9 @@ export abstract class Formatter {
 
 					if (!this.dateParser) throw new Error("Date parser is not available");
 
-					const parseAttempt = this.dateParser.parseDate(dateInput);
+					const aliasMap = settingsStore.getState().dateAliases;
+					const normalizedInput = normalizeDateInput(dateInput, aliasMap);
+					const parseAttempt = this.dateParser.parseDate(normalizedInput);
 
 					if (parseAttempt) {
 						// Store the ISO string with a special prefix

src/gui/VDateInputPrompt/VDateInputPrompt.ts

@@ -2,6 +2,11 @@ import type { App, Debouncer } from "obsidian";
 import { TextComponent, debounce } from "obsidian";
 import GenericInputPrompt from "../GenericInputPrompt/GenericInputPrompt";
 import { parseNaturalLanguageDate } from "../../utils/dateParser";
+import { settingsStore } from "../../settingsStore";
+import {
+	formatDateAliasInline,
+	getOrderedDateAliases,
+} from "../../utils/dateAliases";
 
 export default class VDateInputPrompt extends GenericInputPrompt {
 	private previewEl: HTMLElement;
@@ -106,6 +111,33 @@ export default class VDateInputPrompt extends GenericInputPrompt {
 		this.previewEl.style.fontFamily = "var(--font-monospace)";
 		this.previewEl.textContent = VDateInputPrompt.PREVIEW_PLACEHOLDER;
 		this.previewEl.style.color = "var(--text-normal)";
+
+		const aliasEntries = getOrderedDateAliases(
+			settingsStore.getState().dateAliases,
+		);
+		if (aliasEntries.length > 0) {
+			const aliasDetails = previewContainer.createEl("details", {
+				cls: "vdate-alias-details",
+			});
+			aliasDetails.style.marginTop = "0.25rem";
+
+			const aliasSummary = aliasDetails.createEl("summary", {
+				text: `Aliases (${aliasEntries.length})`,
+			});
+			aliasSummary.style.fontSize = "0.85em";
+			aliasSummary.style.color = "var(--text-muted)";
+
+			const aliasList = aliasDetails.createEl("div", {
+				cls: "vdate-alias-list",
+			});
+			aliasList.textContent = formatDateAliasInline(
+				settingsStore.getState().dateAliases,
+			);
+			aliasList.style.marginTop = "0.25rem";
+			aliasList.style.fontSize = "0.85em";
+			aliasList.style.color = "var(--text-muted)";
+			aliasList.style.fontFamily = "var(--font-monospace)";
+		}
 	}
 
 	private updatePreview() {

src/preflight/OnePageInputModal.ts

@@ -10,6 +10,11 @@ import {
 import { FieldValueInputSuggest } from "src/gui/suggesters/FieldValueInputSuggest";
 import { SuggesterInputSuggest } from "src/gui/suggesters/SuggesterInputSuggest";
 import { formatISODate, parseNaturalLanguageDate } from "src/utils/dateParser";
+import {
+	formatDateAliasInline,
+	getOrderedDateAliases,
+} from "src/utils/dateAliases";
+import { settingsStore } from "src/settingsStore";
 import type { FieldRequirement } from "./RequirementCollector";
 
 type PreviewComputer = (
@@ -179,6 +184,28 @@ export class OnePageInputModal extends Modal {
 				preview.style.marginTop = "0.25rem";
 				preview.style.fontSize = "0.9em";
 				preview.style.fontFamily = "var(--font-monospace)";
+				const aliasEntries = getOrderedDateAliases(
+					settingsStore.getState().dateAliases,
+				);
+				if (aliasEntries.length > 0) {
+					const aliasDetails = container.createEl("details");
+					aliasDetails.style.marginTop = "0.25rem";
+
+					const aliasSummary = aliasDetails.createEl("summary", {
+						text: `Aliases (${aliasEntries.length})`,
+					});
+					aliasSummary.style.fontSize = "0.85em";
+					aliasSummary.style.color = "var(--text-muted)";
+
+					const aliasList = aliasDetails.createEl("div");
+					aliasList.textContent = formatDateAliasInline(
+						settingsStore.getState().dateAliases,
+					);
+					aliasList.style.marginTop = "0.25rem";
+					aliasList.style.fontSize = "0.85em";
+					aliasList.style.color = "var(--text-muted)";
+					aliasList.style.fontFamily = "var(--font-monospace)";
+				}
 				const updatePreview = (val: string) => {
 					const inputVal = (val ?? "").trim();
 					if (!inputVal && req.defaultValue) {

src/quickAddSettingsTab.ts

@@ -1,4 +1,5 @@
 import type { App, TAbstractFile } from "obsidian";
+import type { TextAreaComponent } from "obsidian";
 import {
 	BaseComponent,
 	PluginSettingTab,
@@ -16,6 +17,11 @@ import { ExportPackageModal } from "./gui/PackageManager/ExportPackageModal";
 import { ImportPackageModal } from "./gui/PackageManager/ImportPackageModal";
 import { InputPromptDraftStore } from "./utils/InputPromptDraftStore";
 import type { QuickAddSettings } from "./settings";
+import {
+	DEFAULT_DATE_ALIASES,
+	formatDateAliasLines,
+	parseDateAliasLines,
+} from "./utils/dateAliases";
 
 type SettingGroupLike = {
 	addSetting(cb: (setting: Setting) => void): void;
@@ -52,6 +58,7 @@ export class QuickAddSettingsTab extends PluginSettingTab {
 		this.addUseMultiLineInputPromptSetting(inputGroup);
 		this.addPersistInputPromptDraftsSetting(inputGroup);
 		this.addOnePageInputSetting(inputGroup);
+		this.addDateAliasesSetting(inputGroup);
 
 		const templatesGroup = this.createSettingGroup("Templates & Properties");
 		this.addTemplateFolderPathSetting(templatesGroup);
@@ -412,6 +419,61 @@ export class QuickAddSettingsTab extends PluginSettingTab {
 		});
 	}
 
+	private addDateAliasesSetting(group: SettingGroupLike) {
+		group.addSetting((setting) => {
+			setting.setName("Date aliases");
+			setting.setDesc(
+				"Shortcodes for natural language date parsing. " +
+					"One per line: alias = phrase. Example: tm = tomorrow.",
+			);
+			setting.settingEl.style.alignItems = "flex-start";
+			setting.controlEl.style.display = "flex";
+			setting.controlEl.style.flexWrap = "wrap";
+			setting.controlEl.style.gap = "0.5rem";
+			setting.controlEl.style.alignItems = "flex-start";
+			setting.controlEl.style.flex = "1 1 320px";
+			setting.controlEl.style.minWidth = "240px";
+
+			let textAreaRef: TextAreaComponent | null = null;
+
+			setting.addTextArea((textArea) => {
+				textAreaRef = textArea;
+				textArea
+					.setPlaceholder("t = today\ntm = tomorrow\nyd = yesterday")
+					.setValue(
+						formatDateAliasLines(settingsStore.getState().dateAliases),
+					)
+					.onChange((value) => {
+						settingsStore.setState({
+							dateAliases: parseDateAliasLines(value),
+						});
+					});
+				textArea.inputEl.style.width = "100%";
+				textArea.inputEl.style.minHeight = "6rem";
+				textArea.inputEl.style.flex = "1 1 280px";
+				textArea.inputEl.style.maxWidth = "100%";
+				textArea.inputEl.style.boxSizing = "border-box";
+			});
+
+			setting.addButton((button) => {
+				button
+					.setButtonText("Reset to defaults")
+					.onClick(() => {
+						settingsStore.setState({
+							dateAliases: DEFAULT_DATE_ALIASES,
+						});
+						if (textAreaRef) {
+							textAreaRef.setValue(
+								formatDateAliasLines(DEFAULT_DATE_ALIASES),
+							);
+						}
+					});
+				button.buttonEl.style.alignSelf = "flex-start";
+				button.buttonEl.style.whiteSpace = "nowrap";
+			});
+		});
+	}
+
 	private addDisableOnlineFeaturesSetting(group: SettingGroupLike) {
 		group.addSetting((setting) => {
 			setting

src/settings.ts

@@ -1,6 +1,7 @@
 import type { Model } from "./ai/Provider";
 import { DefaultProviders, type AIProvider } from "./ai/Provider";
 import type IChoice from "./types/choices/IChoice";
+import { DEFAULT_DATE_ALIASES } from "./utils/dateAliases";
 
 export interface QuickAddSettings {
 	choices: IChoice[];
@@ -25,6 +26,7 @@ export interface QuickAddSettings {
 	showCaptureNotification: boolean;
 	showInputCancellationNotification: boolean;
 	enableTemplatePropertyTypes: boolean;
+	dateAliases: Record<string, string>;
 	ai: {
 		defaultModel: Model["name"] | "Ask me";
 		defaultSystemPrompt: string;
@@ -60,6 +62,7 @@ export const DEFAULT_SETTINGS: QuickAddSettings = {
 	showCaptureNotification: true,
 	showInputCancellationNotification: false,
 	enableTemplatePropertyTypes: false,
+	dateAliases: DEFAULT_DATE_ALIASES,
 	ai: {
 		defaultModel: "Ask me",
 		defaultSystemPrompt: `As an AI assistant within Obsidian, your primary goal is to help users manage their ideas and knowledge more effectively. Format your responses using Markdown syntax. Please use the [[Obsidian]] link format. You can write aliases for the links by writing [[Obsidian|the alias after the pipe symbol]]. To use mathematical notation, use LaTeX syntax. LaTeX syntax for larger equations should be on separate lines, surrounded with double dollar signs ($$). You can also inline math expressions by wrapping it in $ symbols. For example, use $$w_{ij}^{\text{new}}:=w_{ij}^{\text{current}}+\eta\cdot\delta_j\cdot x_{ij}$$ on a separate line, but you can write "($\eta$ = learning rate, $\delta_j$ = error term, $x_{ij}$ = input)" inline.`,

src/utils/dateAliases.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from "vitest";
+import {
+	formatDateAliasInline,
+	formatDateAliasLines,
+	getOrderedDateAliases,
+	normalizeDateInput,
+	parseDateAliasLines,
+} from "./dateAliases";
+
+describe("dateAliases", () => {
+	it("normalizes direct aliases", () => {
+		const result = normalizeDateInput("tm", { tm: "tomorrow" });
+		expect(result).toBe("tomorrow");
+	});
+
+	it("normalizes aliases in the first token", () => {
+		const result = normalizeDateInput("tm 5pm", { tm: "tomorrow" });
+		expect(result).toBe("tomorrow 5pm");
+	});
+
+	it("leaves non-alias input untouched", () => {
+		const result = normalizeDateInput("next friday", { tm: "tomorrow" });
+		expect(result).toBe("next friday");
+	});
+
+	it("parses alias lines into a map", () => {
+		const parsed = parseDateAliasLines("tm = tomorrow\n# comment\nyd=yesterday");
+		expect(parsed).toEqual({ tm: "tomorrow", yd: "yesterday" });
+	});
+
+	it("formats aliases back into lines", () => {
+		const formatted = formatDateAliasLines({
+			tm: "tomorrow",
+			yd: "yesterday",
+		});
+		expect(formatted).toBe("tm = tomorrow\nyd = yesterday");
+	});
+
+	it("orders aliases with preferred keys first", () => {
+		const ordered = getOrderedDateAliases({
+			foo: "bar",
+			tm: "tomorrow",
+			yd: "yesterday",
+			t: "today",
+		});
+		expect(ordered[0][0]).toBe("t");
+		expect(ordered[1][0]).toBe("tm");
+	});
+
+	it("formats aliases inline", () => {
+		const summary = formatDateAliasInline({
+			tm: "tomorrow",
+			yd: "yesterday",
+		});
+		expect(summary).toContain("tm=tomorrow");
+	});
+});

src/utils/dateAliases.ts

@@ -0,0 +1,90 @@
+export type DateAliasMap = Record<string, string>;
+
+export const DEFAULT_DATE_ALIASES: DateAliasMap = {
+	t: "today",
+	tm: "tomorrow",
+	yd: "yesterday",
+	nw: "next week",
+	nm: "next month",
+	ny: "next year",
+	lw: "last week",
+	lm: "last month",
+	ly: "last year",
+};
+
+export function normalizeDateInput(
+	input: string,
+	aliases: DateAliasMap = DEFAULT_DATE_ALIASES,
+): string {
+	const trimmed = input.trim();
+	if (!trimmed) return input;
+
+	const direct = aliases[trimmed.toLowerCase()];
+	if (direct) return direct;
+
+	const [first, ...rest] = trimmed.split(/\s+/);
+	const replacement = aliases[first.toLowerCase()];
+	if (!replacement) return input;
+
+	return [replacement, ...rest].join(" ");
+}
+
+export function parseDateAliasLines(text: string): DateAliasMap {
+	const result: DateAliasMap = {};
+	const lines = text.split(/\r?\n/);
+
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+
+		const separatorIndex = trimmed.indexOf("=");
+		if (separatorIndex === -1) continue;
+
+		const key = trimmed.slice(0, separatorIndex).trim().toLowerCase();
+		const value = trimmed.slice(separatorIndex + 1).trim();
+
+		if (!key || !value) continue;
+		result[key] = value;
+	}
+
+	return result;
+}
+
+export function formatDateAliasLines(aliases: DateAliasMap): string {
+	return Object.entries(aliases)
+		.filter(([key, value]) => key && value)
+		.map(([key, value]) => `${key} = ${value}`)
+		.join("\n");
+}
+
+export function getOrderedDateAliases(
+	aliases: DateAliasMap,
+): Array<[string, string]> {
+	const entries = Object.entries(aliases);
+	if (entries.length === 0) return [];
+
+	const preferredKeys = ["t", "tm", "yd"];
+	const preferred = preferredKeys
+		.map((key) => {
+			const value = aliases[key];
+			return value ? ([key, value] as [string, string]) : null;
+		})
+		.filter((entry): entry is [string, string] => entry !== null);
+
+	const used = new Set(preferred.map(([key]) => key));
+	const remaining = entries
+		.filter(([key]) => !used.has(key))
+		.sort((a, b) => {
+			const lenDiff = a[0].length - b[0].length;
+			if (lenDiff !== 0) return lenDiff;
+			return a[0].localeCompare(b[0]);
+		});
+
+	return [...preferred, ...remaining];
+}
+
+export function formatDateAliasInline(aliases: DateAliasMap): string {
+	return getOrderedDateAliases(aliases)
+		.map(([key, value]) => `${key}=${value}`)
+		.join(", ");
+}