5321 lines
452 KiB
JavaScript
5321 lines
452 KiB
JavaScript
'use strict';
|
|
|
|
var obsidian = require('obsidian');
|
|
var electron = require('electron');
|
|
|
|
var PathDisplayFormat;
|
|
(function (PathDisplayFormat) {
|
|
PathDisplayFormat[PathDisplayFormat["None"] = 0] = "None";
|
|
PathDisplayFormat[PathDisplayFormat["Full"] = 1] = "Full";
|
|
PathDisplayFormat[PathDisplayFormat["FolderOnly"] = 2] = "FolderOnly";
|
|
PathDisplayFormat[PathDisplayFormat["FolderWithFilename"] = 3] = "FolderWithFilename";
|
|
PathDisplayFormat[PathDisplayFormat["FolderPathFilenameOptional"] = 4] = "FolderPathFilenameOptional";
|
|
})(PathDisplayFormat || (PathDisplayFormat = {}));
|
|
var Mode;
|
|
(function (Mode) {
|
|
Mode[Mode["Standard"] = 1] = "Standard";
|
|
Mode[Mode["EditorList"] = 2] = "EditorList";
|
|
Mode[Mode["SymbolList"] = 4] = "SymbolList";
|
|
Mode[Mode["WorkspaceList"] = 8] = "WorkspaceList";
|
|
Mode[Mode["HeadingsList"] = 16] = "HeadingsList";
|
|
Mode[Mode["BookmarksList"] = 32] = "BookmarksList";
|
|
Mode[Mode["CommandList"] = 64] = "CommandList";
|
|
Mode[Mode["RelatedItemsList"] = 128] = "RelatedItemsList";
|
|
Mode[Mode["VaultList"] = 256] = "VaultList";
|
|
})(Mode || (Mode = {}));
|
|
var SymbolType;
|
|
(function (SymbolType) {
|
|
SymbolType[SymbolType["Link"] = 1] = "Link";
|
|
SymbolType[SymbolType["Embed"] = 2] = "Embed";
|
|
SymbolType[SymbolType["Tag"] = 4] = "Tag";
|
|
SymbolType[SymbolType["Heading"] = 8] = "Heading";
|
|
SymbolType[SymbolType["Callout"] = 16] = "Callout";
|
|
SymbolType[SymbolType["CanvasNode"] = 32] = "CanvasNode";
|
|
})(SymbolType || (SymbolType = {}));
|
|
var LinkType;
|
|
(function (LinkType) {
|
|
LinkType[LinkType["None"] = 0] = "None";
|
|
LinkType[LinkType["Normal"] = 1] = "Normal";
|
|
LinkType[LinkType["Heading"] = 2] = "Heading";
|
|
LinkType[LinkType["Block"] = 4] = "Block";
|
|
})(LinkType || (LinkType = {}));
|
|
const SymbolIndicators = {};
|
|
SymbolIndicators[SymbolType.Link] = '🔗';
|
|
SymbolIndicators[SymbolType.Embed] = '!';
|
|
SymbolIndicators[SymbolType.Tag] = '#';
|
|
SymbolIndicators[SymbolType.Heading] = 'H';
|
|
const HeadingIndicators = {};
|
|
HeadingIndicators[1] = 'H₁';
|
|
HeadingIndicators[2] = 'H₂';
|
|
HeadingIndicators[3] = 'H₃';
|
|
HeadingIndicators[4] = 'H₄';
|
|
HeadingIndicators[5] = 'H₅';
|
|
HeadingIndicators[6] = 'H₆';
|
|
var SuggestionType;
|
|
(function (SuggestionType) {
|
|
SuggestionType["EditorList"] = "editorList";
|
|
SuggestionType["SymbolList"] = "symbolList";
|
|
SuggestionType["WorkspaceList"] = "workspaceList";
|
|
SuggestionType["HeadingsList"] = "headingsList";
|
|
SuggestionType["Bookmark"] = "bookmark";
|
|
SuggestionType["CommandList"] = "commandList";
|
|
SuggestionType["RelatedItemsList"] = "relatedItemsList";
|
|
SuggestionType["VaultList"] = "vaultList";
|
|
SuggestionType["File"] = "file";
|
|
SuggestionType["Alias"] = "alias";
|
|
SuggestionType["Unresolved"] = "unresolved";
|
|
})(SuggestionType || (SuggestionType = {}));
|
|
var MatchType;
|
|
(function (MatchType) {
|
|
MatchType[MatchType["None"] = 0] = "None";
|
|
MatchType[MatchType["Primary"] = 1] = "Primary";
|
|
MatchType[MatchType["Basename"] = 2] = "Basename";
|
|
MatchType[MatchType["Path"] = 3] = "Path";
|
|
})(MatchType || (MatchType = {}));
|
|
var RelationType;
|
|
(function (RelationType) {
|
|
RelationType["DiskLocation"] = "disk-location";
|
|
RelationType["Backlink"] = "backlink";
|
|
RelationType["OutgoingLink"] = "outgoing-link";
|
|
})(RelationType || (RelationType = {}));
|
|
|
|
function isOfType(obj, discriminator, val) {
|
|
let ret = false;
|
|
if (obj && obj[discriminator] !== undefined) {
|
|
ret = true;
|
|
if (val !== undefined && val !== obj[discriminator]) {
|
|
ret = false;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
function isSymbolSuggestion(obj) {
|
|
return isOfType(obj, 'type', SuggestionType.SymbolList);
|
|
}
|
|
function isEditorSuggestion(obj) {
|
|
return isOfType(obj, 'type', SuggestionType.EditorList);
|
|
}
|
|
function isHeadingSuggestion(obj) {
|
|
return isOfType(obj, 'type', SuggestionType.HeadingsList);
|
|
}
|
|
function isFileSuggestion(obj) {
|
|
return isOfType(obj, 'type', SuggestionType.File);
|
|
}
|
|
function isAliasSuggestion(obj) {
|
|
return isOfType(obj, 'type', SuggestionType.Alias);
|
|
}
|
|
function isUnresolvedSuggestion(obj) {
|
|
return isOfType(obj, 'type', SuggestionType.Unresolved);
|
|
}
|
|
function isSystemSuggestion(obj) {
|
|
return isFileSuggestion(obj) || isUnresolvedSuggestion(obj) || isAliasSuggestion(obj);
|
|
}
|
|
function isExSuggestion(sugg) {
|
|
return sugg && !isSystemSuggestion(sugg);
|
|
}
|
|
function isHeadingCache(obj) {
|
|
return isOfType(obj, 'level');
|
|
}
|
|
function isTagCache(obj) {
|
|
return isOfType(obj, 'tag');
|
|
}
|
|
function isCalloutCache(obj) {
|
|
return isOfType(obj, 'type', 'callout');
|
|
}
|
|
function isTFile(obj) {
|
|
return isOfType(obj, 'extension');
|
|
}
|
|
function escapeRegExp(str) {
|
|
return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
|
|
}
|
|
function getInternalPluginById(app, id) {
|
|
return app?.internalPlugins?.getPluginById(id);
|
|
}
|
|
function getInternalEnabledPluginById(app, id) {
|
|
return app?.internalPlugins?.getEnabledPluginById(id);
|
|
}
|
|
function getSystemSwitcherInstance(app) {
|
|
const plugin = getInternalPluginById(app, 'switcher');
|
|
return plugin?.instance;
|
|
}
|
|
function stripMDExtensionFromPath(file) {
|
|
let retVal = null;
|
|
if (file) {
|
|
const { path } = file;
|
|
retVal = path;
|
|
if (file.extension === 'md') {
|
|
const index = path.lastIndexOf('.');
|
|
if (index !== -1 && index !== path.length - 1 && index !== 0) {
|
|
retVal = path.slice(0, index);
|
|
}
|
|
}
|
|
}
|
|
return retVal;
|
|
}
|
|
function filenameFromPath(path) {
|
|
let retVal = null;
|
|
if (path) {
|
|
const index = path.lastIndexOf('/');
|
|
retVal = index === -1 ? path : path.slice(index + 1);
|
|
}
|
|
return retVal;
|
|
}
|
|
function matcherFnForRegExList(regExStrings) {
|
|
regExStrings = regExStrings ?? [];
|
|
const regExList = [];
|
|
for (const str of regExStrings) {
|
|
try {
|
|
const rx = new RegExp(str);
|
|
regExList.push(rx);
|
|
}
|
|
catch (err) {
|
|
console.log(`Switcher++: error creating RegExp from string: ${str}`, err);
|
|
}
|
|
}
|
|
const isMatchFn = (input) => {
|
|
for (const rx of regExList) {
|
|
if (rx.test(input)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
return isMatchFn;
|
|
}
|
|
function getLinkType(linkCache) {
|
|
let type = LinkType.None;
|
|
if (linkCache) {
|
|
// remove the display text before trying to parse the link target
|
|
const linkStr = linkCache.link.split('|')[0];
|
|
if (linkStr.includes('#^')) {
|
|
type = LinkType.Block;
|
|
}
|
|
else if (linkStr.includes('#')) {
|
|
type = LinkType.Heading;
|
|
}
|
|
else {
|
|
type = LinkType.Normal;
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
/**
|
|
* Retrieves a TFile object using path. Return null if path does not represent
|
|
* a TFile object.
|
|
* @param {string} path
|
|
* @param {Vault} vault
|
|
* @returns TFile
|
|
*/
|
|
function getTFileByPath(path, vault) {
|
|
let file = null;
|
|
const abstractItem = vault.getAbstractFileByPath(path);
|
|
if (isTFile(abstractItem)) {
|
|
file = abstractItem;
|
|
}
|
|
return file;
|
|
}
|
|
function generateMarkdownLink(fileManager, vault, sugg, sourcePath, options) {
|
|
let linkStr = null;
|
|
options = Object.assign({ useBasenameAsAlias: true, useHeadingAsAlias: true }, options);
|
|
if (sugg) {
|
|
let destFile = null;
|
|
let alias = null;
|
|
let subpath = null;
|
|
const fileSuggTypes = [
|
|
SuggestionType.Alias,
|
|
SuggestionType.Bookmark,
|
|
SuggestionType.HeadingsList,
|
|
SuggestionType.SymbolList,
|
|
SuggestionType.RelatedItemsList,
|
|
SuggestionType.EditorList,
|
|
SuggestionType.File,
|
|
];
|
|
// for file based suggestions, get the destination file
|
|
if (fileSuggTypes.includes(sugg.type)) {
|
|
destFile = sugg.file;
|
|
}
|
|
const linkSubPathForHeading = (heading) => {
|
|
return {
|
|
subpath: `#${heading}`,
|
|
alias: options.useHeadingAsAlias ? heading : null,
|
|
};
|
|
};
|
|
switch (sugg.type) {
|
|
case SuggestionType.Unresolved:
|
|
linkStr = generateMarkdownLinkForUnresolved(sugg.linktext);
|
|
break;
|
|
case SuggestionType.Alias:
|
|
alias = sugg.alias;
|
|
break;
|
|
case SuggestionType.Bookmark: {
|
|
const { item } = sugg;
|
|
if (item.type === 'file' && item.title) {
|
|
alias = item.title;
|
|
}
|
|
break;
|
|
}
|
|
case SuggestionType.HeadingsList: {
|
|
const { heading } = sugg.item;
|
|
({ subpath, alias } = linkSubPathForHeading(heading));
|
|
break;
|
|
}
|
|
case SuggestionType.SymbolList: {
|
|
const { item: { symbol }, } = sugg;
|
|
if (isHeadingCache(symbol)) {
|
|
({ subpath, alias } = linkSubPathForHeading(symbol.heading));
|
|
}
|
|
else if (isOfType(symbol, 'link')) {
|
|
// Test if the link matches the external link format [text](url)
|
|
const isExternalLink = new RegExp(/^\[(.*?)\]\((.+?)\)/).test(symbol.original);
|
|
if (isExternalLink) {
|
|
linkStr = symbol.original;
|
|
}
|
|
else {
|
|
linkStr = generateMarkdownLinkForReferenceCache(fileManager, vault, sourcePath, symbol, destFile, options.useBasenameAsAlias);
|
|
}
|
|
}
|
|
else {
|
|
// Disable link generation for other symbol types by setting destFile to null
|
|
destFile = null;
|
|
}
|
|
break;
|
|
}
|
|
case SuggestionType.RelatedItemsList: {
|
|
const { item } = sugg;
|
|
if (item.unresolvedText) {
|
|
linkStr = generateMarkdownLinkForUnresolved(item.unresolvedText);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (destFile && !linkStr) {
|
|
// if an alias has be not identified use the filename as alias
|
|
if (!alias && options.useBasenameAsAlias) {
|
|
alias = destFile.basename;
|
|
}
|
|
linkStr = fileManager.generateMarkdownLink(destFile, sourcePath, subpath, alias);
|
|
}
|
|
}
|
|
return linkStr;
|
|
}
|
|
function generateMarkdownLinkForUnresolved(path, displayText) {
|
|
displayText = displayText?.length ? `|${displayText}` : '';
|
|
return `[[${path}${displayText}]]`;
|
|
}
|
|
function generateMarkdownLinkForReferenceCache(fileManager, vault, sourcePath, refCache, refCacheSourceFile, useBasenameAsAlias) {
|
|
const { link, displayText } = refCache;
|
|
const { path, subpath } = obsidian.parseLinktext(link);
|
|
let alias = displayText;
|
|
let destFile = null;
|
|
let linkStr = null;
|
|
if (!path?.length) {
|
|
// the path portion of the link is empty, meaning the destination path
|
|
// is the file that contains the ReferenceCache
|
|
destFile = refCacheSourceFile;
|
|
}
|
|
else {
|
|
destFile = getTFileByPath(path, vault);
|
|
}
|
|
if (destFile) {
|
|
if (!alias?.length && useBasenameAsAlias) {
|
|
alias = destFile.basename;
|
|
}
|
|
linkStr = fileManager.generateMarkdownLink(destFile, sourcePath, subpath, alias);
|
|
}
|
|
else {
|
|
linkStr = generateMarkdownLinkForUnresolved(path, alias);
|
|
}
|
|
return linkStr;
|
|
}
|
|
|
|
class FrontMatterParser {
|
|
static getAliases(frontMatter) {
|
|
let aliases = [];
|
|
if (frontMatter) {
|
|
aliases = FrontMatterParser.getValueForKey(frontMatter, /^alias(es)?$/i);
|
|
}
|
|
return aliases;
|
|
}
|
|
static getValueForKey(frontMatter, keyPattern) {
|
|
const retVal = [];
|
|
const fmKeys = Object.keys(frontMatter);
|
|
const key = fmKeys.find((val) => keyPattern.test(val));
|
|
if (key) {
|
|
// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
|
|
let value = frontMatter[key];
|
|
if (typeof value === 'string') {
|
|
value = value.split(',');
|
|
}
|
|
if (Array.isArray(value)) {
|
|
value.forEach((val) => {
|
|
if (typeof val === 'string') {
|
|
retVal.push(val.trim());
|
|
}
|
|
});
|
|
}
|
|
}
|
|
return retVal;
|
|
}
|
|
}
|
|
|
|
// map Canvas node data types to facet id
|
|
const CANVAS_NODE_FACET_ID_MAP = {
|
|
file: 'canvas-node-file',
|
|
text: 'canvas-node-text',
|
|
link: 'canvas-node-link',
|
|
group: 'canvas-node-group',
|
|
};
|
|
const SYMBOL_MODE_FACETS = [
|
|
{
|
|
id: SymbolType[SymbolType.Heading],
|
|
mode: Mode.SymbolList,
|
|
label: 'headings',
|
|
isActive: false,
|
|
isAvailable: true,
|
|
},
|
|
{
|
|
id: SymbolType[SymbolType.Tag],
|
|
mode: Mode.SymbolList,
|
|
label: 'tags',
|
|
isActive: false,
|
|
isAvailable: true,
|
|
},
|
|
{
|
|
id: SymbolType[SymbolType.Callout],
|
|
mode: Mode.SymbolList,
|
|
label: 'callouts',
|
|
isActive: false,
|
|
isAvailable: true,
|
|
},
|
|
{
|
|
id: SymbolType[SymbolType.Link],
|
|
mode: Mode.SymbolList,
|
|
label: 'links',
|
|
isActive: false,
|
|
isAvailable: true,
|
|
},
|
|
{
|
|
id: SymbolType[SymbolType.Embed],
|
|
mode: Mode.SymbolList,
|
|
label: 'embeds',
|
|
isActive: false,
|
|
isAvailable: true,
|
|
},
|
|
{
|
|
id: CANVAS_NODE_FACET_ID_MAP.file,
|
|
mode: Mode.SymbolList,
|
|
label: 'file cards',
|
|
isActive: false,
|
|
isAvailable: true,
|
|
},
|
|
{
|
|
id: CANVAS_NODE_FACET_ID_MAP.text,
|
|
mode: Mode.SymbolList,
|
|
label: 'text cards',
|
|
isActive: false,
|
|
isAvailable: true,
|
|
},
|
|
{
|
|
id: CANVAS_NODE_FACET_ID_MAP.link,
|
|
mode: Mode.SymbolList,
|
|
label: 'link cards',
|
|
isActive: false,
|
|
isAvailable: true,
|
|
},
|
|
{
|
|
id: CANVAS_NODE_FACET_ID_MAP.group,
|
|
mode: Mode.SymbolList,
|
|
label: 'groups',
|
|
isActive: false,
|
|
isAvailable: true,
|
|
},
|
|
];
|
|
const RELATED_ITEMS_MODE_FACETS = [
|
|
{
|
|
id: RelationType.Backlink,
|
|
mode: Mode.RelatedItemsList,
|
|
label: 'backlinks',
|
|
isActive: false,
|
|
isAvailable: true,
|
|
},
|
|
{
|
|
id: RelationType.OutgoingLink,
|
|
mode: Mode.RelatedItemsList,
|
|
label: 'outgoing links',
|
|
isActive: false,
|
|
isAvailable: true,
|
|
},
|
|
{
|
|
id: RelationType.DiskLocation,
|
|
mode: Mode.RelatedItemsList,
|
|
label: 'disk location',
|
|
isActive: false,
|
|
isAvailable: true,
|
|
},
|
|
];
|
|
const BOOKMARKS_FACET_ID_MAP = {
|
|
file: 'bookmarks-file',
|
|
folder: 'bookmarks-folder',
|
|
search: 'bookmarks-search',
|
|
group: 'bookmarks-group',
|
|
};
|
|
const BOOKMARKS_MODE_FACETS = [
|
|
{
|
|
id: BOOKMARKS_FACET_ID_MAP.file,
|
|
mode: Mode.BookmarksList,
|
|
label: 'files',
|
|
isActive: false,
|
|
isAvailable: true,
|
|
},
|
|
{
|
|
id: BOOKMARKS_FACET_ID_MAP.folder,
|
|
mode: Mode.BookmarksList,
|
|
label: 'folders',
|
|
isActive: false,
|
|
isAvailable: true,
|
|
},
|
|
{
|
|
id: BOOKMARKS_FACET_ID_MAP.search,
|
|
mode: Mode.BookmarksList,
|
|
label: 'searches',
|
|
isActive: false,
|
|
isAvailable: true,
|
|
},
|
|
];
|
|
const FACETS_ALL = [
|
|
...SYMBOL_MODE_FACETS,
|
|
...RELATED_ITEMS_MODE_FACETS,
|
|
...BOOKMARKS_MODE_FACETS,
|
|
];
|
|
function getFacetMap() {
|
|
return FACETS_ALL.reduce((facetMap, facet) => {
|
|
const facetId = facet['id'];
|
|
facetMap[facetId] = Object.assign({}, facet);
|
|
return facetMap;
|
|
}, {});
|
|
}
|
|
|
|
// istanbul ignore next
|
|
const isObject = (obj) => {
|
|
if (typeof obj === "object" && obj !== null) {
|
|
if (typeof Object.getPrototypeOf === "function") {
|
|
const prototype = Object.getPrototypeOf(obj);
|
|
return prototype === Object.prototype || prototype === null;
|
|
}
|
|
return Object.prototype.toString.call(obj) === "[object Object]";
|
|
}
|
|
return false;
|
|
};
|
|
const merge = (...objects) => objects.reduce((result, current) => {
|
|
if (Array.isArray(current)) {
|
|
throw new TypeError("Arguments provided to ts-deepmerge must be objects, not arrays.");
|
|
}
|
|
Object.keys(current).forEach((key) => {
|
|
if (["__proto__", "constructor", "prototype"].includes(key)) {
|
|
return;
|
|
}
|
|
if (Array.isArray(result[key]) && Array.isArray(current[key])) {
|
|
result[key] = merge.options.mergeArrays
|
|
? merge.options.uniqueArrayItems
|
|
? Array.from(new Set(result[key].concat(current[key])))
|
|
: [...result[key], ...current[key]]
|
|
: current[key];
|
|
}
|
|
else if (isObject(result[key]) && isObject(current[key])) {
|
|
result[key] = merge(result[key], current[key]);
|
|
}
|
|
else {
|
|
result[key] =
|
|
current[key] === undefined
|
|
? merge.options.allowUndefinedOverrides
|
|
? current[key]
|
|
: result[key]
|
|
: current[key];
|
|
}
|
|
});
|
|
return result;
|
|
}, {});
|
|
const defaultOptions = {
|
|
allowUndefinedOverrides: true,
|
|
mergeArrays: true,
|
|
uniqueArrayItems: true,
|
|
};
|
|
merge.options = defaultOptions;
|
|
merge.withOptions = (options, ...objects) => {
|
|
merge.options = Object.assign(Object.assign({}, defaultOptions), options);
|
|
const result = merge(...objects);
|
|
merge.options = defaultOptions;
|
|
return result;
|
|
};
|
|
|
|
class SwitcherPlusSettings {
|
|
static get defaults() {
|
|
const enabledSymbolTypes = {};
|
|
enabledSymbolTypes[SymbolType.Link] = true;
|
|
enabledSymbolTypes[SymbolType.Embed] = true;
|
|
enabledSymbolTypes[SymbolType.Tag] = true;
|
|
enabledSymbolTypes[SymbolType.Heading] = true;
|
|
enabledSymbolTypes[SymbolType.Callout] = true;
|
|
return {
|
|
version: '2.0.0',
|
|
onOpenPreferNewTab: true,
|
|
alwaysNewTabForSymbols: false,
|
|
useActiveTabForSymbolsOnMobile: false,
|
|
symbolsInLineOrder: true,
|
|
editorListCommand: 'edt ',
|
|
symbolListCommand: '@',
|
|
symbolListActiveEditorCommand: '$ ',
|
|
workspaceListCommand: '+',
|
|
headingsListCommand: '#',
|
|
bookmarksListCommand: "'",
|
|
commandListCommand: '>',
|
|
vaultListCommand: 'vault ',
|
|
relatedItemsListCommand: '~',
|
|
relatedItemsListActiveEditorCommand: '^ ',
|
|
strictHeadingsOnly: false,
|
|
searchAllHeadings: true,
|
|
headingsSearchDebounceMilli: 250,
|
|
excludeViewTypes: ['empty'],
|
|
referenceViews: ['backlink', 'localgraph', 'outgoing-link', 'outline'],
|
|
limit: 50,
|
|
includeSidePanelViewTypes: ['backlink', 'image', 'markdown', 'pdf'],
|
|
enabledSymbolTypes,
|
|
selectNearestHeading: true,
|
|
excludeFolders: [],
|
|
excludeLinkSubTypes: 0,
|
|
excludeRelatedFolders: [''],
|
|
excludeOpenRelatedFiles: false,
|
|
excludeObsidianIgnoredFiles: false,
|
|
shouldSearchFilenames: false,
|
|
shouldSearchBookmarks: false,
|
|
pathDisplayFormat: PathDisplayFormat.FolderWithFilename,
|
|
hidePathIfRoot: true,
|
|
enabledRelatedItems: Object.values(RelationType),
|
|
showOptionalIndicatorIcons: true,
|
|
overrideStandardModeBehaviors: true,
|
|
enabledRibbonCommands: [
|
|
Mode[Mode.HeadingsList],
|
|
Mode[Mode.SymbolList],
|
|
],
|
|
fileExtAllowList: ['canvas'],
|
|
matchPriorityAdjustments: {
|
|
isEnabled: false,
|
|
adjustments: {
|
|
isOpenInEditor: { value: 0, label: 'Open items' },
|
|
isBookmarked: { value: 0, label: 'Bookmarked items' },
|
|
isRecent: { value: 0, label: 'Recent items' },
|
|
isAttachment: { value: 0, label: 'Attachment file types' },
|
|
file: { value: 0, label: 'Filenames' },
|
|
alias: { value: 0, label: 'Aliases' },
|
|
unresolved: { value: 0, label: 'Unresolved filenames' },
|
|
h1: { value: 0, label: 'H₁ headings' },
|
|
},
|
|
fileExtAdjustments: {
|
|
canvas: { value: 0, label: 'Canvas files' },
|
|
},
|
|
},
|
|
quickFilters: {
|
|
resetKey: '0',
|
|
keyList: ['1', '2', '3', '4', '5', '6', '7', '8', '9'],
|
|
modifiers: ['Ctrl', 'Alt'],
|
|
facetList: getFacetMap(),
|
|
shouldResetActiveFacets: false,
|
|
shouldShowFacetInstructions: true,
|
|
},
|
|
preserveCommandPaletteLastInput: false,
|
|
preserveQuickSwitcherLastInput: false,
|
|
shouldCloseModalOnBackspace: false,
|
|
maxRecentFileSuggestionsOnInit: 25,
|
|
orderEditorListByAccessTime: true,
|
|
insertLinkInEditor: {
|
|
isEnabled: true,
|
|
keymap: {
|
|
modifiers: ['Mod'],
|
|
key: 'i',
|
|
purpose: 'insert in editor',
|
|
},
|
|
insertableEditorTypes: ['markdown'],
|
|
useBasenameAsAlias: true,
|
|
useHeadingAsAlias: true,
|
|
},
|
|
removeDefaultTabBinding: true,
|
|
navigationKeys: {
|
|
nextKeys: [
|
|
{ modifiers: ['Ctrl'], key: 'n' },
|
|
{ modifiers: ['Ctrl'], key: 'j' },
|
|
],
|
|
prevKeys: [
|
|
{ modifiers: ['Ctrl'], key: 'p' },
|
|
{ modifiers: ['Ctrl'], key: 'k' },
|
|
],
|
|
},
|
|
preferredSourceForTitle: 'H1',
|
|
closeWhenEmptyKeys: [{ modifiers: null, key: 'Backspace' }],
|
|
escapeCmdChar: '!',
|
|
};
|
|
}
|
|
get version() {
|
|
return this.data.version;
|
|
}
|
|
set version(value) {
|
|
this.data.version = value;
|
|
}
|
|
get builtInSystemOptions() {
|
|
return getSystemSwitcherInstance(this.plugin.app)?.options;
|
|
}
|
|
get showAllFileTypes() {
|
|
// forward to core switcher settings
|
|
return this.builtInSystemOptions?.showAllFileTypes;
|
|
}
|
|
get showAttachments() {
|
|
// forward to core switcher settings
|
|
return this.builtInSystemOptions?.showAttachments;
|
|
}
|
|
get showExistingOnly() {
|
|
// forward to core switcher settings
|
|
return this.builtInSystemOptions?.showExistingOnly;
|
|
}
|
|
get onOpenPreferNewTab() {
|
|
return this.data.onOpenPreferNewTab;
|
|
}
|
|
set onOpenPreferNewTab(value) {
|
|
this.data.onOpenPreferNewTab = value;
|
|
}
|
|
get alwaysNewTabForSymbols() {
|
|
return this.data.alwaysNewTabForSymbols;
|
|
}
|
|
set alwaysNewTabForSymbols(value) {
|
|
this.data.alwaysNewTabForSymbols = value;
|
|
}
|
|
get useActiveTabForSymbolsOnMobile() {
|
|
return this.data.useActiveTabForSymbolsOnMobile;
|
|
}
|
|
set useActiveTabForSymbolsOnMobile(value) {
|
|
this.data.useActiveTabForSymbolsOnMobile = value;
|
|
}
|
|
get symbolsInLineOrder() {
|
|
return this.data.symbolsInLineOrder;
|
|
}
|
|
set symbolsInLineOrder(value) {
|
|
this.data.symbolsInLineOrder = value;
|
|
}
|
|
get editorListPlaceholderText() {
|
|
return SwitcherPlusSettings.defaults.editorListCommand;
|
|
}
|
|
get editorListCommand() {
|
|
return this.data.editorListCommand;
|
|
}
|
|
set editorListCommand(value) {
|
|
this.data.editorListCommand = value;
|
|
}
|
|
get symbolListPlaceholderText() {
|
|
return SwitcherPlusSettings.defaults.symbolListCommand;
|
|
}
|
|
get symbolListCommand() {
|
|
return this.data.symbolListCommand;
|
|
}
|
|
set symbolListCommand(value) {
|
|
this.data.symbolListCommand = value;
|
|
}
|
|
get symbolListActiveEditorCommand() {
|
|
return this.data.symbolListActiveEditorCommand;
|
|
}
|
|
set symbolListActiveEditorCommand(value) {
|
|
this.data.symbolListActiveEditorCommand = value;
|
|
}
|
|
get workspaceListCommand() {
|
|
return this.data.workspaceListCommand;
|
|
}
|
|
set workspaceListCommand(value) {
|
|
this.data.workspaceListCommand = value;
|
|
}
|
|
get workspaceListPlaceholderText() {
|
|
return SwitcherPlusSettings.defaults.workspaceListCommand;
|
|
}
|
|
get headingsListCommand() {
|
|
return this.data.headingsListCommand;
|
|
}
|
|
set headingsListCommand(value) {
|
|
this.data.headingsListCommand = value;
|
|
}
|
|
get headingsListPlaceholderText() {
|
|
return SwitcherPlusSettings.defaults.headingsListCommand;
|
|
}
|
|
get bookmarksListCommand() {
|
|
return this.data.bookmarksListCommand;
|
|
}
|
|
set bookmarksListCommand(value) {
|
|
this.data.bookmarksListCommand = value;
|
|
}
|
|
get bookmarksListPlaceholderText() {
|
|
return SwitcherPlusSettings.defaults.bookmarksListCommand;
|
|
}
|
|
get commandListCommand() {
|
|
return this.data.commandListCommand;
|
|
}
|
|
set commandListCommand(value) {
|
|
this.data.commandListCommand = value;
|
|
}
|
|
get commandListPlaceholderText() {
|
|
return SwitcherPlusSettings.defaults.commandListCommand;
|
|
}
|
|
get vaultListCommand() {
|
|
return this.data.vaultListCommand;
|
|
}
|
|
set vaultListCommand(value) {
|
|
this.data.vaultListCommand = value;
|
|
}
|
|
get vaultListPlaceholderText() {
|
|
return SwitcherPlusSettings.defaults.vaultListCommand;
|
|
}
|
|
get relatedItemsListCommand() {
|
|
return this.data.relatedItemsListCommand;
|
|
}
|
|
set relatedItemsListCommand(value) {
|
|
this.data.relatedItemsListCommand = value;
|
|
}
|
|
get relatedItemsListPlaceholderText() {
|
|
return SwitcherPlusSettings.defaults.relatedItemsListCommand;
|
|
}
|
|
get relatedItemsListActiveEditorCommand() {
|
|
return this.data.relatedItemsListActiveEditorCommand;
|
|
}
|
|
set relatedItemsListActiveEditorCommand(value) {
|
|
this.data.relatedItemsListActiveEditorCommand = value;
|
|
}
|
|
get strictHeadingsOnly() {
|
|
return this.data.strictHeadingsOnly;
|
|
}
|
|
set strictHeadingsOnly(value) {
|
|
this.data.strictHeadingsOnly = value;
|
|
}
|
|
get searchAllHeadings() {
|
|
return this.data.searchAllHeadings;
|
|
}
|
|
set searchAllHeadings(value) {
|
|
this.data.searchAllHeadings = value;
|
|
}
|
|
get headingsSearchDebounceMilli() {
|
|
return this.data.headingsSearchDebounceMilli;
|
|
}
|
|
set headingsSearchDebounceMilli(value) {
|
|
this.data.headingsSearchDebounceMilli = value;
|
|
}
|
|
get excludeViewTypes() {
|
|
return this.data.excludeViewTypes;
|
|
}
|
|
set excludeViewTypes(value) {
|
|
this.data.excludeViewTypes = value;
|
|
}
|
|
get referenceViews() {
|
|
return this.data.referenceViews;
|
|
}
|
|
set referenceViews(value) {
|
|
this.data.referenceViews = value;
|
|
}
|
|
get limit() {
|
|
return this.data.limit;
|
|
}
|
|
set limit(value) {
|
|
this.data.limit = value;
|
|
}
|
|
get includeSidePanelViewTypes() {
|
|
return this.data.includeSidePanelViewTypes;
|
|
}
|
|
set includeSidePanelViewTypes(value) {
|
|
// remove any duplicates before storing
|
|
this.data.includeSidePanelViewTypes = [...new Set(value)];
|
|
}
|
|
get includeSidePanelViewTypesPlaceholder() {
|
|
return SwitcherPlusSettings.defaults.includeSidePanelViewTypes.join('\n');
|
|
}
|
|
get selectNearestHeading() {
|
|
return this.data.selectNearestHeading;
|
|
}
|
|
set selectNearestHeading(value) {
|
|
this.data.selectNearestHeading = value;
|
|
}
|
|
get excludeFolders() {
|
|
return this.data.excludeFolders;
|
|
}
|
|
set excludeFolders(value) {
|
|
// remove any duplicates before storing
|
|
this.data.excludeFolders = [...new Set(value)];
|
|
}
|
|
get excludeLinkSubTypes() {
|
|
return this.data.excludeLinkSubTypes;
|
|
}
|
|
set excludeLinkSubTypes(value) {
|
|
this.data.excludeLinkSubTypes = value;
|
|
}
|
|
get excludeRelatedFolders() {
|
|
return this.data.excludeRelatedFolders;
|
|
}
|
|
set excludeRelatedFolders(value) {
|
|
this.data.excludeRelatedFolders = [...new Set(value)];
|
|
}
|
|
get excludeOpenRelatedFiles() {
|
|
return this.data.excludeOpenRelatedFiles;
|
|
}
|
|
set excludeOpenRelatedFiles(value) {
|
|
this.data.excludeOpenRelatedFiles = value;
|
|
}
|
|
get excludeObsidianIgnoredFiles() {
|
|
return this.data.excludeObsidianIgnoredFiles;
|
|
}
|
|
set excludeObsidianIgnoredFiles(value) {
|
|
this.data.excludeObsidianIgnoredFiles = value;
|
|
}
|
|
get shouldSearchFilenames() {
|
|
return this.data.shouldSearchFilenames;
|
|
}
|
|
set shouldSearchFilenames(value) {
|
|
this.data.shouldSearchFilenames = value;
|
|
}
|
|
get shouldSearchBookmarks() {
|
|
return this.data.shouldSearchBookmarks;
|
|
}
|
|
set shouldSearchBookmarks(value) {
|
|
this.data.shouldSearchBookmarks = value;
|
|
}
|
|
get pathDisplayFormat() {
|
|
return this.data.pathDisplayFormat;
|
|
}
|
|
set pathDisplayFormat(value) {
|
|
this.data.pathDisplayFormat = value;
|
|
}
|
|
get hidePathIfRoot() {
|
|
return this.data.hidePathIfRoot;
|
|
}
|
|
set hidePathIfRoot(value) {
|
|
this.data.hidePathIfRoot = value;
|
|
}
|
|
get enabledRelatedItems() {
|
|
return this.data.enabledRelatedItems;
|
|
}
|
|
set enabledRelatedItems(value) {
|
|
this.data.enabledRelatedItems = value;
|
|
}
|
|
get showOptionalIndicatorIcons() {
|
|
return this.data.showOptionalIndicatorIcons;
|
|
}
|
|
set showOptionalIndicatorIcons(value) {
|
|
this.data.showOptionalIndicatorIcons = value;
|
|
}
|
|
get overrideStandardModeBehaviors() {
|
|
return this.data.overrideStandardModeBehaviors;
|
|
}
|
|
set overrideStandardModeBehaviors(value) {
|
|
this.data.overrideStandardModeBehaviors = value;
|
|
}
|
|
get enabledRibbonCommands() {
|
|
return this.data.enabledRibbonCommands;
|
|
}
|
|
set enabledRibbonCommands(value) {
|
|
// remove any duplicates before storing
|
|
this.data.enabledRibbonCommands = [...new Set(value)];
|
|
}
|
|
get fileExtAllowList() {
|
|
return this.data.fileExtAllowList;
|
|
}
|
|
set fileExtAllowList(value) {
|
|
this.data.fileExtAllowList = value;
|
|
}
|
|
get matchPriorityAdjustments() {
|
|
return this.data.matchPriorityAdjustments;
|
|
}
|
|
set matchPriorityAdjustments(value) {
|
|
this.data.matchPriorityAdjustments = value;
|
|
}
|
|
get quickFilters() {
|
|
return this.data.quickFilters;
|
|
}
|
|
set quickFilters(value) {
|
|
this.data.quickFilters = value;
|
|
}
|
|
get preserveCommandPaletteLastInput() {
|
|
return this.data.preserveCommandPaletteLastInput;
|
|
}
|
|
set preserveCommandPaletteLastInput(value) {
|
|
this.data.preserveCommandPaletteLastInput = value;
|
|
}
|
|
get preserveQuickSwitcherLastInput() {
|
|
return this.data.preserveQuickSwitcherLastInput;
|
|
}
|
|
set preserveQuickSwitcherLastInput(value) {
|
|
this.data.preserveQuickSwitcherLastInput = value;
|
|
}
|
|
get shouldCloseModalOnBackspace() {
|
|
return this.data.shouldCloseModalOnBackspace;
|
|
}
|
|
set shouldCloseModalOnBackspace(value) {
|
|
this.data.shouldCloseModalOnBackspace = value;
|
|
}
|
|
get maxRecentFileSuggestionsOnInit() {
|
|
return this.data.maxRecentFileSuggestionsOnInit;
|
|
}
|
|
set maxRecentFileSuggestionsOnInit(value) {
|
|
this.data.maxRecentFileSuggestionsOnInit = value;
|
|
}
|
|
get orderEditorListByAccessTime() {
|
|
return this.data.orderEditorListByAccessTime;
|
|
}
|
|
set orderEditorListByAccessTime(value) {
|
|
this.data.orderEditorListByAccessTime = value;
|
|
}
|
|
get insertLinkInEditor() {
|
|
return this.data.insertLinkInEditor;
|
|
}
|
|
set insertLinkInEditor(value) {
|
|
this.data.insertLinkInEditor = value;
|
|
}
|
|
get removeDefaultTabBinding() {
|
|
return this.data.removeDefaultTabBinding;
|
|
}
|
|
set removeDefaultTabBinding(value) {
|
|
this.data.removeDefaultTabBinding = value;
|
|
}
|
|
get navigationKeys() {
|
|
return this.data.navigationKeys;
|
|
}
|
|
set navigationKeys(value) {
|
|
this.data.navigationKeys = value;
|
|
}
|
|
get preferredSourceForTitle() {
|
|
return this.data.preferredSourceForTitle;
|
|
}
|
|
set preferredSourceForTitle(value) {
|
|
this.data.preferredSourceForTitle = value;
|
|
}
|
|
get closeWhenEmptyKeys() {
|
|
return this.data.closeWhenEmptyKeys;
|
|
}
|
|
set closeWhenEmptyKeys(value) {
|
|
this.data.closeWhenEmptyKeys = value;
|
|
}
|
|
get escapeCmdChar() {
|
|
return this.data.escapeCmdChar;
|
|
}
|
|
set escapeCmdChar(value) {
|
|
this.data.escapeCmdChar = value;
|
|
}
|
|
constructor(plugin) {
|
|
this.plugin = plugin;
|
|
this.data = SwitcherPlusSettings.defaults;
|
|
}
|
|
async updateDataAndLoadSettings() {
|
|
await SwitcherPlusSettings.transformDataFile(this.plugin, SwitcherPlusSettings.defaults);
|
|
return await this.loadSettings();
|
|
}
|
|
async loadSettings() {
|
|
const copy = (savedData, defaultData, keys) => {
|
|
const keysToMerge = ['matchPriorityAdjustments', 'quickFilters'];
|
|
const deepMerge = (key) => {
|
|
return merge.withOptions({ mergeArrays: false }, defaultData[key], savedData[key]);
|
|
};
|
|
for (const key of keys) {
|
|
if (key in savedData) {
|
|
defaultData[key] = keysToMerge.includes(key)
|
|
? deepMerge(key)
|
|
: savedData[key];
|
|
}
|
|
}
|
|
};
|
|
try {
|
|
const savedData = (await this.plugin?.loadData());
|
|
if (savedData) {
|
|
const keys = Object.keys(SwitcherPlusSettings.defaults);
|
|
copy(savedData, this.data, keys);
|
|
}
|
|
}
|
|
catch (err) {
|
|
console.log('Switcher++: error loading settings, using defaults. ', err);
|
|
}
|
|
}
|
|
async saveSettings() {
|
|
const { plugin, data } = this;
|
|
await plugin?.saveData(data);
|
|
}
|
|
save() {
|
|
this.saveSettings().catch((e) => {
|
|
console.log('Switcher++: error saving changes to settings', e);
|
|
});
|
|
}
|
|
isSymbolTypeEnabled(symbol) {
|
|
const { enabledSymbolTypes } = this.data;
|
|
let value = SwitcherPlusSettings.defaults.enabledSymbolTypes[symbol];
|
|
if (Object.prototype.hasOwnProperty.call(enabledSymbolTypes, symbol)) {
|
|
value = enabledSymbolTypes[symbol];
|
|
}
|
|
return value;
|
|
}
|
|
setSymbolTypeEnabled(symbol, isEnabled) {
|
|
this.data.enabledSymbolTypes[symbol] = isEnabled;
|
|
}
|
|
static async transformDataFile(plugin, defaults) {
|
|
await SwitcherPlusSettings.transformDataFileToV1(plugin, defaults);
|
|
await SwitcherPlusSettings.transformDataFileToV2(plugin, defaults);
|
|
}
|
|
static async transformDataFileToV1(plugin, defaults) {
|
|
let isTransformed = false;
|
|
try {
|
|
const data = (await plugin?.loadData());
|
|
if (data && typeof data === 'object') {
|
|
const versionKey = 'version';
|
|
if (!Object.prototype.hasOwnProperty.call(data, versionKey)) {
|
|
// rename from starred to bookmarks
|
|
const starredCommandKey = 'starredListCommand';
|
|
if (Object.prototype.hasOwnProperty.call(data, starredCommandKey)) {
|
|
data['bookmarksListCommand'] =
|
|
data[starredCommandKey] ?? defaults.bookmarksListCommand;
|
|
delete data[starredCommandKey];
|
|
}
|
|
// rename isStarred to isBookmarked
|
|
const isStarredKey = 'isStarred';
|
|
const adjustments = data['matchPriorityAdjustments'];
|
|
if (adjustments &&
|
|
Object.prototype.hasOwnProperty.call(adjustments, isStarredKey)) {
|
|
adjustments['isBookmarked'] = adjustments[isStarredKey];
|
|
delete adjustments[isStarredKey];
|
|
}
|
|
data[versionKey] = '1.0.0';
|
|
await plugin?.saveData(data);
|
|
isTransformed = true;
|
|
}
|
|
}
|
|
}
|
|
catch (error) {
|
|
console.log('Switcher++: error transforming data.json to v1.0.0', error);
|
|
}
|
|
return isTransformed;
|
|
}
|
|
static async transformDataFileToV2(plugin, defaults) {
|
|
let isTransformed = false;
|
|
try {
|
|
const data = (await plugin?.loadData());
|
|
if (data && typeof data === 'object') {
|
|
const versionKey = 'version';
|
|
if (data[versionKey] === '1.0.0') {
|
|
const matchPriorityAdjustmentsKey = 'matchPriorityAdjustments';
|
|
if (Object.prototype.hasOwnProperty.call(data, matchPriorityAdjustmentsKey)) {
|
|
// Convert matchPriorityAdjustments to key/object pairs
|
|
// Version <= 1.0.0 type was Record<string, number>
|
|
const oldAdjustments = data[matchPriorityAdjustmentsKey];
|
|
const adjustments = {};
|
|
data[matchPriorityAdjustmentsKey] = {
|
|
isEnabled: !!data['enableMatchPriorityAdjustments'],
|
|
adjustments,
|
|
};
|
|
delete data['enableMatchPriorityAdjustments'];
|
|
Object.entries(oldAdjustments).forEach(([key, value]) => {
|
|
const label = defaults.matchPriorityAdjustments.adjustments[key]?.label ?? '';
|
|
adjustments[key] = { value, label };
|
|
});
|
|
}
|
|
const quickFiltersKey = 'quickFilters';
|
|
if (Object.prototype.hasOwnProperty.call(data, quickFiltersKey)) {
|
|
// convert .facetList from Array<Object> to Record<string, Object>
|
|
const facetListKey = 'facetList';
|
|
const quickFiltersData = data[quickFiltersKey];
|
|
const oldFacetList = quickFiltersData[facetListKey];
|
|
const facetList = oldFacetList?.reduce((facetMap, oldFacet) => {
|
|
const facetId = oldFacet['id'];
|
|
facetMap[facetId] = oldFacet;
|
|
return facetMap;
|
|
}, {});
|
|
quickFiltersData[facetListKey] = facetList;
|
|
}
|
|
data[versionKey] = '2.0.0';
|
|
await plugin?.saveData(data);
|
|
isTransformed = true;
|
|
}
|
|
}
|
|
}
|
|
catch (error) {
|
|
console.log('Switcher++: error transforming data.json to v2.0.0', error);
|
|
}
|
|
return isTransformed;
|
|
}
|
|
}
|
|
|
|
class SettingsTabSection {
|
|
constructor(app, mainSettingsTab, config) {
|
|
this.app = app;
|
|
this.mainSettingsTab = mainSettingsTab;
|
|
this.config = config;
|
|
}
|
|
/**
|
|
* Creates a new Setting with the given name and description.
|
|
* @param {HTMLElement} containerEl
|
|
* @param {string} name
|
|
* @param {string} desc
|
|
* @returns Setting
|
|
*/
|
|
createSetting(containerEl, name, desc) {
|
|
const setting = new obsidian.Setting(containerEl);
|
|
setting.setName(name);
|
|
setting.setDesc(desc);
|
|
return setting;
|
|
}
|
|
/**
|
|
* Create section title elements and divider.
|
|
* @param {HTMLElement} containerEl
|
|
* @param {string} title
|
|
* @param {string} desc?
|
|
* @returns Setting
|
|
*/
|
|
addSectionTitle(containerEl, title, desc = '') {
|
|
const setting = this.createSetting(containerEl, title, desc);
|
|
setting.setHeading();
|
|
return setting;
|
|
}
|
|
/**
|
|
* Creates a HTMLInput element setting.
|
|
* @param {HTMLElement} containerEl The element to attach the setting to.
|
|
* @param {string} name
|
|
* @param {string} desc
|
|
* @param {string} initialValue
|
|
* @param {StringTypedConfigKey} configStorageKey The SwitcherPlusSettings key where the value for this setting should be stored.
|
|
* @param {string} placeholderText?
|
|
* @returns Setting
|
|
*/
|
|
addTextSetting(containerEl, name, desc, initialValue, configStorageKey, placeholderText) {
|
|
const setting = this.createSetting(containerEl, name, desc);
|
|
setting.addText((comp) => {
|
|
comp.setPlaceholder(placeholderText);
|
|
comp.setValue(initialValue);
|
|
comp.onChange((rawValue) => {
|
|
const value = rawValue.length ? rawValue : initialValue;
|
|
this.saveChangesToConfig(configStorageKey, value);
|
|
});
|
|
});
|
|
return setting;
|
|
}
|
|
/**
|
|
* Create a Checkbox element setting.
|
|
* @param {HTMLElement} containerEl The element to attach the setting to.
|
|
* @param {string} name
|
|
* @param {string} desc
|
|
* @param {boolean} initialValue
|
|
* @param {BooleanTypedConfigKey} configStorageKey The SwitcherPlusSettings key where the value for this setting should be stored. This can safely be set to null if the onChange handler is provided.
|
|
* @param {(value:string,config:SwitcherPlusSettings)=>void} onChange? optional callback to invoke instead of using configStorageKey
|
|
* @returns Setting
|
|
*/
|
|
addToggleSetting(containerEl, name, desc, initialValue, configStorageKey, onChange) {
|
|
const setting = this.createSetting(containerEl, name, desc);
|
|
setting.addToggle((comp) => {
|
|
comp.setValue(initialValue);
|
|
comp.onChange((value) => {
|
|
if (onChange) {
|
|
onChange(value, this.config);
|
|
}
|
|
else {
|
|
this.saveChangesToConfig(configStorageKey, value);
|
|
}
|
|
});
|
|
});
|
|
return setting;
|
|
}
|
|
/**
|
|
* Create a TextArea element setting.
|
|
* @param {HTMLElement} containerEl The element to attach the setting to.
|
|
* @param {string} name
|
|
* @param {string} desc
|
|
* @param {string} initialValue
|
|
* @param {ListTypedConfigKey|StringTypedConfigKey} configStorageKey The SwitcherPlusSettings key where the value for this setting should be stored.
|
|
* @param {string} placeholderText?
|
|
* @returns Setting
|
|
*/
|
|
addTextAreaSetting(containerEl, name, desc, initialValue, configStorageKey, placeholderText) {
|
|
const setting = this.createSetting(containerEl, name, desc);
|
|
setting.addTextArea((comp) => {
|
|
comp.setPlaceholder(placeholderText);
|
|
comp.setValue(initialValue);
|
|
comp.onChange((rawValue) => {
|
|
const value = rawValue.length ? rawValue : initialValue;
|
|
const isArray = Array.isArray(this.config[configStorageKey]);
|
|
this.saveChangesToConfig(configStorageKey, isArray ? value.split('\n') : value);
|
|
});
|
|
});
|
|
return setting;
|
|
}
|
|
/**
|
|
* Add a dropdown list setting
|
|
* @param {HTMLElement} containerEl
|
|
* @param {string} name
|
|
* @param {string} desc
|
|
* @param {string} initialValue option value that is initially selected
|
|
* @param {Record<string, string>} options
|
|
* @param {StringTypedConfigKey} configStorageKey The SwitcherPlusSettings key where the value for this setting should be stored. This can safely be set to null if the onChange handler is provided.
|
|
* @param {(rawValue:string,config:SwitcherPlusSettings)=>void} onChange? optional callback to invoke instead of using configStorageKey
|
|
* @returns Setting
|
|
*/
|
|
addDropdownSetting(containerEl, name, desc, initialValue, options, configStorageKey, onChange) {
|
|
const setting = this.createSetting(containerEl, name, desc);
|
|
setting.addDropdown((comp) => {
|
|
comp.addOptions(options);
|
|
comp.setValue(initialValue);
|
|
comp.onChange((rawValue) => {
|
|
if (onChange) {
|
|
onChange(rawValue, this.config);
|
|
}
|
|
else {
|
|
this.saveChangesToConfig(configStorageKey, rawValue);
|
|
}
|
|
});
|
|
});
|
|
return setting;
|
|
}
|
|
addSliderSetting(containerEl, name, desc, initialValue, limits, configStorageKey, onChange) {
|
|
const setting = this.createSetting(containerEl, name, desc);
|
|
// display a button to reset the slider value
|
|
setting.addExtraButton((comp) => {
|
|
comp.setIcon('lucide-rotate-ccw');
|
|
comp.setTooltip('Restore default');
|
|
comp.onClick(() => setting.components[1].setValue(0));
|
|
return comp;
|
|
});
|
|
setting.addSlider((comp) => {
|
|
comp.setLimits(limits[0], limits[1], limits[2]);
|
|
comp.setValue(initialValue);
|
|
comp.setDynamicTooltip();
|
|
comp.onChange((value) => {
|
|
if (onChange) {
|
|
onChange(value, this.config);
|
|
}
|
|
else {
|
|
this.saveChangesToConfig(configStorageKey, value);
|
|
}
|
|
});
|
|
});
|
|
return setting;
|
|
}
|
|
/**
|
|
* Updates the internal SwitcherPlusSettings configStorageKey with value, and writes it to disk.
|
|
* @param {K} configStorageKey The SwitcherPlusSettings key where the value for this setting should be stored.
|
|
* @param {SwitcherPlusSettings[K]} value
|
|
* @returns void
|
|
*/
|
|
saveChangesToConfig(configStorageKey, value) {
|
|
if (configStorageKey) {
|
|
const { config } = this;
|
|
config[configStorageKey] = value;
|
|
config.save();
|
|
}
|
|
}
|
|
}
|
|
|
|
class BookmarksSettingsTabSection extends SettingsTabSection {
|
|
display(containerEl) {
|
|
const { config } = this;
|
|
this.addSectionTitle(containerEl, 'Bookmarks List Mode Settings');
|
|
this.addTextSetting(containerEl, 'Bookmarks list mode trigger', 'Character that will trigger bookmarks list mode in the switcher', config.bookmarksListCommand, 'bookmarksListCommand', config.bookmarksListPlaceholderText);
|
|
}
|
|
}
|
|
|
|
class CommandListSettingsTabSection extends SettingsTabSection {
|
|
display(containerEl) {
|
|
const { config } = this;
|
|
this.addSectionTitle(containerEl, 'Command List Mode Settings');
|
|
this.addTextSetting(containerEl, 'Command list mode trigger', 'Character that will trigger command list mode in the switcher', config.commandListCommand, 'commandListCommand', config.commandListPlaceholderText);
|
|
}
|
|
}
|
|
|
|
class RelatedItemsSettingsTabSection extends SettingsTabSection {
|
|
display(containerEl) {
|
|
const { config } = this;
|
|
this.addSectionTitle(containerEl, 'Related Items List Mode Settings');
|
|
this.addTextSetting(containerEl, 'Related Items list mode trigger', 'Character that will trigger related items list mode in the switcher. This triggers a display of Related Items for the source file of the currently selected (highlighted) suggestion in the switcher. If there is not a suggestion, display results for the active editor.', config.relatedItemsListCommand, 'relatedItemsListCommand', config.relatedItemsListPlaceholderText);
|
|
this.addTextSetting(containerEl, 'Related Items list mode trigger - Active editor only', 'Character that will trigger related items list mode in the switcher. This always triggers a display of Related Items for the active editor only.', config.relatedItemsListActiveEditorCommand, 'relatedItemsListActiveEditorCommand', config.relatedItemsListActiveEditorCommand);
|
|
this.showEnabledRelatedItems(containerEl, config);
|
|
this.addToggleSetting(containerEl, 'Exclude open files', 'Enable, related files which are already open will not be displayed in the list. Disabled, All related files will be displayed in the list.', config.excludeOpenRelatedFiles, 'excludeOpenRelatedFiles');
|
|
}
|
|
showEnabledRelatedItems(containerEl, config) {
|
|
const relationTypes = Object.values(RelationType).sort();
|
|
const relationTypesStr = relationTypes.join(', ');
|
|
const desc = `The types of related items to show in the list. Add one type per line. Available types: ${relationTypesStr}`;
|
|
this.createSetting(containerEl, 'Show related item types', desc).addTextArea((textArea) => {
|
|
textArea.setValue(config.enabledRelatedItems.join('\n'));
|
|
textArea.inputEl.addEventListener('focusout', () => {
|
|
const values = textArea
|
|
.getValue()
|
|
.split('\n')
|
|
.map((v) => v.trim())
|
|
.filter((v) => v.length > 0);
|
|
const invalidValues = [...new Set(values)].filter((v) => !relationTypes.includes(v));
|
|
if (invalidValues?.length) {
|
|
this.showErrorPopup(invalidValues.join('<br/>'), relationTypesStr);
|
|
}
|
|
else {
|
|
config.enabledRelatedItems = values;
|
|
config.save();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
showErrorPopup(invalidTypes, relationTypes) {
|
|
const popup = new obsidian.Modal(this.app);
|
|
popup.titleEl.setText('Invalid related item type');
|
|
popup.contentEl.innerHTML = `Changes not saved. Available relation types are: ${relationTypes}. The following types are invalid:<br/><br/>${invalidTypes}`;
|
|
popup.open();
|
|
}
|
|
}
|
|
|
|
class GeneralSettingsTabSection extends SettingsTabSection {
|
|
display(containerEl) {
|
|
const { config } = this;
|
|
this.addSectionTitle(containerEl, 'General Settings');
|
|
this.showEnabledRibbonCommands(containerEl, config);
|
|
this.showPreferredSourceForTitle(containerEl, config);
|
|
this.showPathDisplayFormat(containerEl, config);
|
|
this.addToggleSetting(containerEl, 'Hide path for root items', 'When enabled, path information will be hidden for items at the root of the vault.', config.hidePathIfRoot, 'hidePathIfRoot').setClass('qsp-setting-item-indent');
|
|
this.addTextSetting(containerEl, 'Mode trigger escape character', 'Character to indicate that a mode trigger character should be treated just as a normal text.', config.escapeCmdChar, 'escapeCmdChar');
|
|
this.addToggleSetting(containerEl, 'Default to open in new tab', 'When enabled, navigating to un-opened files will open a new editor tab whenever possible (as if cmd/ctrl were held). When the file is already open, the existing tab will be activated. This overrides all other tab settings.', config.onOpenPreferNewTab, 'onOpenPreferNewTab');
|
|
this.addToggleSetting(containerEl, 'Override Standard mode behavior', 'When enabled, Switcher++ will change the default Obsidian builtin Switcher functionality (Standard mode) to inject custom behavior.', config.overrideStandardModeBehaviors, 'overrideStandardModeBehaviors');
|
|
this.addToggleSetting(containerEl, 'Show indicator icons', 'Display icons to indicate that an item is recent, bookmarked, etc..', config.showOptionalIndicatorIcons, 'showOptionalIndicatorIcons');
|
|
this.addToggleSetting(containerEl, 'Allow Backspace key to close the Switcher', 'When the search box is empty, pressing the backspace key will close Switcher++.', config.shouldCloseModalOnBackspace, 'shouldCloseModalOnBackspace');
|
|
this.showMatchPriorityAdjustments(containerEl, config);
|
|
this.showInsertLinkInEditor(containerEl, config);
|
|
this.addToggleSetting(containerEl, 'Restore previous input in Command Mode', 'When enabled, restore the last typed input in Command Mode when launched via global command hotkey.', config.preserveCommandPaletteLastInput, 'preserveCommandPaletteLastInput');
|
|
this.addToggleSetting(containerEl, 'Restore previous input', 'When enabled, restore the last typed input when launched via global command hotkey.', config.preserveQuickSwitcherLastInput, 'preserveQuickSwitcherLastInput');
|
|
this.showResetFacetEachSession(containerEl, config);
|
|
}
|
|
showPreferredSourceForTitle(containerEl, config) {
|
|
const options = {
|
|
H1: 'First H₁ heading',
|
|
Default: 'Default',
|
|
};
|
|
this.addDropdownSetting(containerEl, 'Preferred suggestion title source', 'The preferred source to use for the "title" text that will be searched and displayed for file based suggestions', config.preferredSourceForTitle, options, 'preferredSourceForTitle');
|
|
}
|
|
showPathDisplayFormat(containerEl, config) {
|
|
const options = {};
|
|
options[PathDisplayFormat.None.toString()] = 'Hide path';
|
|
options[PathDisplayFormat.Full.toString()] = 'Full path';
|
|
options[PathDisplayFormat.FolderOnly.toString()] = 'Only parent folder';
|
|
options[PathDisplayFormat.FolderWithFilename.toString()] = 'Parent folder & filename';
|
|
options[PathDisplayFormat.FolderPathFilenameOptional.toString()] =
|
|
'Parent folder path (filename optional)';
|
|
this.addDropdownSetting(containerEl, 'Preferred file path display format', 'The preferred way to display file paths in suggestions', config.pathDisplayFormat.toString(), options, null, (rawValue, config) => {
|
|
config.pathDisplayFormat = Number(rawValue);
|
|
config.save();
|
|
});
|
|
}
|
|
showEnabledRibbonCommands(containerEl, config) {
|
|
const modeNames = Object.values(Mode)
|
|
.filter((v) => isNaN(Number(v)))
|
|
.sort();
|
|
const modeNamesStr = modeNames.join(' ');
|
|
const desc = `Display an icon in the ribbon menu to launch specific modes. Add one mode per line. Available modes: ${modeNamesStr}`;
|
|
this.createSetting(containerEl, 'Show ribbon icons', desc).addTextArea((textArea) => {
|
|
textArea.setValue(config.enabledRibbonCommands.join('\n'));
|
|
textArea.inputEl.addEventListener('focusout', () => {
|
|
const values = textArea
|
|
.getValue()
|
|
.split('\n')
|
|
.map((v) => v.trim())
|
|
.filter((v) => v.length > 0);
|
|
const invalidValues = Array.from(new Set(values)).filter((v) => !modeNames.includes(v));
|
|
if (invalidValues.length) {
|
|
this.showErrorPopup(invalidValues.join('<br/>'), modeNamesStr);
|
|
}
|
|
else {
|
|
config.enabledRibbonCommands = values;
|
|
config.save();
|
|
// force unregister/register of ribbon commands, so the changes take
|
|
// effect immediately
|
|
this.mainSettingsTab.plugin.registerRibbonCommandIcons();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
showErrorPopup(invalidValues, validModes) {
|
|
const popup = new obsidian.Modal(this.app);
|
|
popup.titleEl.setText('Invalid mode');
|
|
popup.contentEl.innerHTML = `Changes not saved. Available modes are: ${validModes}. The following are invalid:<br/><br/>${invalidValues}`;
|
|
popup.open();
|
|
}
|
|
showMatchPriorityAdjustments(containerEl, config) {
|
|
const { matchPriorityAdjustments: { isEnabled, adjustments, fileExtAdjustments }, } = config;
|
|
this.addToggleSetting(containerEl, 'Result priority adjustments', 'Artificially increase the match score of the specified item types by a fixed percentage so they appear higher in the results list', isEnabled, null, (isEnabled, config) => {
|
|
config.matchPriorityAdjustments.isEnabled = isEnabled;
|
|
// have to wait for the save here because the call to display() will
|
|
// trigger a read of the updated data
|
|
config.saveSettings().then(() => {
|
|
// reload the settings panel. This will cause the matchPriorityAdjustments
|
|
// controls to be shown/hidden based on isEnabled status
|
|
this.mainSettingsTab.display();
|
|
}, (reason) => console.log('Switcher++: error saving "Result Priority Adjustments" setting. ', reason));
|
|
});
|
|
if (isEnabled) {
|
|
[adjustments, fileExtAdjustments].forEach((collection) => {
|
|
Object.entries(collection).forEach(([key, data]) => {
|
|
const { value, label } = data;
|
|
const setting = this.addSliderSetting(containerEl, label, data.desc ?? '', value, [-1, 1, 0.05], null, (value, config) => {
|
|
collection[key].value = value;
|
|
config.save();
|
|
});
|
|
setting.setClass('qsp-setting-item-indent');
|
|
});
|
|
});
|
|
}
|
|
}
|
|
showResetFacetEachSession(containerEl, config) {
|
|
this.addToggleSetting(containerEl, 'Reset active Quick Filters', 'When enabled, the switcher will reset all Quick Filters back to inactive for each session.', config.quickFilters.shouldResetActiveFacets, null, (value, config) => {
|
|
config.quickFilters.shouldResetActiveFacets = value;
|
|
config.save();
|
|
});
|
|
}
|
|
showInsertLinkInEditor(containerEl, config) {
|
|
this.createSetting(containerEl, 'Insert link in editor', '');
|
|
let setting = this.addToggleSetting(containerEl, 'Use filename as alias', 'When enabled, the file basename will be set as the link alias.', config.insertLinkInEditor.useBasenameAsAlias, null, (value, config) => {
|
|
config.insertLinkInEditor.useBasenameAsAlias = value;
|
|
config.save();
|
|
});
|
|
setting.setClass('qsp-setting-item-indent');
|
|
setting = this.addToggleSetting(containerEl, 'Use heading as alias', 'When enabled, the file heading will be set as the link alias. This overrides the "use filename as alias" setting.', config.insertLinkInEditor.useHeadingAsAlias, null, (value, config) => {
|
|
config.insertLinkInEditor.useHeadingAsAlias = value;
|
|
config.save();
|
|
});
|
|
setting.setClass('qsp-setting-item-indent');
|
|
}
|
|
}
|
|
|
|
class WorkspaceSettingsTabSection extends SettingsTabSection {
|
|
display(containerEl) {
|
|
const { config } = this;
|
|
this.addSectionTitle(containerEl, 'Workspace List Mode Settings');
|
|
this.addTextSetting(containerEl, 'Workspace list mode trigger', 'Character that will trigger workspace list mode in the switcher', config.workspaceListCommand, 'workspaceListCommand', config.workspaceListPlaceholderText);
|
|
}
|
|
}
|
|
|
|
class EditorSettingsTabSection extends SettingsTabSection {
|
|
display(containerEl) {
|
|
const { config } = this;
|
|
this.addSectionTitle(containerEl, 'Editor List Mode Settings');
|
|
this.addTextSetting(containerEl, 'Editor list mode trigger', 'Character that will trigger editor list mode in the switcher', config.editorListCommand, 'editorListCommand', config.editorListPlaceholderText);
|
|
this.showIncludeSidePanelViews(containerEl, config);
|
|
this.addToggleSetting(containerEl, 'Order default editor list by most recently accessed', 'When there is no search term, order the list of editors by most recent access time.', config.orderEditorListByAccessTime, 'orderEditorListByAccessTime');
|
|
}
|
|
showIncludeSidePanelViews(containerEl, config) {
|
|
const viewsListing = Object.keys(this.app.viewRegistry.viewByType).sort().join(' ');
|
|
const desc = `When in Editor list mode, show the following view types from the side panels. Add one view type per line. Available view types: ${viewsListing}`;
|
|
this.addTextAreaSetting(containerEl, 'Include side panel views', desc, config.includeSidePanelViewTypes.join('\n'), 'includeSidePanelViewTypes', config.includeSidePanelViewTypesPlaceholder);
|
|
}
|
|
}
|
|
|
|
class HeadingsSettingsTabSection extends SettingsTabSection {
|
|
display(containerEl) {
|
|
const { config } = this;
|
|
this.addSectionTitle(containerEl, 'Headings List Mode Settings');
|
|
this.addTextSetting(containerEl, 'Headings list mode trigger', 'Character that will trigger headings list mode in the switcher', config.headingsListCommand, 'headingsListCommand', config.headingsListPlaceholderText);
|
|
this.addToggleSetting(containerEl, 'Show headings only', 'Enabled, strictly search through only the headings contained in the file. Note: this setting overrides the "Show existing only", and "Search filenames" settings. Disabled, fallback to searching against the filename when there is not a match in the first H1 contained in the file. This will also allow searching through filenames, Aliases, and Unresolved links to be enabled.', config.strictHeadingsOnly, 'strictHeadingsOnly');
|
|
this.addToggleSetting(containerEl, 'Search all headings', 'Enabled, search through all headings contained in each file. Disabled, only search through the first H1 in each file.', config.searchAllHeadings, 'searchAllHeadings');
|
|
this.addToggleSetting(containerEl, 'Search filenames', "Enabled, search and show suggestions for filenames. Disabled, Don't search through filenames (except for fallback searches)", config.shouldSearchFilenames, 'shouldSearchFilenames');
|
|
this.addToggleSetting(containerEl, 'Search Bookmarks', "Enabled, search and show suggestions for Boomarks. Disabled, Don't search through Bookmarks", config.shouldSearchBookmarks, 'shouldSearchBookmarks');
|
|
this.addSliderSetting(containerEl, 'Max recent files to show', 'The maximum number of recent files to show when there is no search term', config.maxRecentFileSuggestionsOnInit, [0, 75, 1], 'maxRecentFileSuggestionsOnInit');
|
|
this.showExcludeFolders(containerEl, config);
|
|
this.addToggleSetting(containerEl, 'Hide Obsidian "Excluded files"', 'Enabled, do not display suggestions for files that are in Obsidian\'s "Options > Files & Links > Excluded files" list. Disabled, suggestions for those files will be displayed but downranked.', config.excludeObsidianIgnoredFiles, 'excludeObsidianIgnoredFiles');
|
|
this.showFileExtAllowList(containerEl, config);
|
|
}
|
|
showFileExtAllowList(containerEl, config) {
|
|
this.createSetting(containerEl, 'File extension override', 'Override the "Show attachments" and the "Show all file types" builtin, system Switcher settings and always search files with the listed extensions. Add one path per line. For example to add ".canvas" file extension, just add "canvas".').addTextArea((textArea) => {
|
|
textArea.setValue(config.fileExtAllowList.join('\n'));
|
|
textArea.inputEl.addEventListener('focusout', () => {
|
|
const allowList = textArea
|
|
.getValue()
|
|
.split('\n')
|
|
.map((v) => v.trim())
|
|
.filter((v) => v.length > 0);
|
|
config.fileExtAllowList = allowList;
|
|
config.save();
|
|
});
|
|
});
|
|
}
|
|
showExcludeFolders(containerEl, config) {
|
|
const settingName = 'Exclude folders';
|
|
this.createSetting(containerEl, settingName, 'When in Headings list mode, folder path that match any regex listed here will not be searched for suggestions. Path should start from the Vault Root. Add one path per line.').addTextArea((textArea) => {
|
|
textArea.setValue(config.excludeFolders.join('\n'));
|
|
textArea.inputEl.addEventListener('focusout', () => {
|
|
const excludes = textArea
|
|
.getValue()
|
|
.split('\n')
|
|
.filter((v) => v.length > 0);
|
|
if (this.validateExcludeFolderList(settingName, excludes)) {
|
|
config.excludeFolders = excludes;
|
|
config.save();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
validateExcludeFolderList(settingName, excludes) {
|
|
let isValid = true;
|
|
let failedMsg = '';
|
|
for (const str of excludes) {
|
|
try {
|
|
new RegExp(str);
|
|
}
|
|
catch (err) {
|
|
// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
|
|
failedMsg += `<span class="qsp-warning">${str}</span><br/>${err}<br/><br/>`;
|
|
isValid = false;
|
|
}
|
|
}
|
|
if (!isValid) {
|
|
const popup = new obsidian.Modal(this.app);
|
|
popup.titleEl.setText(settingName);
|
|
popup.contentEl.innerHTML = `Changes not saved. The following regex contain errors:<br/><br/>${failedMsg}`;
|
|
popup.open();
|
|
}
|
|
return isValid;
|
|
}
|
|
}
|
|
|
|
class SymbolSettingsTabSection extends SettingsTabSection {
|
|
display(containerEl) {
|
|
const { config } = this;
|
|
this.addSectionTitle(containerEl, 'Symbol List Mode Settings');
|
|
this.addTextSetting(containerEl, 'Symbol list mode trigger', 'Character that will trigger symbol list mode in the switcher. This triggers a display of Symbols for the source file of the currently selected (highlighted) suggestion in the switcher. If there is not a suggestion, display results for the active editor.', config.symbolListCommand, 'symbolListCommand', config.symbolListPlaceholderText);
|
|
this.addTextSetting(containerEl, 'Symbol list mode trigger - Active editor only', 'Character that will trigger symbol list mode in the switcher. This always triggers a display of Symbols for the active editor only.', config.symbolListActiveEditorCommand, 'symbolListActiveEditorCommand', config.symbolListActiveEditorCommand);
|
|
this.addToggleSetting(containerEl, 'List symbols as indented outline', 'Enabled, symbols will be displayed in the (line) order they appear in the source text, indented under any preceding heading. Disabled, symbols will be grouped by type: Headings, Tags, Links, Embeds.', config.symbolsInLineOrder, 'symbolsInLineOrder');
|
|
this.addToggleSetting(containerEl, 'Open Symbols in new tab', 'Enabled, always open a new tab when navigating to Symbols. Disabled, navigate in an already open tab (if one exists).', config.alwaysNewTabForSymbols, 'alwaysNewTabForSymbols');
|
|
this.addToggleSetting(containerEl, 'Open Symbols in active tab on mobile devices', 'Enabled, navigate to the target file and symbol in the active editor tab. Disabled, open a new tab when navigating to Symbols, even on mobile devices.', config.useActiveTabForSymbolsOnMobile, 'useActiveTabForSymbolsOnMobile');
|
|
this.addToggleSetting(containerEl, 'Auto-select nearest heading', 'Enabled, in an unfiltered symbol list, select the closest preceding Heading to the current cursor position. Disabled, the first symbol in the list is selected.', config.selectNearestHeading, 'selectNearestHeading');
|
|
this.showEnableSymbolTypesToggle(containerEl, config);
|
|
this.showEnableLinksToggle(containerEl, config);
|
|
}
|
|
showEnableSymbolTypesToggle(containerEl, config) {
|
|
const allowedSymbols = [
|
|
['Show Headings', SymbolType.Heading],
|
|
['Show Tags', SymbolType.Tag],
|
|
['Show Embeds', SymbolType.Embed],
|
|
['Show Callouts', SymbolType.Callout],
|
|
];
|
|
allowedSymbols.forEach(([name, symbolType]) => {
|
|
this.addToggleSetting(containerEl, name, '', config.isSymbolTypeEnabled(symbolType), null, (isEnabled) => {
|
|
config.setSymbolTypeEnabled(symbolType, isEnabled);
|
|
config.save();
|
|
});
|
|
});
|
|
}
|
|
showEnableLinksToggle(containerEl, config) {
|
|
const isLinksEnabled = config.isSymbolTypeEnabled(SymbolType.Link);
|
|
this.addToggleSetting(containerEl, 'Show Links', '', isLinksEnabled, null, (isEnabled) => {
|
|
config.setSymbolTypeEnabled(SymbolType.Link, isEnabled);
|
|
// have to wait for the save here because the call to display() will
|
|
// trigger a read of the updated data
|
|
config.saveSettings().then(() => {
|
|
// reload the settings panel. This will cause the sublink types toggle
|
|
// controls to be shown/hidden based on isLinksEnabled status
|
|
this.mainSettingsTab.display();
|
|
}, (reason) => console.log('Switcher++: error saving "Show Links" setting. ', reason));
|
|
});
|
|
if (isLinksEnabled) {
|
|
const allowedLinkTypes = [
|
|
['Links to headings', LinkType.Heading],
|
|
['Links to blocks', LinkType.Block],
|
|
];
|
|
allowedLinkTypes.forEach(([name, linkType]) => {
|
|
const isExcluded = (config.excludeLinkSubTypes & linkType) === linkType;
|
|
const setting = this.addToggleSetting(containerEl, name, '', !isExcluded, null, (isEnabled) => this.saveEnableSubLinkChange(linkType, isEnabled));
|
|
setting.setClass('qsp-setting-item-indent');
|
|
});
|
|
}
|
|
}
|
|
saveEnableSubLinkChange(linkType, isEnabled) {
|
|
const { config } = this;
|
|
let exclusions = config.excludeLinkSubTypes;
|
|
if (isEnabled) {
|
|
// remove from exclusion list
|
|
exclusions &= ~linkType;
|
|
}
|
|
else {
|
|
// add to exclusion list
|
|
exclusions |= linkType;
|
|
}
|
|
config.excludeLinkSubTypes = exclusions;
|
|
config.save();
|
|
}
|
|
}
|
|
|
|
class VaultListSettingsTabSection extends SettingsTabSection {
|
|
display(containerEl) {
|
|
const { config } = this;
|
|
const titleSetting = this.addSectionTitle(containerEl, 'Vault List Mode Settings');
|
|
titleSetting.nameEl?.createSpan({
|
|
cls: ['qsp-tag', 'qsp-warning'],
|
|
text: 'Experimental',
|
|
});
|
|
this.addTextSetting(containerEl, 'Vault list mode trigger', 'Character that will trigger vault list mode in the switcher', config.vaultListCommand, 'vaultListCommand', config.vaultListPlaceholderText);
|
|
}
|
|
}
|
|
|
|
class SwitcherPlusSettingTab extends obsidian.PluginSettingTab {
|
|
constructor(app, plugin, config) {
|
|
super(app, plugin);
|
|
this.plugin = plugin;
|
|
this.config = config;
|
|
}
|
|
display() {
|
|
const { containerEl } = this;
|
|
const tabSections = [
|
|
GeneralSettingsTabSection,
|
|
SymbolSettingsTabSection,
|
|
HeadingsSettingsTabSection,
|
|
EditorSettingsTabSection,
|
|
RelatedItemsSettingsTabSection,
|
|
BookmarksSettingsTabSection,
|
|
CommandListSettingsTabSection,
|
|
WorkspaceSettingsTabSection,
|
|
VaultListSettingsTabSection,
|
|
];
|
|
containerEl.empty();
|
|
containerEl.createEl('h2', { text: 'Quick Switcher++ Settings' });
|
|
tabSections.forEach((tabSectionClass) => {
|
|
this.displayTabSection(tabSectionClass);
|
|
});
|
|
}
|
|
displayTabSection(tabSectionClass) {
|
|
const { app, config, containerEl } = this;
|
|
const tabSection = new tabSectionClass(app, this, config);
|
|
tabSection.display(containerEl);
|
|
}
|
|
}
|
|
|
|
class InputInfo {
|
|
static get defaultParsedCommand() {
|
|
return {
|
|
isValidated: false,
|
|
index: -1,
|
|
parsedInput: null,
|
|
};
|
|
}
|
|
get searchQuery() {
|
|
return this._searchQuery;
|
|
}
|
|
get inputTextSansEscapeChar() {
|
|
return this._inputTextSansEscapeChar ?? this.inputText;
|
|
}
|
|
set inputTextSansEscapeChar(value) {
|
|
this._inputTextSansEscapeChar = value;
|
|
}
|
|
constructor(inputText = '', mode = Mode.Standard, sessionOpts) {
|
|
this.inputText = inputText;
|
|
this.mode = mode;
|
|
this._inputTextSansEscapeChar = null;
|
|
this.currentWorkspaceEnvList = {
|
|
openWorkspaceLeaves: new Set(),
|
|
openWorkspaceFiles: new Set(),
|
|
fileBookmarks: new Map(),
|
|
nonFileBookmarks: new Set(),
|
|
mostRecentFiles: new Set(),
|
|
attachmentFileExtensions: new Set(),
|
|
};
|
|
this.sessionOpts = sessionOpts ?? {};
|
|
const symbolListCmd = {
|
|
...InputInfo.defaultParsedCommand,
|
|
source: null,
|
|
};
|
|
const relatedItemsListCmd = {
|
|
...InputInfo.defaultParsedCommand,
|
|
source: null,
|
|
};
|
|
const parsedCmds = {};
|
|
this.parsedCommands = parsedCmds;
|
|
parsedCmds[Mode.SymbolList] = symbolListCmd;
|
|
parsedCmds[Mode.RelatedItemsList] = relatedItemsListCmd;
|
|
[
|
|
Mode.Standard,
|
|
Mode.EditorList,
|
|
Mode.WorkspaceList,
|
|
Mode.HeadingsList,
|
|
Mode.BookmarksList,
|
|
Mode.CommandList,
|
|
Mode.VaultList,
|
|
].forEach((mode) => {
|
|
parsedCmds[mode] = InputInfo.defaultParsedCommand;
|
|
});
|
|
}
|
|
buildSearchQuery() {
|
|
const { mode } = this;
|
|
const input = this.parsedCommands[mode].parsedInput ?? '';
|
|
const prepQuery = obsidian.prepareQuery(input.trim().toLowerCase());
|
|
const hasSearchTerm = prepQuery?.query?.length > 0;
|
|
this._searchQuery = { prepQuery, hasSearchTerm };
|
|
}
|
|
parsedCommand(mode) {
|
|
mode = mode ?? this.mode;
|
|
return this.parsedCommands[mode];
|
|
}
|
|
}
|
|
|
|
class Handler {
|
|
constructor(app, settings) {
|
|
this.app = app;
|
|
this.settings = settings;
|
|
}
|
|
reset() {
|
|
/* noop */
|
|
}
|
|
onNoResultsCreateAction(_inputInfo, _evt) {
|
|
return false;
|
|
}
|
|
getFacets(mode) {
|
|
if (!this.facets) {
|
|
const facetList = this.settings?.quickFilters?.facetList;
|
|
if (facetList) {
|
|
this.facets = Object.values(facetList).filter((facet) => facet.mode === mode);
|
|
}
|
|
}
|
|
return this.facets ?? [];
|
|
}
|
|
getAvailableFacets(inputInfo) {
|
|
return this.getFacets(inputInfo.mode).filter((v) => v.isAvailable);
|
|
}
|
|
activateFacet(facets, isActive) {
|
|
facets.forEach((v) => (v.isActive = isActive));
|
|
if (!this.settings.quickFilters.shouldResetActiveFacets) {
|
|
this.settings.save();
|
|
}
|
|
}
|
|
getActiveFacetIds(inputInfo) {
|
|
const facetIds = this.getAvailableFacets(inputInfo)
|
|
.filter((v) => v.isActive)
|
|
.map((v) => v.id);
|
|
return new Set(facetIds);
|
|
}
|
|
isFacetedWith(activeFacetIds, facetId) {
|
|
const hasActiveFacets = !!activeFacetIds.size;
|
|
return (hasActiveFacets && activeFacetIds.has(facetId)) || !hasActiveFacets;
|
|
}
|
|
getEditorInfo(leaf) {
|
|
const { excludeViewTypes } = this.settings;
|
|
let file = null;
|
|
let isValidSource = false;
|
|
let cursor = null;
|
|
if (leaf) {
|
|
const { view } = leaf;
|
|
const viewType = view.getViewType();
|
|
file = view.file;
|
|
cursor = this.getCursorPosition(view);
|
|
// determine if the current active editor pane is valid
|
|
const isCurrentEditorValid = !excludeViewTypes.includes(viewType);
|
|
// whether or not the current active editor can be used as the target for
|
|
// symbol search
|
|
isValidSource = isCurrentEditorValid && !!file;
|
|
}
|
|
return { isValidSource, leaf, file, suggestion: null, cursor };
|
|
}
|
|
getSuggestionInfo(suggestion) {
|
|
const info = this.getSourceInfoFromSuggestion(suggestion);
|
|
let leaf = info.leaf;
|
|
if (info.isValidSource) {
|
|
// try to find a matching leaf for suggestion types that don't explicitly
|
|
// provide one. This is primarily needed to be able to focus an
|
|
// existing pane if there is one
|
|
({ leaf } = this.findMatchingLeaf(info.file, info.leaf));
|
|
}
|
|
// Get the cursor information to support `selectNearestHeading`
|
|
const cursor = this.getCursorPosition(leaf?.view);
|
|
return { ...info, leaf, cursor };
|
|
}
|
|
getSourceInfoFromSuggestion(suggestion) {
|
|
let file = null;
|
|
let leaf = null;
|
|
// Can't use these suggestions as the target for another symbol command,
|
|
// because they don't point to a file
|
|
const invalidTypes = [
|
|
SuggestionType.SymbolList,
|
|
SuggestionType.Unresolved,
|
|
SuggestionType.WorkspaceList,
|
|
SuggestionType.CommandList,
|
|
SuggestionType.VaultList,
|
|
];
|
|
const isFileBasedSuggestion = suggestion && !invalidTypes.includes(suggestion.type);
|
|
if (isFileBasedSuggestion) {
|
|
file = suggestion.file;
|
|
}
|
|
if (isEditorSuggestion(suggestion)) {
|
|
leaf = suggestion.item;
|
|
}
|
|
const isValidSource = !!file;
|
|
return { isValidSource, leaf, file, suggestion };
|
|
}
|
|
/**
|
|
* Retrieves the position of the cursor, given that view is in a Mode that supports cursors.
|
|
* @param {View} view
|
|
* @returns EditorPosition
|
|
*/
|
|
getCursorPosition(view) {
|
|
let cursor = null;
|
|
if (view?.getViewType() === 'markdown') {
|
|
const md = view;
|
|
if (md.getMode() !== 'preview') {
|
|
const { editor } = md;
|
|
cursor = editor.getCursor('head');
|
|
}
|
|
}
|
|
return cursor;
|
|
}
|
|
/**
|
|
* Returns the text of the first H1 contained in sourceFile, or sourceFile
|
|
* path if an H1 does not exist
|
|
* @param {TFile} sourceFile
|
|
* @returns string
|
|
*/
|
|
getTitleText(sourceFile) {
|
|
const path = stripMDExtensionFromPath(sourceFile);
|
|
const h1 = this.getFirstH1(sourceFile);
|
|
return h1?.heading ?? path;
|
|
}
|
|
/**
|
|
* Finds and returns the first H1 from sourceFile
|
|
* @param {TFile} sourceFile
|
|
* @returns HeadingCache
|
|
*/
|
|
getFirstH1(sourceFile) {
|
|
return Handler.getFirstH1(sourceFile, this.app.metadataCache);
|
|
}
|
|
static getFirstH1(sourceFile, metadataCache) {
|
|
let h1 = null;
|
|
const headingList = metadataCache.getFileCache(sourceFile)?.headings?.filter((v) => v.level === 1) ??
|
|
[];
|
|
if (headingList.length) {
|
|
h1 = headingList.reduce((acc, curr) => {
|
|
const { line: currLine } = curr.position.start;
|
|
const accLine = acc.position.start.line;
|
|
return currLine < accLine ? curr : acc;
|
|
});
|
|
}
|
|
return h1;
|
|
}
|
|
/**
|
|
* Finds the first open WorkspaceLeaf that is showing source file.
|
|
* @param {TFile} file The source file that is being shown to find
|
|
* @param {WorkspaceLeaf} leaf An already open editor, or, a 'reference' WorkspaceLeaf (example: backlinks, outline, etc.. views) that is used to find the associated editor if one exists.
|
|
* @param {} shouldIncludeRefViews=false set to true to make reference view types valid return candidates.
|
|
* @returns TargetInfo
|
|
*/
|
|
findMatchingLeaf(file, leaf, shouldIncludeRefViews = false) {
|
|
let matchingLeaf = null;
|
|
const hasSourceLeaf = !!leaf;
|
|
const { settings: { referenceViews, excludeViewTypes, includeSidePanelViewTypes }, } = this;
|
|
const isMatch = (candidateLeaf) => {
|
|
let val = false;
|
|
if (candidateLeaf?.view) {
|
|
const isCandidateRefView = referenceViews.includes(candidateLeaf.view.getViewType());
|
|
const isValidCandidate = shouldIncludeRefViews || !isCandidateRefView;
|
|
const isSourceRefView = hasSourceLeaf && referenceViews.includes(leaf.view.getViewType());
|
|
if (isValidCandidate) {
|
|
if (hasSourceLeaf && (shouldIncludeRefViews || !isSourceRefView)) {
|
|
val = candidateLeaf === leaf;
|
|
}
|
|
else {
|
|
val = candidateLeaf.view.file === file;
|
|
}
|
|
}
|
|
}
|
|
return val;
|
|
};
|
|
// Prioritize the active leaf matches first, otherwise find the first matching leaf
|
|
const activeLeaf = this.getActiveLeaf();
|
|
if (isMatch(activeLeaf)) {
|
|
matchingLeaf = activeLeaf;
|
|
}
|
|
else {
|
|
const leaves = this.getOpenLeaves(excludeViewTypes, includeSidePanelViewTypes);
|
|
// put leaf at the first index so it gets checked first
|
|
matchingLeaf = [leaf, ...leaves].find(isMatch);
|
|
}
|
|
return {
|
|
leaf: matchingLeaf ?? null,
|
|
file,
|
|
suggestion: null,
|
|
isValidSource: false,
|
|
};
|
|
}
|
|
/** Determines if an existing tab should be reused, or create new tab, or create new window based on evt and taking into account user preferences
|
|
* @param {MouseEvent|KeyboardEvent} evt
|
|
* @param {boolean} isAlreadyOpen?
|
|
* @param {Mode} mode? Only Symbol mode has special handling.
|
|
* @returns {navType: boolean | PaneType; splitDirection: SplitDirection}
|
|
*/
|
|
extractTabNavigationType(evt, isAlreadyOpen, mode) {
|
|
const splitDirection = evt?.shiftKey ? 'horizontal' : 'vertical';
|
|
const key = evt?.key;
|
|
let navType = obsidian.Keymap.isModEvent(evt) ?? false;
|
|
if (navType === true || navType === 'tab') {
|
|
if (key === 'o') {
|
|
// cmd-o to create new window
|
|
navType = 'window';
|
|
}
|
|
else if (key === '\\') {
|
|
// cmd-\ to create split
|
|
navType = 'split';
|
|
}
|
|
}
|
|
navType = this.applyTabCreationPreferences(navType, isAlreadyOpen, mode);
|
|
return { navType, splitDirection };
|
|
}
|
|
/**
|
|
* Determines whether or not a new leaf should be created taking user
|
|
* settings into account
|
|
* @param {PaneType | boolean} navType
|
|
* @param {} isAlreadyOpen=false Set to true if there is a pane showing the file already
|
|
* @param {Mode} mode? Only Symbol mode has special handling.
|
|
* @returns boolean
|
|
*/
|
|
applyTabCreationPreferences(navType, isAlreadyOpen = false, mode) {
|
|
let preferredNavType = navType;
|
|
const { onOpenPreferNewTab, alwaysNewTabForSymbols, useActiveTabForSymbolsOnMobile } = this.settings;
|
|
if (navType === false) {
|
|
if (onOpenPreferNewTab) {
|
|
preferredNavType = !isAlreadyOpen;
|
|
}
|
|
else if (mode === Mode.SymbolList) {
|
|
preferredNavType = obsidian.Platform.isMobile
|
|
? !useActiveTabForSymbolsOnMobile
|
|
: alwaysNewTabForSymbols;
|
|
}
|
|
}
|
|
return preferredNavType;
|
|
}
|
|
/**
|
|
* Determines if a leaf belongs to the main editor panel (workspace.rootSplit or
|
|
* workspace.floatingSplit) as opposed to the side panels
|
|
* @param {WorkspaceLeaf} leaf
|
|
* @returns boolean
|
|
*/
|
|
isMainPanelLeaf(leaf) {
|
|
const { workspace } = this.app;
|
|
const root = leaf?.getRoot();
|
|
return root === workspace.rootSplit || root === workspace.floatingSplit;
|
|
}
|
|
/**
|
|
* Reveals and optionally bring into focus a WorkspaceLeaf, including leaves
|
|
* from the side panels.
|
|
* @param {WorkspaceLeaf} leaf
|
|
* @param {Record<string, unknown>} eState?
|
|
* @returns void
|
|
*/
|
|
activateLeaf(leaf, eState) {
|
|
const { workspace } = this.app;
|
|
const isInSidePanel = !this.isMainPanelLeaf(leaf);
|
|
const state = { focus: true, ...eState };
|
|
if (isInSidePanel) {
|
|
workspace.revealLeaf(leaf);
|
|
}
|
|
workspace.setActiveLeaf(leaf, { focus: true });
|
|
leaf.view.setEphemeralState(state);
|
|
}
|
|
/**
|
|
* Returns a array of all open WorkspaceLeaf taking into account
|
|
* excludeMainPanelViewTypes and includeSidePanelViewTypes.
|
|
* @param {string[]} excludeMainPanelViewTypes?
|
|
* @param {string[]} includeSidePanelViewTypes?
|
|
* @returns WorkspaceLeaf[]
|
|
*/
|
|
getOpenLeaves(excludeMainPanelViewTypes, includeSidePanelViewTypes, options) {
|
|
const leaves = [];
|
|
const saveLeaf = (l) => {
|
|
const viewType = l?.view?.getViewType();
|
|
if (this.isMainPanelLeaf(l)) {
|
|
if (!excludeMainPanelViewTypes?.includes(viewType)) {
|
|
leaves.push(l);
|
|
}
|
|
}
|
|
else if (includeSidePanelViewTypes?.includes(viewType)) {
|
|
leaves.push(l);
|
|
}
|
|
};
|
|
this.app.workspace.iterateAllLeaves(saveLeaf);
|
|
if (options?.orderByAccessTime) {
|
|
leaves.sort((a, b) => {
|
|
const t1 = a?.activeTime ?? 0;
|
|
const t2 = b?.activeTime ?? 0;
|
|
return t2 - t1;
|
|
});
|
|
}
|
|
return leaves;
|
|
}
|
|
/**
|
|
* Loads a file into a WorkspaceLeaf based on navType
|
|
* @param {TFile} file
|
|
* @param {PaneType|boolean} navType
|
|
* @param {OpenViewState} openState?
|
|
* @param {SplitDirection} splitDirection if navType is 'split', the direction to
|
|
* open the split. Defaults to 'vertical'
|
|
* @returns void
|
|
*/
|
|
async openFileInLeaf(file, navType, openState, splitDirection = 'vertical') {
|
|
const { workspace } = this.app;
|
|
const leaf = navType === 'split'
|
|
? workspace.getLeaf(navType, splitDirection)
|
|
: workspace.getLeaf(navType);
|
|
await leaf.openFile(file, openState);
|
|
}
|
|
/**
|
|
* Determines whether to activate (make active and focused) an existing WorkspaceLeaf
|
|
* (searches through all leaves), or create a new WorkspaceLeaf, or reuse an unpinned
|
|
* WorkspaceLeaf, or create a new window in order to display file. This takes user
|
|
* settings and event status into account.
|
|
* @param {MouseEvent|KeyboardEvent} evt navigation trigger event
|
|
* @param {TFile} file The file to display
|
|
* @param {string} errorContext Custom text to save in error messages
|
|
* @param {OpenViewState} openState? State to pass to the new, or activated view. If
|
|
* falsy, default values will be used
|
|
* @param {WorkspaceLeaf} leaf? WorkspaceLeaf, or reference WorkspaceLeaf
|
|
* (backlink, outline, etc..) to activate if it's already known
|
|
* @param {Mode} mode? Only Symbol mode has custom handling
|
|
* @param {boolean} shouldIncludeRefViews whether reference WorkspaceLeaves are valid
|
|
* targets for activation
|
|
* @returns void
|
|
*/
|
|
navigateToLeafOrOpenFile(evt, file, errorContext, openState, leaf, mode, shouldIncludeRefViews = false) {
|
|
this.navigateToLeafOrOpenFileAsync(evt, file, openState, leaf, mode, shouldIncludeRefViews).catch((reason) => {
|
|
console.log(`Switcher++: error navigating to open file. ${errorContext}`, reason);
|
|
});
|
|
}
|
|
/**
|
|
* Determines whether to activate (make active and focused) an existing WorkspaceLeaf
|
|
* (searches through all leaves), or create a new WorkspaceLeaf, or reuse an unpinned
|
|
* WorkspaceLeaf, or create a new window in order to display file. This takes user
|
|
* settings and event status into account.
|
|
* @param {MouseEvent|KeyboardEvent} evt navigation trigger event
|
|
* @param {TFile} file The file to display
|
|
* @param {OpenViewState} openState? State to pass to the new, or activated view. If
|
|
* falsy, default values will be used
|
|
* @param {WorkspaceLeaf} leaf? WorkspaceLeaf, or reference WorkspaceLeaf
|
|
* (backlink, outline, etc..) to activate if it's already known
|
|
* @param {Mode} mode? Only Symbol mode has custom handling
|
|
* @param {boolean} shouldIncludeRefViews whether reference WorkspaceLeaves are valid
|
|
* targets for activation
|
|
* @returns void
|
|
*/
|
|
async navigateToLeafOrOpenFileAsync(evt, file, openState, leaf, mode, shouldIncludeRefViews = false) {
|
|
const { leaf: targetLeaf } = this.findMatchingLeaf(file, leaf, shouldIncludeRefViews);
|
|
const isAlreadyOpen = !!targetLeaf;
|
|
const { navType, splitDirection } = this.extractTabNavigationType(evt, isAlreadyOpen, mode);
|
|
await this.activateLeafOrOpenFile(navType, file, targetLeaf, openState, splitDirection);
|
|
}
|
|
/**
|
|
* Activates leaf (if provided), or load file into another leaf based on navType
|
|
* @param {PaneType|boolean} navType
|
|
* @param {TFile} file
|
|
* @param {WorkspaceLeaf} leaf? optional if supplied and navType is
|
|
* false then leaf will be activated
|
|
* @param {OpenViewState} openState?
|
|
* @param {SplitDirection} splitDirection? if navType is 'split', the direction to
|
|
* open the split
|
|
* @returns void
|
|
*/
|
|
async activateLeafOrOpenFile(navType, file, leaf, openState, splitDirection) {
|
|
// default to having the pane active and focused
|
|
openState = openState ?? { active: true, eState: { active: true, focus: true } };
|
|
if (leaf && navType === false) {
|
|
const eState = openState?.eState;
|
|
this.activateLeaf(leaf, eState);
|
|
}
|
|
else {
|
|
await this.openFileInLeaf(file, navType, openState, splitDirection);
|
|
}
|
|
}
|
|
/**
|
|
* Renders the UI elements to display path information for file using the
|
|
* stored configuration settings
|
|
* @param {HTMLElement} parentEl containing element, this should be the element with
|
|
* the "suggestion-content" style
|
|
* @param {TFile} file
|
|
* @param {boolean} excludeOptionalFilename? set to true to hide the filename in cases
|
|
* where when {PathDisplayFormat} is set to FolderPathFilenameOptional
|
|
* @param {SearchResult} match?
|
|
* @param {boolean} overridePathFormat? set to true force display the path and set
|
|
* {PathDisplayFormat} to FolderPathFilenameOptional
|
|
* @returns void
|
|
*/
|
|
renderPath(parentEl, file, excludeOptionalFilename, match, overridePathFormat) {
|
|
if (parentEl && file) {
|
|
const isRoot = file.parent.isRoot();
|
|
let format = this.settings.pathDisplayFormat;
|
|
let hidePath = format === PathDisplayFormat.None || (isRoot && this.settings.hidePathIfRoot);
|
|
if (overridePathFormat) {
|
|
format = PathDisplayFormat.FolderPathFilenameOptional;
|
|
hidePath = false;
|
|
}
|
|
if (!hidePath) {
|
|
const wrapperEl = parentEl.createDiv({ cls: ['suggestion-note', 'qsp-note'] });
|
|
const path = this.getPathDisplayText(file, format, excludeOptionalFilename);
|
|
const iconEl = wrapperEl.createSpan({ cls: ['qsp-path-indicator'] });
|
|
obsidian.setIcon(iconEl, 'folder');
|
|
const pathEl = wrapperEl.createSpan({ cls: 'qsp-path' });
|
|
obsidian.renderResults(pathEl, path, match);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Formats the path of file based on displayFormat
|
|
* @param {TFile} file
|
|
* @param {PathDisplayFormat} displayFormat
|
|
* @param {boolean} excludeOptionalFilename? Only applicable to
|
|
* {PathDisplayFormat.FolderPathFilenameOptional}. When true will exclude the filename from the returned string
|
|
* @returns string
|
|
*/
|
|
getPathDisplayText(file, displayFormat, excludeOptionalFilename) {
|
|
let text = '';
|
|
if (file) {
|
|
const { parent } = file;
|
|
const dirname = parent.name;
|
|
const isRoot = parent.isRoot();
|
|
// root path is expected to always be "/"
|
|
const rootPath = this.app.vault.getRoot().path;
|
|
switch (displayFormat) {
|
|
case PathDisplayFormat.FolderWithFilename:
|
|
text = isRoot ? `${file.name}` : obsidian.normalizePath(`${dirname}/${file.name}`);
|
|
break;
|
|
case PathDisplayFormat.FolderOnly:
|
|
text = isRoot ? rootPath : dirname;
|
|
break;
|
|
case PathDisplayFormat.Full:
|
|
text = file.path;
|
|
break;
|
|
case PathDisplayFormat.FolderPathFilenameOptional:
|
|
if (excludeOptionalFilename) {
|
|
text = parent.path;
|
|
if (!isRoot) {
|
|
text += rootPath; // add explicit trailing /
|
|
}
|
|
}
|
|
else {
|
|
text = this.getPathDisplayText(file, PathDisplayFormat.Full);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return text;
|
|
}
|
|
/**
|
|
* Creates the UI elements to display the primary suggestion text using
|
|
* the correct styles.
|
|
* @param {HTMLElement} parentEl containing element, this should be the element with
|
|
* the "suggestion-item" style
|
|
* @param {string} content
|
|
* @param {SearchResult} match
|
|
* @param {number} offset?
|
|
* @returns HTMLDivElement
|
|
*/
|
|
renderContent(parentEl, content, match, offset) {
|
|
const contentEl = parentEl.createDiv({
|
|
cls: ['suggestion-content', 'qsp-content'],
|
|
});
|
|
const titleEl = contentEl.createDiv({
|
|
cls: ['suggestion-title', 'qsp-title'],
|
|
});
|
|
obsidian.renderResults(titleEl, content, match, offset);
|
|
return contentEl;
|
|
}
|
|
/** add the base suggestion styles to the suggestion container element
|
|
* @param {HTMLElement} parentEl container element
|
|
* @param {string[]} additionalStyles? optional styles to add
|
|
*/
|
|
addClassesToSuggestionContainer(parentEl, additionalStyles) {
|
|
const styles = ['mod-complex'];
|
|
if (additionalStyles) {
|
|
styles.push(...additionalStyles);
|
|
}
|
|
parentEl?.addClasses(styles);
|
|
}
|
|
/**
|
|
* Searches through primaryString, if not match is found,
|
|
* searches through secondaryString
|
|
* @param {PreparedQuery} prepQuery
|
|
* @param {string} primaryString
|
|
* @param {string} secondaryString?
|
|
* @returns { isPrimary: boolean; match?: SearchResult }
|
|
*/
|
|
fuzzySearchStrings(prepQuery, primaryString, secondaryString) {
|
|
let isPrimary = false;
|
|
let match = null;
|
|
if (primaryString) {
|
|
match = obsidian.fuzzySearch(prepQuery, primaryString);
|
|
isPrimary = !!match;
|
|
}
|
|
if (!match && secondaryString) {
|
|
match = obsidian.fuzzySearch(prepQuery, secondaryString);
|
|
if (match) {
|
|
match.score -= 1;
|
|
}
|
|
}
|
|
return {
|
|
isPrimary,
|
|
match,
|
|
};
|
|
}
|
|
/**
|
|
* Searches through primaryText, if no match is found and file is not null, it will
|
|
* fallback to searching 1) file.basename, 2) file.path
|
|
* @param {PreparedQuery} prepQuery
|
|
* @param {string} primaryString
|
|
* @param {PathSegments} pathSegments? TFile like object containing the basename and full path.
|
|
* @returns SearchResultWithFallback
|
|
*/
|
|
fuzzySearchWithFallback(prepQuery, primaryString, pathSegments) {
|
|
let matchType = MatchType.None;
|
|
let matchText;
|
|
let match = null;
|
|
let res = this.fuzzySearchStrings(prepQuery, primaryString);
|
|
if (res.match) {
|
|
match = res.match;
|
|
matchType = MatchType.Primary;
|
|
matchText = primaryString;
|
|
}
|
|
else if (pathSegments) {
|
|
const { basename, path } = pathSegments;
|
|
// Note: the fallback to path has to search through the entire path
|
|
// because search needs to match over the filename/basename boundaries
|
|
// e.g. search string "to my" should match "path/to/myfile.md"
|
|
// that means MatchType.Basename will always be in the basename, while
|
|
// MatchType.ParentPath can span both filename and basename
|
|
res = this.fuzzySearchStrings(prepQuery, basename, path);
|
|
if (res.isPrimary) {
|
|
matchType = MatchType.Basename;
|
|
matchText = basename;
|
|
}
|
|
else if (res.match) {
|
|
matchType = MatchType.Path;
|
|
matchText = path;
|
|
}
|
|
match = res.match;
|
|
}
|
|
return { matchType, matchText, match };
|
|
}
|
|
/**
|
|
* Separate match into two groups, one that only matches the path segment of file, and
|
|
* a second that only matches the filename segment
|
|
* @param {PathSegments} pathSegments
|
|
* @param {SearchResult} match
|
|
* @returns {SearchResult; SearchResult}
|
|
*/
|
|
splitSearchMatchesAtBasename(pathSegments, match) {
|
|
let basenameMatch = null;
|
|
let pathMatch = null;
|
|
// function to re-anchor offsets by a certain amount
|
|
const decrementOffsets = (offsets, amount) => {
|
|
offsets.forEach((offset) => {
|
|
offset[0] -= amount;
|
|
offset[1] -= amount;
|
|
});
|
|
};
|
|
if (pathSegments && match?.matches) {
|
|
const nameIndex = pathSegments.path.lastIndexOf(pathSegments.basename);
|
|
if (nameIndex >= 0) {
|
|
const { matches, score } = match;
|
|
const matchStartIndex = matches[0][0];
|
|
const matchEndIndex = matches[matches.length - 1][1];
|
|
if (matchStartIndex >= nameIndex) {
|
|
// the entire match offset is in the basename segment, so match can be used
|
|
// for basename
|
|
basenameMatch = match;
|
|
decrementOffsets(basenameMatch.matches, nameIndex);
|
|
}
|
|
else if (matchEndIndex <= nameIndex) {
|
|
// the entire match offset is in the path segment
|
|
pathMatch = match;
|
|
}
|
|
else {
|
|
// the match offset spans both path and basename, so they will have to
|
|
// to be split up. Note that the entire SearchResult can span both, and
|
|
// a single SearchMatchPart inside the SearchResult can also span both
|
|
let i = matches.length;
|
|
while (i--) {
|
|
const matchPartStartIndex = matches[i][0];
|
|
const matchPartEndIndex = matches[i][1];
|
|
const nextMatchPartIndex = i + 1;
|
|
if (matchPartEndIndex <= nameIndex) {
|
|
// the last path segment MatchPart ends cleanly in the path segment
|
|
pathMatch = { score, matches: matches.slice(0, nextMatchPartIndex) };
|
|
basenameMatch = { score, matches: matches.slice(nextMatchPartIndex) };
|
|
decrementOffsets(basenameMatch.matches, nameIndex);
|
|
break;
|
|
}
|
|
else if (matchPartStartIndex < nameIndex) {
|
|
// the last MatchPart starts in path segment and ends in basename segment
|
|
// adjust the end of the path segment MatchPart to finish at the end
|
|
// of the path segment
|
|
let offsets = matches.slice(0, nextMatchPartIndex);
|
|
offsets[offsets.length - 1] = [matchPartStartIndex, nameIndex];
|
|
pathMatch = { score, matches: offsets };
|
|
// adjust the beginning of the first basename segment MatchPart to start
|
|
// at the beginning of the basename segment
|
|
offsets = matches.slice(i);
|
|
decrementOffsets(offsets, nameIndex);
|
|
offsets[0][0] = 0;
|
|
basenameMatch = { score, matches: offsets };
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return { pathMatch, basenameMatch };
|
|
}
|
|
/**
|
|
* Display the provided information as a suggestion with the content and path information on separate lines
|
|
* @param {HTMLElement} parentEl
|
|
* @param {string[]} parentElStyles
|
|
* @param {string} primaryString
|
|
* @param {TFile} file
|
|
* @param {MatchType} matchType
|
|
* @param {SearchResult} match
|
|
* @param {} excludeOptionalFilename=true
|
|
* @returns void
|
|
*/
|
|
renderAsFileInfoPanel(parentEl, parentElStyles, primaryString, file, matchType, match, excludeOptionalFilename = true) {
|
|
let primaryMatch = null;
|
|
let pathMatch = null;
|
|
if (primaryString?.length) {
|
|
if (matchType === MatchType.Primary) {
|
|
primaryMatch = match;
|
|
}
|
|
else if (matchType === MatchType.Path) {
|
|
pathMatch = match;
|
|
}
|
|
}
|
|
else if (file) {
|
|
primaryString = file.basename;
|
|
if (matchType === MatchType.Basename) {
|
|
primaryMatch = match;
|
|
}
|
|
else if (matchType === MatchType.Path) {
|
|
// MatchType.ParentPath can span both filename and basename
|
|
// (partial match in each) so try to split the match offsets
|
|
({ pathMatch, basenameMatch: primaryMatch } = this.splitSearchMatchesAtBasename(file, match));
|
|
}
|
|
}
|
|
this.addClassesToSuggestionContainer(parentEl, parentElStyles);
|
|
const contentEl = this.renderContent(parentEl, primaryString, primaryMatch);
|
|
this.renderPath(contentEl, file, excludeOptionalFilename, pathMatch, !!pathMatch);
|
|
}
|
|
/**
|
|
* Returns the currently active leaf across all root workspace splits
|
|
* @returns WorkspaceLeaf | null
|
|
*/
|
|
getActiveLeaf() {
|
|
return Handler.getActiveLeaf(this.app.workspace);
|
|
}
|
|
/**
|
|
* Returns the currently active leaf across all root workspace splits
|
|
* @param {Workspace} workspace
|
|
* @returns WorkspaceLeaf | null
|
|
*/
|
|
static getActiveLeaf(workspace) {
|
|
const leaf = workspace?.getActiveViewOfType(obsidian.View)?.leaf;
|
|
return leaf ?? null;
|
|
}
|
|
/**
|
|
* Displays extra flair icons for an item, and adds any associated css classes
|
|
* to parentEl
|
|
* @param {HTMLElement} parentEl the suggestion container element
|
|
* @param {AnySuggestion} sugg the suggestion item
|
|
* @param {HTMLDivElement=null} flairContainerEl optional, if null, it will be created
|
|
* @returns HTMLDivElement the flairContainerEl that was passed in or created
|
|
*/
|
|
renderOptionalIndicators(parentEl, sugg, flairContainerEl = null) {
|
|
const { showOptionalIndicatorIcons } = this.settings;
|
|
const indicatorData = new Map();
|
|
indicatorData.set('isRecent', {
|
|
iconName: 'history',
|
|
parentElClass: 'qsp-recent-file',
|
|
indicatorElClass: 'qsp-recent-indicator',
|
|
});
|
|
indicatorData.set('isOpenInEditor', {
|
|
iconName: 'lucide-file-edit',
|
|
parentElClass: 'qsp-open-editor',
|
|
indicatorElClass: 'qsp-editor-indicator',
|
|
});
|
|
indicatorData.set('isBookmarked', {
|
|
iconName: 'lucide-bookmark',
|
|
parentElClass: 'qsp-bookmarked-file',
|
|
indicatorElClass: 'qsp-bookmarked-indicator',
|
|
});
|
|
if (!flairContainerEl) {
|
|
flairContainerEl = this.createFlairContainer(parentEl);
|
|
}
|
|
if (showOptionalIndicatorIcons) {
|
|
for (const [state, data] of indicatorData.entries()) {
|
|
if (sugg[state] === true) {
|
|
if (data.parentElClass) {
|
|
parentEl?.addClass(data.parentElClass);
|
|
}
|
|
this.renderIndicator(flairContainerEl, [data.indicatorElClass], data.iconName);
|
|
}
|
|
}
|
|
}
|
|
return flairContainerEl;
|
|
}
|
|
/**
|
|
* @param {HTMLDivElement} flairContainerEl
|
|
* @param {string[]} indicatorClasses additional css classes to add to flair element
|
|
* @param {string} svgIconName? the name of the svg icon to use
|
|
* @param {string} indicatorText? the text content of the flair element
|
|
* @returns HTMLElement the flair icon wrapper element
|
|
*/
|
|
renderIndicator(flairContainerEl, indicatorClasses, svgIconName, indicatorText) {
|
|
const cls = ['suggestion-flair', ...indicatorClasses];
|
|
const flairEl = flairContainerEl?.createSpan({ cls });
|
|
if (flairEl) {
|
|
if (svgIconName) {
|
|
flairEl.addClass('svg-icon');
|
|
obsidian.setIcon(flairEl, svgIconName);
|
|
}
|
|
if (indicatorText) {
|
|
flairEl.setText(indicatorText);
|
|
}
|
|
}
|
|
return flairEl;
|
|
}
|
|
/**
|
|
* Creates a child Div element with the appropriate css classes for flair icons
|
|
* @param {HTMLElement} parentEl
|
|
* @returns HTMLDivElement
|
|
*/
|
|
createFlairContainer(parentEl) {
|
|
return parentEl?.createDiv({ cls: ['suggestion-aux', 'qsp-aux'] });
|
|
}
|
|
/**
|
|
* Retrieves a TFile object using path. Return null if path does not represent
|
|
* a TFile object.
|
|
* @param {string} path
|
|
* @returns TFile|null
|
|
*/
|
|
getTFileByPath(path) {
|
|
return getTFileByPath(path, this.app.vault);
|
|
}
|
|
/**
|
|
* Downranks suggestions for files that live in Obsidian ignored paths, or,
|
|
* increases the suggestion score by a factor specified in settings. This instance
|
|
* version just forwards to the static version
|
|
* @param {V} sugg the suggestion objects
|
|
* @returns V
|
|
*/
|
|
applyMatchPriorityPreferences(sugg) {
|
|
return Handler.applyMatchPriorityPreferences(sugg, this.settings, this.app.metadataCache);
|
|
}
|
|
/**
|
|
* Downranks suggestions for files that live in Obsidian ignored paths, or,
|
|
* increases the suggestion score by a factor specified in settings.
|
|
* @param {V} sugg the suggestion objects
|
|
* @param {SwitcherPlusSettings} settings
|
|
* @param {MetadataCache} metadataCache
|
|
* @returns V
|
|
*/
|
|
static applyMatchPriorityPreferences(sugg, settings, metadataCache) {
|
|
if (sugg?.match) {
|
|
const { match, type, file } = sugg;
|
|
if (file && metadataCache?.isUserIgnored(file.path)) {
|
|
// downrank suggestions that are in an obsidian ignored paths
|
|
sugg.downranked = true;
|
|
sugg.match.score -= 10;
|
|
}
|
|
else if (settings?.matchPriorityAdjustments?.isEnabled) {
|
|
const { matchPriorityAdjustments } = settings;
|
|
const adjustments = matchPriorityAdjustments.adjustments ?? {};
|
|
const fileExtAdjustments = matchPriorityAdjustments.fileExtAdjustments ?? {};
|
|
let factor = 0;
|
|
const getFactor = (key, collection) => {
|
|
collection = collection ?? adjustments;
|
|
let val = 0;
|
|
if (Object.prototype.hasOwnProperty.call(collection, key)) {
|
|
val = Number(collection[key]?.value);
|
|
}
|
|
return isNaN(val) ? 0 : val;
|
|
};
|
|
const getFactorConstrained = (searchType, searchKey) => {
|
|
let val = 0;
|
|
if ((searchType !== null && searchType === type) || sugg[searchKey]) {
|
|
val = getFactor(searchKey);
|
|
}
|
|
return val;
|
|
};
|
|
factor += getFactorConstrained(SuggestionType.Bookmark, 'isBookmarked');
|
|
factor += getFactorConstrained(SuggestionType.EditorList, 'isOpenInEditor');
|
|
factor += getFactorConstrained(null, 'isRecent');
|
|
factor += getFactorConstrained(null, 'isAttachment');
|
|
factor += getFactor(file?.extension, fileExtAdjustments);
|
|
if (isHeadingSuggestion(sugg)) {
|
|
factor += getFactor(`h${sugg.item?.level}`);
|
|
}
|
|
// check for adjustments defined for other suggestion types, the types that are
|
|
// explicitly checked above should not be in the adjustment list so
|
|
// they don't get counted twice (above and then again here)
|
|
const typeStr = type.toString();
|
|
factor += getFactor(typeStr);
|
|
// update score by the percentage define by factor
|
|
// find one percent of score by dividing the absolute value of score by 100,
|
|
// multiply factor by 100 to convert into percentage
|
|
// multiply the two to get the change amount, and add it to score
|
|
match.score += (Math.abs(match.score) / 100) * (factor * 100);
|
|
}
|
|
}
|
|
return sugg;
|
|
}
|
|
/**
|
|
* Sets isOpenInEditor, isRecent, isBookmarked, isAttachment, status of sugg
|
|
* based on currentWorkspaceEnvList
|
|
* @param {WorkspaceEnvList} currentWorkspaceEnvList
|
|
* @param {V} sugg
|
|
* @returns V
|
|
*/
|
|
static updateWorkspaceEnvListStatus(currentWorkspaceEnvList, sugg) {
|
|
if (currentWorkspaceEnvList && sugg?.file) {
|
|
const { file } = sugg;
|
|
sugg.isOpenInEditor = currentWorkspaceEnvList.openWorkspaceFiles?.has(file);
|
|
sugg.isRecent = currentWorkspaceEnvList.mostRecentFiles?.has(file);
|
|
sugg.isBookmarked = currentWorkspaceEnvList.fileBookmarks?.has(file);
|
|
sugg.isAttachment = currentWorkspaceEnvList.attachmentFileExtensions?.has(file.extension);
|
|
}
|
|
return sugg;
|
|
}
|
|
/**
|
|
* Renders a suggestion hint for creating a new note
|
|
* @param {HTMLElement} parentEl
|
|
* @param {string} filename
|
|
* @returns HTMLDivElement
|
|
*/
|
|
renderFileCreationSuggestion(parentEl, filename) {
|
|
this.addClassesToSuggestionContainer(parentEl);
|
|
const contentEl = this.renderContent(parentEl, filename, null);
|
|
const flairEl = this.createFlairContainer(parentEl);
|
|
flairEl?.createSpan({
|
|
cls: 'suggestion-hotkey',
|
|
text: 'Enter to create',
|
|
});
|
|
return contentEl;
|
|
}
|
|
/**
|
|
* Creates a new note in the vault with filename. Uses evt to determine the
|
|
* navigation type (reuse tab, new tab, new window) to use for opening the newly
|
|
* created note.
|
|
* @param {string} filename
|
|
* @param {MouseEvent|KeyboardEvent} evt
|
|
* @returns void
|
|
*/
|
|
createFile(filename, evt) {
|
|
const { workspace } = this.app;
|
|
const { navType } = this.extractTabNavigationType(evt);
|
|
const activeView = workspace.getActiveViewOfType(obsidian.FileView);
|
|
let sourcePath = '';
|
|
if (activeView?.file) {
|
|
sourcePath = activeView.file.path;
|
|
}
|
|
workspace
|
|
.openLinkText(filename, sourcePath, navType, { active: true })
|
|
.catch((err) => {
|
|
console.log('Switcher++: error creating new file. ', err);
|
|
});
|
|
}
|
|
}
|
|
|
|
const WORKSPACE_PLUGIN_ID = 'workspaces';
|
|
class WorkspaceHandler extends Handler {
|
|
getCommandString(_sessionOpts) {
|
|
return this.settings?.workspaceListCommand;
|
|
}
|
|
validateCommand(inputInfo, index, filterText, _activeSuggestion, _activeLeaf) {
|
|
const cmd = inputInfo.parsedCommand(Mode.WorkspaceList);
|
|
if (this.getEnabledWorkspacesPluginInstance()) {
|
|
inputInfo.mode = Mode.WorkspaceList;
|
|
cmd.index = index;
|
|
cmd.parsedInput = filterText;
|
|
cmd.isValidated = true;
|
|
}
|
|
return cmd;
|
|
}
|
|
getSuggestions(inputInfo) {
|
|
const suggestions = [];
|
|
if (inputInfo) {
|
|
inputInfo.buildSearchQuery();
|
|
const { hasSearchTerm, prepQuery } = inputInfo.searchQuery;
|
|
const items = this.getItems();
|
|
items.forEach((item) => {
|
|
let shouldPush = true;
|
|
let match = null;
|
|
if (hasSearchTerm) {
|
|
match = obsidian.fuzzySearch(prepQuery, item.id);
|
|
shouldPush = !!match;
|
|
}
|
|
if (shouldPush) {
|
|
suggestions.push({ type: SuggestionType.WorkspaceList, item, match });
|
|
}
|
|
});
|
|
if (hasSearchTerm) {
|
|
obsidian.sortSearchResults(suggestions);
|
|
}
|
|
}
|
|
return suggestions;
|
|
}
|
|
renderSuggestion(sugg, parentEl) {
|
|
let handled = false;
|
|
if (sugg) {
|
|
this.addClassesToSuggestionContainer(parentEl, ['qsp-suggestion-workspace']);
|
|
this.renderContent(parentEl, sugg.item.id, sugg.match);
|
|
handled = true;
|
|
}
|
|
return handled;
|
|
}
|
|
onChooseSuggestion(sugg, _evt) {
|
|
let handled = false;
|
|
if (sugg) {
|
|
const { id } = sugg.item;
|
|
const pluginInstance = this.getEnabledWorkspacesPluginInstance();
|
|
if (pluginInstance) {
|
|
pluginInstance.loadWorkspace(id);
|
|
}
|
|
handled = true;
|
|
}
|
|
return handled;
|
|
}
|
|
onNoResultsCreateAction(inputInfo, _evt) {
|
|
const pluginInstance = this.getEnabledWorkspacesPluginInstance();
|
|
if (pluginInstance) {
|
|
const input = inputInfo.parsedCommand(Mode.WorkspaceList)?.parsedInput;
|
|
// create a new workspace and set it active
|
|
pluginInstance.saveWorkspace(input);
|
|
pluginInstance.setActiveWorkspace(input);
|
|
}
|
|
return true;
|
|
}
|
|
getItems() {
|
|
const items = [];
|
|
const workspaces = this.getEnabledWorkspacesPluginInstance()?.workspaces;
|
|
if (workspaces) {
|
|
Object.keys(workspaces).forEach((id) => items.push({ id, type: 'workspaceInfo' }));
|
|
}
|
|
return items.sort((a, b) => a.id.localeCompare(b.id));
|
|
}
|
|
getEnabledWorkspacesPluginInstance() {
|
|
return getInternalEnabledPluginById(this.app, WORKSPACE_PLUGIN_ID);
|
|
}
|
|
}
|
|
|
|
class StandardExHandler extends Handler {
|
|
getCommandString(_sessionOpts) {
|
|
return '';
|
|
}
|
|
validateCommand(_inputInfo, _index, _filterText, _activeSuggestion, _activeLeaf) {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
getSuggestions(_inputInfo) {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
renderSuggestion(sugg, parentEl) {
|
|
let handled = false;
|
|
if (isFileSuggestion(sugg)) {
|
|
handled = this.renderFileSuggestion(sugg, parentEl);
|
|
}
|
|
else {
|
|
handled = this.renderAliasSuggestion(sugg, parentEl);
|
|
}
|
|
if (sugg?.downranked) {
|
|
parentEl.addClass('mod-downranked');
|
|
}
|
|
return handled;
|
|
}
|
|
onChooseSuggestion(sugg, evt) {
|
|
let handled = false;
|
|
if (sugg) {
|
|
const { file } = sugg;
|
|
this.navigateToLeafOrOpenFile(evt, file, `Unable to open file from SystemSuggestion ${file.path}`);
|
|
handled = true;
|
|
}
|
|
return handled;
|
|
}
|
|
renderFileSuggestion(sugg, parentEl) {
|
|
let handled = false;
|
|
if (sugg) {
|
|
const { file, matchType, match } = sugg;
|
|
this.renderAsFileInfoPanel(parentEl, ['qsp-suggestion-file'], null, file, matchType, match);
|
|
this.renderOptionalIndicators(parentEl, sugg);
|
|
handled = true;
|
|
}
|
|
return handled;
|
|
}
|
|
renderAliasSuggestion(sugg, parentEl) {
|
|
let handled = false;
|
|
if (sugg) {
|
|
const { file, matchType, match } = sugg;
|
|
this.renderAsFileInfoPanel(parentEl, ['qsp-suggestion-alias'], sugg.alias, file, matchType, match, false);
|
|
const flairContainerEl = this.renderOptionalIndicators(parentEl, sugg);
|
|
this.renderIndicator(flairContainerEl, ['qsp-alias-indicator'], 'lucide-forward');
|
|
handled = true;
|
|
}
|
|
return handled;
|
|
}
|
|
addPropertiesToStandardSuggestions(inputInfo, sugg) {
|
|
const { match, file } = sugg;
|
|
const matches = match?.matches;
|
|
let matchType = MatchType.None;
|
|
let matchText = null;
|
|
if (matches) {
|
|
if (isAliasSuggestion(sugg)) {
|
|
matchType = MatchType.Primary;
|
|
matchText = sugg.alias;
|
|
}
|
|
else {
|
|
matchType = MatchType.Path;
|
|
matchText = file?.path;
|
|
}
|
|
}
|
|
sugg.matchType = matchType;
|
|
sugg.matchText = matchText;
|
|
// patch with missing properties required for enhanced custom rendering
|
|
Handler.updateWorkspaceEnvListStatus(inputInfo.currentWorkspaceEnvList, sugg);
|
|
}
|
|
static createUnresolvedSuggestion(linktext, result, settings, metadataCache) {
|
|
const sugg = {
|
|
linktext,
|
|
type: SuggestionType.Unresolved,
|
|
...result,
|
|
};
|
|
return Handler.applyMatchPriorityPreferences(sugg, settings, metadataCache);
|
|
}
|
|
}
|
|
|
|
class EditorHandler extends Handler {
|
|
getCommandString(_sessionOpts) {
|
|
return this.settings?.editorListCommand;
|
|
}
|
|
validateCommand(inputInfo, index, filterText, _activeSuggestion, _activeLeaf) {
|
|
inputInfo.mode = Mode.EditorList;
|
|
const cmd = inputInfo.parsedCommand(Mode.EditorList);
|
|
cmd.index = index;
|
|
cmd.parsedInput = filterText;
|
|
cmd.isValidated = true;
|
|
return cmd;
|
|
}
|
|
getSuggestions(inputInfo) {
|
|
const suggestions = [];
|
|
if (inputInfo) {
|
|
inputInfo.buildSearchQuery();
|
|
const { hasSearchTerm, prepQuery } = inputInfo.searchQuery;
|
|
const items = this.getItems();
|
|
items.forEach((item) => {
|
|
const file = item.view?.file;
|
|
let shouldPush = true;
|
|
let result = { matchType: MatchType.None, match: null };
|
|
const preferredTitle = this.getPreferredTitle(item, this.settings.preferredSourceForTitle);
|
|
if (hasSearchTerm) {
|
|
result = this.fuzzySearchWithFallback(prepQuery, preferredTitle, file);
|
|
shouldPush = result.matchType !== MatchType.None;
|
|
}
|
|
if (shouldPush) {
|
|
suggestions.push(this.createSuggestion(inputInfo.currentWorkspaceEnvList, item, file, result, preferredTitle));
|
|
}
|
|
});
|
|
if (hasSearchTerm) {
|
|
obsidian.sortSearchResults(suggestions);
|
|
}
|
|
}
|
|
return suggestions;
|
|
}
|
|
getPreferredTitle(leaf, titleSource) {
|
|
return EditorHandler.getPreferredTitle(leaf, titleSource, this.app.metadataCache);
|
|
}
|
|
static getPreferredTitle(leaf, titleSource, metadataCache) {
|
|
const { view } = leaf;
|
|
const file = view?.file;
|
|
let text = leaf.getDisplayText();
|
|
if (titleSource === 'H1' && file) {
|
|
const h1 = EditorHandler.getFirstH1(file, metadataCache);
|
|
if (h1) {
|
|
text = text.replace(file.basename, h1.heading);
|
|
}
|
|
}
|
|
return text;
|
|
}
|
|
getItems() {
|
|
const { excludeViewTypes, includeSidePanelViewTypes, orderEditorListByAccessTime: orderByAccessTime, } = this.settings;
|
|
return this.getOpenLeaves(excludeViewTypes, includeSidePanelViewTypes, {
|
|
orderByAccessTime,
|
|
});
|
|
}
|
|
renderSuggestion(sugg, parentEl) {
|
|
let handled = false;
|
|
if (sugg) {
|
|
const { file, matchType, match } = sugg;
|
|
const hideBasename = [MatchType.None, MatchType.Primary].includes(matchType);
|
|
this.renderAsFileInfoPanel(parentEl, ['qsp-suggestion-editor'], sugg.preferredTitle, file, matchType, match, hideBasename);
|
|
this.renderOptionalIndicators(parentEl, sugg);
|
|
handled = true;
|
|
}
|
|
return handled;
|
|
}
|
|
onChooseSuggestion(sugg, evt) {
|
|
let handled = false;
|
|
if (sugg) {
|
|
this.navigateToLeafOrOpenFile(evt, sugg.file, 'Unable to reopen existing editor in new Leaf.', null, sugg.item, null, true);
|
|
handled = true;
|
|
}
|
|
return handled;
|
|
}
|
|
createSuggestion(currentWorkspaceEnvList, leaf, file, result, preferredTitle) {
|
|
return EditorHandler.createSuggestion(currentWorkspaceEnvList, leaf, file, this.settings, this.app.metadataCache, preferredTitle, result);
|
|
}
|
|
static createSuggestion(currentWorkspaceEnvList, leaf, file, settings, metadataCache, preferredTitle, result) {
|
|
result = result ?? { matchType: MatchType.None, match: null, matchText: null };
|
|
preferredTitle = preferredTitle ?? null;
|
|
let sugg = {
|
|
item: leaf,
|
|
file,
|
|
preferredTitle,
|
|
type: SuggestionType.EditorList,
|
|
...result,
|
|
};
|
|
sugg = Handler.updateWorkspaceEnvListStatus(currentWorkspaceEnvList, sugg);
|
|
return Handler.applyMatchPriorityPreferences(sugg, settings, metadataCache);
|
|
}
|
|
}
|
|
|
|
const BOOKMARKS_PLUGIN_ID = 'bookmarks';
|
|
class BookmarksHandler extends Handler {
|
|
getCommandString(_sessionOpts) {
|
|
return this.settings?.bookmarksListCommand;
|
|
}
|
|
validateCommand(inputInfo, index, filterText, _activeSuggestion, _activeLeaf) {
|
|
const cmd = inputInfo.parsedCommand(Mode.BookmarksList);
|
|
if (this.getEnabledBookmarksPluginInstance()) {
|
|
inputInfo.mode = Mode.BookmarksList;
|
|
cmd.index = index;
|
|
cmd.parsedInput = filterText;
|
|
cmd.isValidated = true;
|
|
}
|
|
return cmd;
|
|
}
|
|
getSuggestions(inputInfo) {
|
|
const suggestions = [];
|
|
if (inputInfo) {
|
|
inputInfo.buildSearchQuery();
|
|
const { hasSearchTerm, prepQuery } = inputInfo.searchQuery;
|
|
const itemsInfo = this.getItems(inputInfo);
|
|
itemsInfo.forEach((info) => {
|
|
let shouldPush = true;
|
|
let result = { matchType: MatchType.None, match: null };
|
|
if (hasSearchTerm) {
|
|
result = this.fuzzySearchWithFallback(prepQuery, info.bookmarkPath);
|
|
shouldPush = result.matchType !== MatchType.None;
|
|
}
|
|
if (shouldPush) {
|
|
suggestions.push(this.createSuggestion(inputInfo.currentWorkspaceEnvList, info, result));
|
|
}
|
|
});
|
|
if (hasSearchTerm) {
|
|
obsidian.sortSearchResults(suggestions);
|
|
}
|
|
}
|
|
return suggestions;
|
|
}
|
|
renderSuggestion(_sugg, _parentEl) {
|
|
return false;
|
|
}
|
|
onChooseSuggestion(_sugg, _evt) {
|
|
return false;
|
|
}
|
|
getPreferredTitle(pluginInstance, bookmark, file, titleSource) {
|
|
let text = pluginInstance.getItemTitle(bookmark);
|
|
if (titleSource === 'H1' && file) {
|
|
const h1 = this.getFirstH1(file);
|
|
if (h1) {
|
|
// the "#" represents the start of a heading deep link,
|
|
// "#^" represents the the start of a deep block link,
|
|
// so everything before "#" should represent the filename that
|
|
// needs to be replaced with the file title
|
|
text = text.replace(/^[^#]*/, h1.heading);
|
|
}
|
|
}
|
|
return text;
|
|
}
|
|
getItems(inputInfo) {
|
|
const itemsInfo = [];
|
|
const pluginInstance = this.getEnabledBookmarksPluginInstance();
|
|
if (pluginInstance) {
|
|
// if inputInfo is not supplied, then all items are expected (disregard facets), so use
|
|
// and empty facet list
|
|
const activeFacetIds = inputInfo
|
|
? this.getActiveFacetIds(inputInfo)
|
|
: new Set();
|
|
const traverseBookmarks = (bookmarks, path) => {
|
|
bookmarks?.forEach((bookmark) => {
|
|
if (BookmarksHandler.isBookmarksPluginGroupItem(bookmark)) {
|
|
traverseBookmarks(bookmark.items, `${path}${bookmark.title}/`);
|
|
}
|
|
else if (this.isFacetedWith(activeFacetIds, BOOKMARKS_FACET_ID_MAP[bookmark.type])) {
|
|
let file = null;
|
|
if (BookmarksHandler.isBookmarksPluginFileItem(bookmark)) {
|
|
file = this.getTFileByPath(bookmark.path);
|
|
}
|
|
const title = this.getPreferredTitle(pluginInstance, bookmark, file, this.settings.preferredSourceForTitle);
|
|
const bookmarkPath = path + title;
|
|
itemsInfo.push({ item: bookmark, bookmarkPath, file });
|
|
}
|
|
});
|
|
};
|
|
traverseBookmarks(pluginInstance.items, '');
|
|
}
|
|
return itemsInfo;
|
|
}
|
|
getEnabledBookmarksPluginInstance() {
|
|
return getInternalEnabledPluginById(this.app, BOOKMARKS_PLUGIN_ID);
|
|
}
|
|
createSuggestion(currentWorkspaceEnvList, bookmarkInfo, result) {
|
|
return BookmarksHandler.createSuggestion(currentWorkspaceEnvList, bookmarkInfo, this.settings, this.app.metadataCache, result);
|
|
}
|
|
static createSuggestion(currentWorkspaceEnvList, bookmarkInfo, settings, metadataCache, result) {
|
|
let sugg = {
|
|
type: SuggestionType.Bookmark,
|
|
item: bookmarkInfo.item,
|
|
bookmarkPath: bookmarkInfo.bookmarkPath,
|
|
file: bookmarkInfo.file,
|
|
...result,
|
|
};
|
|
sugg = Handler.updateWorkspaceEnvListStatus(currentWorkspaceEnvList, sugg);
|
|
return Handler.applyMatchPriorityPreferences(sugg, settings, metadataCache);
|
|
}
|
|
static isBookmarksPluginFileItem(obj) {
|
|
return isOfType(obj, 'type', 'file');
|
|
}
|
|
static isBookmarksPluginGroupItem(obj) {
|
|
return isOfType(obj, 'type', 'group');
|
|
}
|
|
}
|
|
|
|
class HeadingsHandler extends Handler {
|
|
getCommandString(_sessionOpts) {
|
|
return this.settings?.headingsListCommand;
|
|
}
|
|
validateCommand(inputInfo, index, filterText, _activeSuggestion, _activeLeaf) {
|
|
inputInfo.mode = Mode.HeadingsList;
|
|
const cmd = inputInfo.parsedCommand(Mode.HeadingsList);
|
|
cmd.index = index;
|
|
cmd.parsedInput = filterText;
|
|
cmd.isValidated = true;
|
|
return cmd;
|
|
}
|
|
onChooseSuggestion(sugg, evt) {
|
|
let handled = false;
|
|
if (sugg) {
|
|
const { start: { line, col }, end: endLoc, } = sugg.item.position;
|
|
// state information to highlight the target heading
|
|
const eState = {
|
|
active: true,
|
|
focus: true,
|
|
startLoc: { line, col },
|
|
endLoc,
|
|
line,
|
|
cursor: {
|
|
from: { line, ch: col },
|
|
to: { line, ch: col },
|
|
},
|
|
};
|
|
this.navigateToLeafOrOpenFile(evt, sugg.file, 'Unable to navigate to heading for file.', { active: true, eState });
|
|
handled = true;
|
|
}
|
|
return handled;
|
|
}
|
|
renderSuggestion(sugg, parentEl) {
|
|
let handled = false;
|
|
if (sugg) {
|
|
const { item } = sugg;
|
|
this.addClassesToSuggestionContainer(parentEl, [
|
|
'qsp-suggestion-headings',
|
|
`qsp-headings-l${item.level}`,
|
|
]);
|
|
const contentEl = this.renderContent(parentEl, item.heading, sugg.match);
|
|
this.renderPath(contentEl, sugg.file);
|
|
// render the flair icons
|
|
const flairContainerEl = this.createFlairContainer(parentEl);
|
|
this.renderOptionalIndicators(parentEl, sugg, flairContainerEl);
|
|
this.renderIndicator(flairContainerEl, ['qsp-headings-indicator'], null, HeadingIndicators[item.level]);
|
|
if (sugg.downranked) {
|
|
parentEl.addClass('mod-downranked');
|
|
}
|
|
handled = true;
|
|
}
|
|
return handled;
|
|
}
|
|
getSuggestions(inputInfo) {
|
|
let suggestions = [];
|
|
if (inputInfo) {
|
|
inputInfo.buildSearchQuery();
|
|
const { hasSearchTerm } = inputInfo.searchQuery;
|
|
if (hasSearchTerm) {
|
|
const { limit } = this.settings;
|
|
suggestions = this.getAllFilesSuggestions(inputInfo);
|
|
obsidian.sortSearchResults(suggestions);
|
|
if (suggestions.length > 0 && limit > 0) {
|
|
suggestions = suggestions.slice(0, limit);
|
|
}
|
|
}
|
|
else {
|
|
suggestions = this.getInitialSuggestionList(inputInfo);
|
|
}
|
|
}
|
|
return suggestions;
|
|
}
|
|
getAllFilesSuggestions(inputInfo) {
|
|
const suggestions = [];
|
|
const { prepQuery } = inputInfo.searchQuery;
|
|
const { app: { vault }, settings: { strictHeadingsOnly, showExistingOnly, shouldSearchBookmarks, excludeFolders, }, } = this;
|
|
const isExcludedFolder = matcherFnForRegExList(excludeFolders);
|
|
let nodes = [vault.getRoot()];
|
|
while (nodes.length > 0) {
|
|
const node = nodes.pop();
|
|
if (isTFile(node)) {
|
|
this.addSuggestionsFromFile(inputInfo, suggestions, node, prepQuery);
|
|
}
|
|
else if (!isExcludedFolder(node.path)) {
|
|
nodes = nodes.concat(node.children);
|
|
}
|
|
}
|
|
if (!strictHeadingsOnly) {
|
|
if (shouldSearchBookmarks) {
|
|
inputInfo.currentWorkspaceEnvList.nonFileBookmarks?.forEach((bInfo) => {
|
|
this.addBookmarkSuggestion(inputInfo, suggestions, prepQuery, bInfo);
|
|
});
|
|
}
|
|
if (!showExistingOnly) {
|
|
this.addUnresolvedSuggestions(suggestions, prepQuery);
|
|
}
|
|
}
|
|
return suggestions;
|
|
}
|
|
addSuggestionsFromFile(inputInfo, suggestions, file, prepQuery) {
|
|
const { currentWorkspaceEnvList } = inputInfo;
|
|
const { searchAllHeadings, strictHeadingsOnly, shouldSearchFilenames, shouldSearchBookmarks, shouldShowAlias, } = this.settings;
|
|
if (this.shouldIncludeFile(file)) {
|
|
const isH1Matched = this.addHeadingSuggestions(inputInfo, suggestions, prepQuery, file, searchAllHeadings);
|
|
if (!strictHeadingsOnly) {
|
|
if (shouldSearchFilenames || !isH1Matched) {
|
|
// if strict is disabled and filename search is enabled or there
|
|
// isn't an H1 match, then do a fallback search against the filename, then path
|
|
this.addFileSuggestions(inputInfo, suggestions, prepQuery, file);
|
|
}
|
|
if (shouldShowAlias) {
|
|
this.addAliasSuggestions(inputInfo, suggestions, prepQuery, file);
|
|
}
|
|
}
|
|
}
|
|
const isBookmarked = currentWorkspaceEnvList.fileBookmarks?.has(file);
|
|
if (isBookmarked && shouldSearchBookmarks && !strictHeadingsOnly) {
|
|
const bookmarkInfo = currentWorkspaceEnvList.fileBookmarks.get(file);
|
|
this.addBookmarkSuggestion(inputInfo, suggestions, prepQuery, bookmarkInfo);
|
|
}
|
|
}
|
|
shouldIncludeFile(file) {
|
|
let isIncluded = false;
|
|
const { settings: { excludeObsidianIgnoredFiles, builtInSystemOptions: { showAttachments, showAllFileTypes }, fileExtAllowList, }, app: { viewRegistry, metadataCache }, } = this;
|
|
if (isTFile(file)) {
|
|
const { extension } = file;
|
|
if (!metadataCache.isUserIgnored(file.path) || !excludeObsidianIgnoredFiles) {
|
|
isIncluded = viewRegistry.isExtensionRegistered(extension)
|
|
? showAttachments || extension === 'md'
|
|
: showAllFileTypes;
|
|
if (!isIncluded) {
|
|
const allowList = new Set(fileExtAllowList);
|
|
isIncluded = allowList.has(extension);
|
|
}
|
|
}
|
|
}
|
|
return isIncluded;
|
|
}
|
|
addAliasSuggestions(inputInfo, suggestions, prepQuery, file) {
|
|
const { metadataCache } = this.app;
|
|
const frontMatter = metadataCache.getFileCache(file)?.frontmatter;
|
|
if (frontMatter) {
|
|
const aliases = FrontMatterParser.getAliases(frontMatter);
|
|
let i = aliases.length;
|
|
// create suggestions where there is a match with an alias
|
|
while (i--) {
|
|
const alias = aliases[i];
|
|
const { match } = this.fuzzySearchWithFallback(prepQuery, alias);
|
|
if (match) {
|
|
suggestions.push(this.createAliasSuggestion(inputInfo, alias, file, match));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
addFileSuggestions(inputInfo, suggestions, prepQuery, file) {
|
|
const { match, matchType, matchText } = this.fuzzySearchWithFallback(prepQuery, null, file);
|
|
if (match) {
|
|
suggestions.push(this.createFileSuggestion(inputInfo, file, match, matchType, matchText));
|
|
}
|
|
}
|
|
addBookmarkSuggestion(inputInfo, suggestions, prepQuery, bookmarkInfo) {
|
|
const result = this.fuzzySearchWithFallback(prepQuery, bookmarkInfo.bookmarkPath);
|
|
if (result.match) {
|
|
const sugg = BookmarksHandler.createSuggestion(inputInfo.currentWorkspaceEnvList, bookmarkInfo, this.settings, this.app.metadataCache, result);
|
|
suggestions.push(sugg);
|
|
}
|
|
}
|
|
addHeadingSuggestions(inputInfo, suggestions, prepQuery, file, allHeadings) {
|
|
const { metadataCache } = this.app;
|
|
const headingList = metadataCache.getFileCache(file)?.headings ?? [];
|
|
let h1 = null;
|
|
let isH1Matched = false;
|
|
let i = headingList.length;
|
|
while (i--) {
|
|
const heading = headingList[i];
|
|
let isMatched = false;
|
|
if (allHeadings) {
|
|
isMatched = this.matchAndPushHeading(inputInfo, suggestions, prepQuery, file, heading);
|
|
}
|
|
if (heading.level === 1) {
|
|
const { line } = heading.position.start;
|
|
if (h1 === null || line < h1.position.start.line) {
|
|
h1 = heading;
|
|
isH1Matched = isMatched;
|
|
}
|
|
}
|
|
}
|
|
if (!allHeadings && h1) {
|
|
isH1Matched = this.matchAndPushHeading(inputInfo, suggestions, prepQuery, file, h1);
|
|
}
|
|
return isH1Matched;
|
|
}
|
|
matchAndPushHeading(inputInfo, suggestions, prepQuery, file, heading) {
|
|
const { match } = this.fuzzySearchWithFallback(prepQuery, heading.heading);
|
|
if (match) {
|
|
suggestions.push(this.createHeadingSuggestion(inputInfo, heading, file, match));
|
|
}
|
|
return !!match;
|
|
}
|
|
addUnresolvedSuggestions(suggestions, prepQuery) {
|
|
const { metadataCache } = this.app;
|
|
const { unresolvedLinks } = metadataCache;
|
|
const unresolvedSet = new Set();
|
|
const sources = Object.keys(unresolvedLinks);
|
|
let i = sources.length;
|
|
// create a distinct list of unresolved links
|
|
while (i--) {
|
|
// each source has an object with keys that represent the list of unresolved links
|
|
// for that source file
|
|
const sourcePath = sources[i];
|
|
const links = Object.keys(unresolvedLinks[sourcePath]);
|
|
let j = links.length;
|
|
while (j--) {
|
|
// unresolved links can be duplicates, use a Set to get a distinct list
|
|
unresolvedSet.add(links[j]);
|
|
}
|
|
}
|
|
const unresolvedList = Array.from(unresolvedSet);
|
|
i = unresolvedList.length;
|
|
// create suggestions where there is a match with an unresolved link
|
|
while (i--) {
|
|
const unresolved = unresolvedList[i];
|
|
const result = this.fuzzySearchWithFallback(prepQuery, unresolved);
|
|
if (result.matchType !== MatchType.None) {
|
|
suggestions.push(StandardExHandler.createUnresolvedSuggestion(unresolved, result, this.settings, metadataCache));
|
|
}
|
|
}
|
|
}
|
|
createAliasSuggestion(inputInfo, alias, file, match) {
|
|
let sugg = {
|
|
alias,
|
|
file,
|
|
...this.createSearchMatch(match, MatchType.Primary, alias),
|
|
type: SuggestionType.Alias,
|
|
};
|
|
sugg = Handler.updateWorkspaceEnvListStatus(inputInfo.currentWorkspaceEnvList, sugg);
|
|
return this.applyMatchPriorityPreferences(sugg);
|
|
}
|
|
createFileSuggestion(inputInfo, file, match, matchType = MatchType.None, matchText = null) {
|
|
let sugg = {
|
|
file,
|
|
match,
|
|
matchType,
|
|
matchText,
|
|
type: SuggestionType.File,
|
|
};
|
|
sugg = Handler.updateWorkspaceEnvListStatus(inputInfo.currentWorkspaceEnvList, sugg);
|
|
return this.applyMatchPriorityPreferences(sugg);
|
|
}
|
|
createHeadingSuggestion(inputInfo, item, file, match) {
|
|
let sugg = {
|
|
item,
|
|
file,
|
|
...this.createSearchMatch(match, MatchType.Primary, item.heading),
|
|
type: SuggestionType.HeadingsList,
|
|
};
|
|
sugg = Handler.updateWorkspaceEnvListStatus(inputInfo.currentWorkspaceEnvList, sugg);
|
|
return this.applyMatchPriorityPreferences(sugg);
|
|
}
|
|
createSearchMatch(match, type, text) {
|
|
let matchType = MatchType.None;
|
|
let matchText = null;
|
|
if (match) {
|
|
matchType = type;
|
|
matchText = text;
|
|
}
|
|
return {
|
|
match,
|
|
matchType,
|
|
matchText,
|
|
};
|
|
}
|
|
getRecentFilesSuggestions(inputInfo) {
|
|
const suggestions = [];
|
|
const files = inputInfo?.currentWorkspaceEnvList?.mostRecentFiles;
|
|
files?.forEach((file) => {
|
|
if (this.shouldIncludeFile(file)) {
|
|
const h1 = this.getFirstH1(file);
|
|
const sugg = h1
|
|
? this.createHeadingSuggestion(inputInfo, h1, file, null)
|
|
: this.createFileSuggestion(inputInfo, file, null);
|
|
sugg.isRecent = true;
|
|
suggestions.push(sugg);
|
|
}
|
|
});
|
|
return suggestions;
|
|
}
|
|
getOpenEditorSuggestions(inputInfo) {
|
|
const suggestions = [];
|
|
const leaves = inputInfo?.currentWorkspaceEnvList?.openWorkspaceLeaves;
|
|
const { settings, app: { metadataCache }, } = this;
|
|
leaves?.forEach((leaf) => {
|
|
const file = leaf.view?.file;
|
|
const preferredTitle = EditorHandler.getPreferredTitle(leaf, settings.preferredSourceForTitle, metadataCache);
|
|
const sugg = EditorHandler.createSuggestion(inputInfo.currentWorkspaceEnvList, leaf, file, settings, this.app.metadataCache, preferredTitle);
|
|
suggestions.push(sugg);
|
|
});
|
|
return suggestions;
|
|
}
|
|
getInitialSuggestionList(inputInfo) {
|
|
const openEditors = this.getOpenEditorSuggestions(inputInfo);
|
|
const recentFiles = this.getRecentFilesSuggestions(inputInfo);
|
|
return [...openEditors, ...recentFiles];
|
|
}
|
|
onNoResultsCreateAction(inputInfo, evt) {
|
|
const filename = inputInfo.parsedCommand(Mode.HeadingsList)?.parsedInput;
|
|
this.createFile(filename, evt);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
const CANVAS_ICON_MAP = {
|
|
file: 'lucide-file-text',
|
|
text: 'lucide-sticky-note',
|
|
link: 'lucide-globe',
|
|
group: 'create-group',
|
|
};
|
|
class SymbolHandler extends Handler {
|
|
getCommandString(sessionOpts) {
|
|
const { settings } = this;
|
|
return sessionOpts?.useActiveEditorAsSource
|
|
? settings.symbolListActiveEditorCommand
|
|
: settings.symbolListCommand;
|
|
}
|
|
validateCommand(inputInfo, index, filterText, activeSuggestion, activeLeaf) {
|
|
const cmd = inputInfo.parsedCommand(Mode.SymbolList);
|
|
const sourceInfo = this.getSourceInfoForSymbolOperation(activeSuggestion, activeLeaf, index === 0, inputInfo.sessionOpts);
|
|
if (sourceInfo) {
|
|
inputInfo.mode = Mode.SymbolList;
|
|
cmd.source = sourceInfo;
|
|
cmd.index = index;
|
|
cmd.parsedInput = filterText;
|
|
cmd.isValidated = true;
|
|
}
|
|
return cmd;
|
|
}
|
|
async getSuggestions(inputInfo) {
|
|
const suggestions = [];
|
|
if (inputInfo) {
|
|
this.inputInfo = inputInfo;
|
|
inputInfo.buildSearchQuery();
|
|
const { hasSearchTerm, prepQuery } = inputInfo.searchQuery;
|
|
const symbolCmd = inputInfo.parsedCommand(Mode.SymbolList);
|
|
const items = await this.getItems(symbolCmd.source, hasSearchTerm);
|
|
items.forEach((item) => {
|
|
let shouldPush = true;
|
|
let match = null;
|
|
if (hasSearchTerm) {
|
|
match = obsidian.fuzzySearch(prepQuery, SymbolHandler.getSuggestionTextForSymbol(item));
|
|
shouldPush = !!match;
|
|
}
|
|
if (shouldPush) {
|
|
const { file } = symbolCmd.source;
|
|
suggestions.push({ type: SuggestionType.SymbolList, file, item, match });
|
|
}
|
|
});
|
|
if (hasSearchTerm) {
|
|
obsidian.sortSearchResults(suggestions);
|
|
}
|
|
}
|
|
return suggestions;
|
|
}
|
|
renderSuggestion(sugg, parentEl) {
|
|
let handled = false;
|
|
if (sugg) {
|
|
const { item } = sugg;
|
|
const parentElClasses = ['qsp-suggestion-symbol'];
|
|
if (Object.prototype.hasOwnProperty.call(item, 'indentLevel') &&
|
|
this.settings.symbolsInLineOrder &&
|
|
!this.inputInfo?.searchQuery?.hasSearchTerm) {
|
|
parentElClasses.push(`qsp-symbol-l${item.indentLevel}`);
|
|
}
|
|
this.addClassesToSuggestionContainer(parentEl, parentElClasses);
|
|
const text = SymbolHandler.getSuggestionTextForSymbol(item);
|
|
this.renderContent(parentEl, text, sugg.match);
|
|
this.addSymbolIndicator(item, parentEl);
|
|
handled = true;
|
|
}
|
|
return handled;
|
|
}
|
|
onChooseSuggestion(sugg, evt) {
|
|
let handled = false;
|
|
if (sugg) {
|
|
const symbolCmd = this.inputInfo.parsedCommand();
|
|
const { leaf, file } = symbolCmd.source;
|
|
const openState = { active: true };
|
|
const { item } = sugg;
|
|
if (item.symbolType !== SymbolType.CanvasNode) {
|
|
openState.eState = this.constructMDFileNavigationState(item).eState;
|
|
}
|
|
this.navigateToLeafOrOpenFileAsync(evt, file, openState, leaf, Mode.SymbolList).then(() => {
|
|
const { symbol } = item;
|
|
if (SymbolHandler.isCanvasSymbolPayload(item, symbol)) {
|
|
this.zoomToCanvasNode(this.getActiveLeaf().view, symbol);
|
|
}
|
|
}, (reason) => {
|
|
console.log(`Switcher++: Unable to navigate to symbols for file ${file.path}`, reason);
|
|
});
|
|
handled = true;
|
|
}
|
|
return handled;
|
|
}
|
|
reset() {
|
|
this.inputInfo = null;
|
|
}
|
|
getAvailableFacets(inputInfo) {
|
|
const cmd = inputInfo.parsedCommand(Mode.SymbolList);
|
|
const isCanvasFile = SymbolHandler.isCanvasFile(cmd?.source?.file);
|
|
const facets = this.getFacets(inputInfo.mode);
|
|
const canvasFacetIds = new Set(Object.values(CANVAS_NODE_FACET_ID_MAP));
|
|
// get only the string values of SymbolType as they are used as the face ids
|
|
const mdFacetIds = new Set(Object.values(SymbolType).filter((v) => isNaN(Number(v))));
|
|
facets.forEach((facet) => {
|
|
const { id } = facet;
|
|
facet.isAvailable = isCanvasFile ? canvasFacetIds.has(id) : mdFacetIds.has(id);
|
|
});
|
|
return facets.filter((v) => v.isAvailable);
|
|
}
|
|
zoomToCanvasNode(view, nodeData) {
|
|
if (SymbolHandler.isCanvasView(view)) {
|
|
const canvas = view.canvas;
|
|
const node = canvas.nodes.get(nodeData.id);
|
|
canvas.selectOnly(node);
|
|
canvas.zoomToSelection();
|
|
}
|
|
}
|
|
constructMDFileNavigationState(symbolInfo) {
|
|
const { start: { line, col }, end: endLoc, } = symbolInfo.symbol.position;
|
|
// object containing the state information for the target editor,
|
|
// start with the range to highlight in target editor
|
|
return {
|
|
eState: {
|
|
active: true,
|
|
focus: true,
|
|
startLoc: { line, col },
|
|
endLoc,
|
|
line,
|
|
cursor: {
|
|
from: { line, ch: col },
|
|
to: { line, ch: col },
|
|
},
|
|
},
|
|
};
|
|
}
|
|
getSourceInfoForSymbolOperation(activeSuggestion, activeLeaf, isSymbolCmdPrefix, sessionOpts) {
|
|
const prevInputInfo = this.inputInfo;
|
|
let prevSourceInfo = null;
|
|
let prevMode = Mode.Standard;
|
|
if (prevInputInfo) {
|
|
prevSourceInfo = prevInputInfo.parsedCommand().source;
|
|
prevMode = prevInputInfo.mode;
|
|
}
|
|
// figure out if the previous operation was a symbol operation
|
|
const hasPrevSymbolSource = prevMode === Mode.SymbolList && !!prevSourceInfo;
|
|
const activeEditorInfo = this.getEditorInfo(activeLeaf);
|
|
const activeSuggInfo = this.getSuggestionInfo(activeSuggestion);
|
|
// Pick the source file for a potential symbol operation, prioritizing
|
|
// any pre-existing symbol operation that was in progress
|
|
let sourceInfo = null;
|
|
if (hasPrevSymbolSource) {
|
|
sourceInfo = prevSourceInfo;
|
|
}
|
|
else if (activeSuggInfo.isValidSource && !sessionOpts.useActiveEditorAsSource) {
|
|
sourceInfo = activeSuggInfo;
|
|
}
|
|
else if (activeEditorInfo.isValidSource && isSymbolCmdPrefix) {
|
|
// Check isSymbolCmdPrefix to prevent the case where an embedded command would
|
|
// trigger this mode for the active editor.
|
|
sourceInfo = activeEditorInfo;
|
|
}
|
|
return sourceInfo;
|
|
}
|
|
async getItems(sourceInfo, hasSearchTerm) {
|
|
let items = [];
|
|
let symbolsInLineOrder = false;
|
|
let selectNearestHeading = false;
|
|
if (!hasSearchTerm) {
|
|
({ selectNearestHeading, symbolsInLineOrder } = this.settings);
|
|
}
|
|
items = await this.getSymbolsFromSource(sourceInfo, symbolsInLineOrder);
|
|
if (selectNearestHeading) {
|
|
SymbolHandler.FindNearestHeadingSymbol(items, sourceInfo);
|
|
}
|
|
return items;
|
|
}
|
|
static FindNearestHeadingSymbol(items, sourceInfo) {
|
|
const cursorLine = sourceInfo?.cursor?.line;
|
|
// find the nearest heading to the current cursor pos, if applicable
|
|
if (cursorLine) {
|
|
let found = null;
|
|
const headings = items.filter((v) => isHeadingCache(v.symbol));
|
|
if (headings.length) {
|
|
found = headings.reduce((acc, curr) => {
|
|
const { line: currLine } = curr.symbol.position.start;
|
|
const accLine = acc ? acc.symbol.position.start.line : -1;
|
|
return currLine > accLine && currLine <= cursorLine ? curr : acc;
|
|
});
|
|
}
|
|
if (found) {
|
|
found.isSelected = true;
|
|
}
|
|
}
|
|
}
|
|
async getSymbolsFromSource(sourceInfo, orderByLineNumber) {
|
|
const { app: { metadataCache }, inputInfo, } = this;
|
|
const ret = [];
|
|
if (sourceInfo?.file) {
|
|
const { file } = sourceInfo;
|
|
const activeFacetIds = this.getActiveFacetIds(inputInfo);
|
|
if (SymbolHandler.isCanvasFile(file)) {
|
|
await this.addCanvasSymbolsFromSource(file, ret, activeFacetIds);
|
|
}
|
|
else {
|
|
const symbolData = metadataCache.getFileCache(file);
|
|
if (symbolData) {
|
|
const push = (symbols = [], symbolType) => {
|
|
if (this.shouldIncludeSymbol(symbolType, activeFacetIds)) {
|
|
symbols.forEach((symbol) => ret.push({ type: 'symbolInfo', symbol, symbolType }));
|
|
}
|
|
};
|
|
push(symbolData.headings, SymbolType.Heading);
|
|
push(symbolData.tags, SymbolType.Tag);
|
|
this.addLinksFromSource(symbolData.links, ret, activeFacetIds);
|
|
push(symbolData.embeds, SymbolType.Embed);
|
|
await this.addCalloutsFromSource(file, symbolData.sections?.filter((v) => v.type === 'callout'), ret, activeFacetIds);
|
|
if (orderByLineNumber) {
|
|
SymbolHandler.orderSymbolsByLineNumber(ret);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
shouldIncludeSymbol(symbolType, activeFacetIds) {
|
|
let shouldInclude = false;
|
|
if (typeof symbolType === 'string') {
|
|
shouldInclude = this.isFacetedWith(activeFacetIds, symbolType);
|
|
}
|
|
else {
|
|
shouldInclude =
|
|
this.settings.isSymbolTypeEnabled(symbolType) &&
|
|
this.isFacetedWith(activeFacetIds, SymbolType[symbolType]);
|
|
}
|
|
return shouldInclude;
|
|
}
|
|
async addCanvasSymbolsFromSource(file, symbolList, activeFacetIds) {
|
|
let canvasNodes;
|
|
try {
|
|
const fileContent = await this.app.vault.cachedRead(file);
|
|
canvasNodes = JSON.parse(fileContent).nodes;
|
|
}
|
|
catch (e) {
|
|
console.log(`Switcher++: error reading file to extract canvas node information. ${file.path} `, e);
|
|
}
|
|
if (Array.isArray(canvasNodes)) {
|
|
canvasNodes.forEach((node) => {
|
|
if (this.shouldIncludeSymbol(CANVAS_NODE_FACET_ID_MAP[node.type], activeFacetIds)) {
|
|
symbolList.push({
|
|
type: 'symbolInfo',
|
|
symbolType: SymbolType.CanvasNode,
|
|
symbol: { ...node },
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}
|
|
async addCalloutsFromSource(file, sectionCache, symbolList, activeFacetIds) {
|
|
const { app: { vault }, } = this;
|
|
const shouldInclude = this.shouldIncludeSymbol(SymbolType.Callout, activeFacetIds);
|
|
if (shouldInclude && sectionCache?.length && file) {
|
|
let fileContent = null;
|
|
try {
|
|
fileContent = await vault.cachedRead(file);
|
|
}
|
|
catch (e) {
|
|
console.log(`Switcher++: error reading file to extract callout information. ${file.path} `, e);
|
|
}
|
|
if (fileContent) {
|
|
for (const cache of sectionCache) {
|
|
const { start, end } = cache.position;
|
|
const calloutStr = fileContent.slice(start.offset, end.offset);
|
|
const match = calloutStr.match(/^> \[!([^\]]+)\][+-]?(.*?)(?:\n>|$)/);
|
|
if (match) {
|
|
const calloutType = match[1];
|
|
const calloutTitle = match[match.length - 1];
|
|
const symbol = {
|
|
calloutTitle: calloutTitle.trim(),
|
|
calloutType,
|
|
...cache,
|
|
};
|
|
symbolList.push({
|
|
type: 'symbolInfo',
|
|
symbolType: SymbolType.Callout,
|
|
symbol,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
addLinksFromSource(linkData, symbolList, activeFacetIds) {
|
|
const { settings } = this;
|
|
linkData = linkData ?? [];
|
|
if (this.shouldIncludeSymbol(SymbolType.Link, activeFacetIds)) {
|
|
for (const link of linkData) {
|
|
const type = getLinkType(link);
|
|
const isExcluded = (settings.excludeLinkSubTypes & type) === type;
|
|
if (!isExcluded) {
|
|
symbolList.push({
|
|
type: 'symbolInfo',
|
|
symbol: link,
|
|
symbolType: SymbolType.Link,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
static orderSymbolsByLineNumber(symbols) {
|
|
const sorted = symbols.sort((a, b) => {
|
|
const { start: aStart } = a.symbol.position;
|
|
const { start: bStart } = b.symbol.position;
|
|
const lineDiff = aStart.line - bStart.line;
|
|
return lineDiff === 0 ? aStart.col - bStart.col : lineDiff;
|
|
});
|
|
let currIndentLevel = 0;
|
|
sorted.forEach((si) => {
|
|
let indentLevel = 0;
|
|
if (isHeadingCache(si.symbol)) {
|
|
currIndentLevel = si.symbol.level;
|
|
indentLevel = si.symbol.level - 1;
|
|
}
|
|
else {
|
|
indentLevel = currIndentLevel;
|
|
}
|
|
si.indentLevel = indentLevel;
|
|
});
|
|
return sorted;
|
|
}
|
|
static getSuggestionTextForSymbol(symbolInfo) {
|
|
const { symbol } = symbolInfo;
|
|
let text;
|
|
if (isHeadingCache(symbol)) {
|
|
text = symbol.heading;
|
|
}
|
|
else if (isTagCache(symbol)) {
|
|
text = symbol.tag.slice(1);
|
|
}
|
|
else if (isCalloutCache(symbol)) {
|
|
text = symbol.calloutTitle;
|
|
}
|
|
else if (SymbolHandler.isCanvasSymbolPayload(symbolInfo, symbol)) {
|
|
text = SymbolHandler.getSuggestionTextForCanvasNode(symbol);
|
|
}
|
|
else {
|
|
const refCache = symbol;
|
|
({ link: text } = refCache);
|
|
const { displayText } = refCache;
|
|
if (displayText && displayText !== text) {
|
|
text += `|${displayText}`;
|
|
}
|
|
}
|
|
return text;
|
|
}
|
|
static getSuggestionTextForCanvasNode(node) {
|
|
let text = '';
|
|
const accessors = {
|
|
file: () => node.file,
|
|
text: () => node.text,
|
|
link: () => node.url,
|
|
group: () => node.label,
|
|
};
|
|
const fn = accessors[node?.type];
|
|
if (fn) {
|
|
text = fn();
|
|
}
|
|
return text;
|
|
}
|
|
addSymbolIndicator(symbolInfo, parentEl) {
|
|
const { symbolType, symbol } = symbolInfo;
|
|
const flairElClasses = ['qsp-symbol-indicator'];
|
|
const flairContainerEl = this.createFlairContainer(parentEl);
|
|
if (isCalloutCache(symbol)) {
|
|
flairElClasses.push(...['suggestion-flair', 'callout', 'callout-icon', 'svg-icon']);
|
|
const calloutFlairEl = flairContainerEl.createSpan({
|
|
cls: flairElClasses,
|
|
// Obsidian 0.15.9: the icon glyph is set in css based on the data-callout attr
|
|
attr: { 'data-callout': symbol.calloutType },
|
|
});
|
|
// Obsidian 0.15.9 the --callout-icon css prop holds the name of the icon glyph
|
|
const iconName = calloutFlairEl.getCssPropertyValue('--callout-icon');
|
|
obsidian.setIcon(calloutFlairEl, iconName);
|
|
}
|
|
else if (SymbolHandler.isCanvasSymbolPayload(symbolInfo, symbol)) {
|
|
const icon = CANVAS_ICON_MAP[symbol.type];
|
|
this.renderIndicator(flairContainerEl, flairElClasses, icon, null);
|
|
}
|
|
else {
|
|
let indicator;
|
|
if (isHeadingCache(symbol)) {
|
|
indicator = HeadingIndicators[symbol.level];
|
|
}
|
|
else {
|
|
indicator = SymbolIndicators[symbolType];
|
|
}
|
|
this.renderIndicator(flairContainerEl, flairElClasses, null, indicator);
|
|
}
|
|
}
|
|
static isCanvasSymbolPayload(symbolInfo, payload) {
|
|
return symbolInfo.symbolType === SymbolType.CanvasNode;
|
|
}
|
|
static isCanvasFile(sourceFile) {
|
|
return sourceFile?.extension === 'canvas';
|
|
}
|
|
static isCanvasView(view) {
|
|
return view?.getViewType() === 'canvas';
|
|
}
|
|
}
|
|
|
|
const COMMAND_PALETTE_PLUGIN_ID = 'command-palette';
|
|
const RECENTLY_USED_COMMAND_IDS = [];
|
|
class CommandHandler extends Handler {
|
|
getCommandString(_sessionOpts) {
|
|
return this.settings?.commandListCommand;
|
|
}
|
|
validateCommand(inputInfo, index, filterText, _activeSuggestion, _activeLeaf) {
|
|
inputInfo.mode = Mode.CommandList;
|
|
const cmd = inputInfo.parsedCommand(Mode.CommandList);
|
|
cmd.index = index;
|
|
cmd.parsedInput = filterText;
|
|
cmd.isValidated = true;
|
|
return cmd;
|
|
}
|
|
getSuggestions(inputInfo) {
|
|
const suggestions = [];
|
|
if (inputInfo) {
|
|
inputInfo.buildSearchQuery();
|
|
const { hasSearchTerm, prepQuery } = inputInfo.searchQuery;
|
|
const itemsInfo = this.getItems(hasSearchTerm, RECENTLY_USED_COMMAND_IDS);
|
|
itemsInfo.forEach((info) => {
|
|
let shouldPush = true;
|
|
let match = null;
|
|
if (hasSearchTerm) {
|
|
match = obsidian.fuzzySearch(prepQuery, info.cmd.name);
|
|
shouldPush = !!match;
|
|
}
|
|
if (shouldPush) {
|
|
suggestions.push(this.createSuggestion(info, match));
|
|
}
|
|
});
|
|
if (hasSearchTerm) {
|
|
obsidian.sortSearchResults(suggestions);
|
|
}
|
|
}
|
|
return suggestions;
|
|
}
|
|
renderSuggestion(sugg, parentEl) {
|
|
let handled = false;
|
|
if (sugg) {
|
|
const { item, match, isPinned, isRecent } = sugg;
|
|
this.addClassesToSuggestionContainer(parentEl, ['qsp-suggestion-command']);
|
|
this.renderContent(parentEl, item.name, match);
|
|
const flairContainerEl = this.createFlairContainer(parentEl);
|
|
this.renderHotkeyForCommand(item.id, this.app, flairContainerEl);
|
|
if (item.icon) {
|
|
this.renderIndicator(flairContainerEl, [], item.icon);
|
|
}
|
|
if (isPinned) {
|
|
this.renderIndicator(flairContainerEl, [], 'filled-pin');
|
|
}
|
|
else if (isRecent) {
|
|
this.renderOptionalIndicators(parentEl, sugg, flairContainerEl);
|
|
}
|
|
handled = true;
|
|
}
|
|
return handled;
|
|
}
|
|
renderHotkeyForCommand(id, app, flairContainerEl) {
|
|
try {
|
|
const { hotkeyManager } = app;
|
|
if (hotkeyManager.getHotkeys(id) || hotkeyManager.getDefaultHotkeys(id)) {
|
|
const hotkeyStr = hotkeyManager.printHotkeyForCommand(id);
|
|
if (hotkeyStr?.length) {
|
|
flairContainerEl.createEl('kbd', {
|
|
cls: 'suggestion-hotkey',
|
|
text: hotkeyStr,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
catch (err) {
|
|
console.log('Switcher++: error rendering hotkey for command id: ', id, err);
|
|
}
|
|
}
|
|
onChooseSuggestion(sugg) {
|
|
let handled = false;
|
|
if (sugg) {
|
|
const { item } = sugg;
|
|
this.app.commands.executeCommandById(item.id);
|
|
this.saveUsageToList(item.id, RECENTLY_USED_COMMAND_IDS);
|
|
handled = true;
|
|
}
|
|
return handled;
|
|
}
|
|
saveUsageToList(commandId, recentCommandIds) {
|
|
if (recentCommandIds) {
|
|
const oldIndex = recentCommandIds.indexOf(commandId);
|
|
if (oldIndex > -1) {
|
|
recentCommandIds.splice(oldIndex, 1);
|
|
}
|
|
recentCommandIds.unshift(commandId);
|
|
recentCommandIds.splice(25);
|
|
}
|
|
}
|
|
getItems(includeAllCommands, recentCommandIds) {
|
|
const { app } = this;
|
|
const items = includeAllCommands
|
|
? this.getAllCommandsList(app, recentCommandIds)
|
|
: this.getInitialCommandList(app, recentCommandIds);
|
|
return items ?? [];
|
|
}
|
|
getAllCommandsList(app, recentCommandIds) {
|
|
const pinnedIdsSet = this.getPinnedCommandIds();
|
|
const recentIdsSet = new Set(recentCommandIds);
|
|
return app.commands
|
|
.listCommands()
|
|
?.sort((a, b) => a.name.localeCompare(b.name))
|
|
.map((cmd) => {
|
|
return {
|
|
isPinned: pinnedIdsSet.has(cmd.id),
|
|
isRecent: recentIdsSet.has(cmd.id),
|
|
cmd,
|
|
};
|
|
});
|
|
}
|
|
getInitialCommandList(app, recentCommandIds) {
|
|
const commands = [];
|
|
const findAndAdd = (id, isPinned, isRecent) => {
|
|
const cmd = app.commands.findCommand(id);
|
|
if (cmd) {
|
|
commands.push({ isPinned, isRecent, cmd });
|
|
}
|
|
};
|
|
const pinnedCommandIds = this.getPinnedCommandIds();
|
|
pinnedCommandIds.forEach((id) => findAndAdd(id, true, false));
|
|
// remove any pinned commands from the recently used list so they don't show up in
|
|
// both pinned and recent sections
|
|
recentCommandIds
|
|
?.filter((v) => !pinnedCommandIds.has(v))
|
|
.forEach((id) => findAndAdd(id, false, true));
|
|
// if there are no pinned, and no recent items, show the whole list
|
|
return commands.length ? commands : this.getAllCommandsList(app, recentCommandIds);
|
|
}
|
|
getPinnedCommandIds() {
|
|
let pinnedCommandIds;
|
|
if (this.isCommandPalettePluginEnabled() &&
|
|
this.getCommandPalettePluginInstance()?.options.pinned?.length) {
|
|
pinnedCommandIds = new Set(this.getCommandPalettePluginInstance().options.pinned);
|
|
}
|
|
return pinnedCommandIds ?? new Set();
|
|
}
|
|
createSuggestion(commandInfo, match) {
|
|
const { cmd, isPinned, isRecent } = commandInfo;
|
|
const sugg = {
|
|
type: SuggestionType.CommandList,
|
|
item: cmd,
|
|
isPinned,
|
|
isRecent,
|
|
match,
|
|
};
|
|
return this.applyMatchPriorityPreferences(sugg);
|
|
}
|
|
isCommandPalettePluginEnabled() {
|
|
const plugin = this.getCommandPalettePlugin();
|
|
return plugin?.enabled;
|
|
}
|
|
getCommandPalettePlugin() {
|
|
return getInternalPluginById(this.app, COMMAND_PALETTE_PLUGIN_ID);
|
|
}
|
|
getCommandPalettePluginInstance() {
|
|
const commandPalettePlugin = this.getCommandPalettePlugin();
|
|
return commandPalettePlugin?.instance;
|
|
}
|
|
}
|
|
|
|
class RelatedItemsHandler extends Handler {
|
|
getCommandString(sessionOpts) {
|
|
const { settings } = this;
|
|
return sessionOpts?.useActiveEditorAsSource
|
|
? settings.relatedItemsListActiveEditorCommand
|
|
: settings.relatedItemsListCommand;
|
|
}
|
|
validateCommand(inputInfo, index, filterText, activeSuggestion, activeLeaf) {
|
|
const cmd = inputInfo.parsedCommand(Mode.RelatedItemsList);
|
|
const sourceInfo = this.getSourceInfo(activeSuggestion, activeLeaf, index === 0, inputInfo.sessionOpts);
|
|
if (sourceInfo) {
|
|
inputInfo.mode = Mode.RelatedItemsList;
|
|
cmd.source = sourceInfo;
|
|
cmd.index = index;
|
|
cmd.parsedInput = filterText;
|
|
cmd.isValidated = true;
|
|
}
|
|
return cmd;
|
|
}
|
|
getSuggestions(inputInfo) {
|
|
const suggestions = [];
|
|
if (inputInfo) {
|
|
this.inputInfo = inputInfo;
|
|
inputInfo.buildSearchQuery();
|
|
const { hasSearchTerm } = inputInfo.searchQuery;
|
|
const cmd = inputInfo.parsedCommand(Mode.RelatedItemsList);
|
|
const items = this.getItems(cmd.source, inputInfo);
|
|
items.forEach((item) => {
|
|
const sugg = this.searchAndCreateSuggestion(inputInfo, item);
|
|
if (sugg) {
|
|
suggestions.push(sugg);
|
|
}
|
|
});
|
|
if (hasSearchTerm) {
|
|
obsidian.sortSearchResults(suggestions);
|
|
}
|
|
}
|
|
return suggestions;
|
|
}
|
|
renderSuggestion(sugg, parentEl) {
|
|
let handled = false;
|
|
if (sugg) {
|
|
const { file, matchType, match, item } = sugg;
|
|
const iconMap = new Map([
|
|
[RelationType.Backlink, 'links-coming-in'],
|
|
[RelationType.DiskLocation, 'folder-tree'],
|
|
[RelationType.OutgoingLink, 'links-going-out'],
|
|
]);
|
|
parentEl.setAttribute('data-relation-type', item.relationType);
|
|
this.renderAsFileInfoPanel(parentEl, ['qsp-suggestion-related'], sugg.preferredTitle, file, matchType, match);
|
|
const flairContainerEl = this.renderOptionalIndicators(parentEl, sugg);
|
|
if (sugg.item.count) {
|
|
// show the count of backlinks
|
|
this.renderIndicator(flairContainerEl, [], null, `${sugg.item.count}`);
|
|
}
|
|
// render the flair icon
|
|
this.renderIndicator(flairContainerEl, ['qsp-related-indicator'], iconMap.get(item.relationType));
|
|
handled = true;
|
|
}
|
|
return handled;
|
|
}
|
|
onChooseSuggestion(sugg, evt) {
|
|
let handled = false;
|
|
if (sugg) {
|
|
const { file } = sugg;
|
|
this.navigateToLeafOrOpenFile(evt, file, `Unable to open related file ${file.path}`);
|
|
handled = true;
|
|
}
|
|
return handled;
|
|
}
|
|
getPreferredTitle(item, preferredSource) {
|
|
let text = null;
|
|
const { file, unresolvedText } = item;
|
|
if (file) {
|
|
if (preferredSource === 'H1') {
|
|
text = this.getFirstH1(file)?.heading ?? null;
|
|
}
|
|
}
|
|
else {
|
|
const isUnresolved = !!unresolvedText?.length;
|
|
if (isUnresolved) {
|
|
text = unresolvedText;
|
|
}
|
|
}
|
|
return text;
|
|
}
|
|
searchAndCreateSuggestion(inputInfo, item) {
|
|
const { file, unresolvedText } = item;
|
|
let result = { matchType: MatchType.None, match: null };
|
|
const isUnresolved = file === null && unresolvedText?.length;
|
|
const { currentWorkspaceEnvList, searchQuery: { hasSearchTerm, prepQuery }, } = inputInfo;
|
|
const { settings, app: { metadataCache }, } = this;
|
|
const preferredTitle = this.getPreferredTitle(item, settings.preferredSourceForTitle);
|
|
if (hasSearchTerm) {
|
|
result = this.fuzzySearchWithFallback(prepQuery, preferredTitle, file);
|
|
if (result.matchType === MatchType.None) {
|
|
return null;
|
|
}
|
|
}
|
|
return isUnresolved
|
|
? StandardExHandler.createUnresolvedSuggestion(preferredTitle, result, settings, metadataCache)
|
|
: this.createSuggestion(currentWorkspaceEnvList, item, result, preferredTitle);
|
|
}
|
|
getItems(sourceInfo, inputInfo) {
|
|
const relatedItems = [];
|
|
const { metadataCache } = this.app;
|
|
const { file, suggestion } = sourceInfo;
|
|
const enabledRelatedItems = new Set(this.settings.enabledRelatedItems);
|
|
const activeFacetIds = this.getActiveFacetIds(inputInfo);
|
|
const shouldIncludeRelation = (relationType) => {
|
|
return (enabledRelatedItems.has(relationType) &&
|
|
this.isFacetedWith(activeFacetIds, relationType));
|
|
};
|
|
if (shouldIncludeRelation(RelationType.Backlink)) {
|
|
let targetPath = file?.path;
|
|
let linkMap = metadataCache.resolvedLinks;
|
|
if (isUnresolvedSuggestion(suggestion)) {
|
|
targetPath = suggestion.linktext;
|
|
linkMap = metadataCache.unresolvedLinks;
|
|
}
|
|
this.addBacklinks(targetPath, linkMap, relatedItems);
|
|
}
|
|
if (shouldIncludeRelation(RelationType.DiskLocation)) {
|
|
this.addRelatedDiskFiles(file, relatedItems);
|
|
}
|
|
if (shouldIncludeRelation(RelationType.OutgoingLink)) {
|
|
this.addOutgoingLinks(file, relatedItems);
|
|
}
|
|
return relatedItems;
|
|
}
|
|
addRelatedDiskFiles(sourceFile, collection) {
|
|
const { excludeRelatedFolders, excludeOpenRelatedFiles } = this.settings;
|
|
if (sourceFile) {
|
|
const isExcludedFolder = matcherFnForRegExList(excludeRelatedFolders);
|
|
let nodes = [...sourceFile.parent.children];
|
|
while (nodes.length > 0) {
|
|
const node = nodes.pop();
|
|
if (isTFile(node)) {
|
|
const isSourceFile = node === sourceFile;
|
|
const isExcluded = isSourceFile ||
|
|
(excludeOpenRelatedFiles && !!this.findMatchingLeaf(node).leaf);
|
|
if (!isExcluded) {
|
|
collection.push({ file: node, relationType: RelationType.DiskLocation });
|
|
}
|
|
}
|
|
else if (!isExcludedFolder(node.path)) {
|
|
nodes = nodes.concat(node.children);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
addOutgoingLinks(sourceFile, collection) {
|
|
if (sourceFile) {
|
|
const destUnresolved = new Map();
|
|
const destFiles = new Map();
|
|
const { metadataCache } = this.app;
|
|
const outgoingLinks = metadataCache.getFileCache(sourceFile).links ?? [];
|
|
const incrementCount = (info) => info ? !!(info.count += 1) : false;
|
|
outgoingLinks.forEach((linkCache) => {
|
|
const destPath = linkCache.link;
|
|
const destFile = metadataCache.getFirstLinkpathDest(destPath, sourceFile.path);
|
|
let info;
|
|
if (destFile) {
|
|
if (!incrementCount(destFiles.get(destFile)) && destFile !== sourceFile) {
|
|
info = { file: destFile, relationType: RelationType.OutgoingLink, count: 1 };
|
|
destFiles.set(destFile, info);
|
|
collection.push(info);
|
|
}
|
|
}
|
|
else {
|
|
if (!incrementCount(destUnresolved.get(destPath))) {
|
|
info = {
|
|
file: null,
|
|
relationType: RelationType.OutgoingLink,
|
|
unresolvedText: destPath,
|
|
count: 1,
|
|
};
|
|
destUnresolved.set(destPath, info);
|
|
collection.push(info);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
addBacklinks(targetPath, linkMap, collection) {
|
|
for (const [originFilePath, destPathMap] of Object.entries(linkMap)) {
|
|
if (originFilePath !== targetPath &&
|
|
Object.prototype.hasOwnProperty.call(destPathMap, targetPath)) {
|
|
const count = destPathMap[targetPath];
|
|
const originFile = this.getTFileByPath(originFilePath);
|
|
if (originFile) {
|
|
collection.push({
|
|
count,
|
|
file: originFile,
|
|
relationType: RelationType.Backlink,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
reset() {
|
|
this.inputInfo = null;
|
|
}
|
|
getSourceInfo(activeSuggestion, activeLeaf, isPrefixCmd, sessionOpts) {
|
|
const prevInputInfo = this.inputInfo;
|
|
let prevSourceInfo = null;
|
|
let prevMode = Mode.Standard;
|
|
if (prevInputInfo) {
|
|
prevSourceInfo = prevInputInfo.parsedCommand().source;
|
|
prevMode = prevInputInfo.mode;
|
|
}
|
|
// figure out if the previous operation was a symbol operation
|
|
const hasPrevSource = prevMode === Mode.RelatedItemsList && !!prevSourceInfo;
|
|
const activeEditorInfo = this.getEditorInfo(activeLeaf);
|
|
const activeSuggInfo = this.getSuggestionInfo(activeSuggestion);
|
|
if (!activeSuggInfo.isValidSource && isUnresolvedSuggestion(activeSuggestion)) {
|
|
// related items supports retrieving backlinks for unresolved suggestion, so
|
|
// force UnresolvedSuggestion to be valid, even though it would otherwise not be
|
|
activeSuggInfo.isValidSource = true;
|
|
}
|
|
// Pick the source file for the operation, prioritizing
|
|
// any pre-existing operation that was in progress
|
|
let sourceInfo = null;
|
|
if (hasPrevSource) {
|
|
sourceInfo = prevSourceInfo;
|
|
}
|
|
else if (activeSuggInfo.isValidSource && !sessionOpts.useActiveEditorAsSource) {
|
|
sourceInfo = activeSuggInfo;
|
|
}
|
|
else if (activeEditorInfo.isValidSource && isPrefixCmd) {
|
|
sourceInfo = activeEditorInfo;
|
|
}
|
|
return sourceInfo;
|
|
}
|
|
createSuggestion(currentWorkspaceEnvList, item, result, preferredTitle) {
|
|
let sugg = {
|
|
item,
|
|
file: item?.file,
|
|
type: SuggestionType.RelatedItemsList,
|
|
preferredTitle,
|
|
...result,
|
|
};
|
|
sugg = Handler.updateWorkspaceEnvListStatus(currentWorkspaceEnvList, sugg);
|
|
return this.applyMatchPriorityPreferences(sugg);
|
|
}
|
|
}
|
|
|
|
class VaultHandler extends Handler {
|
|
constructor() {
|
|
super(...arguments);
|
|
this.mobileVaultChooserMarker = {
|
|
type: SuggestionType.VaultList,
|
|
match: null,
|
|
item: null,
|
|
pathSegments: null,
|
|
};
|
|
}
|
|
getCommandString(_sessionOpts) {
|
|
return this.settings?.vaultListCommand;
|
|
}
|
|
validateCommand(inputInfo, index, filterText, _activeSuggestion, _activeLeaf) {
|
|
inputInfo.mode = Mode.VaultList;
|
|
const cmd = inputInfo.parsedCommand(Mode.VaultList);
|
|
cmd.index = index;
|
|
cmd.parsedInput = filterText;
|
|
cmd.isValidated = true;
|
|
return cmd;
|
|
}
|
|
getSuggestions(inputInfo) {
|
|
const suggestions = [];
|
|
if (inputInfo) {
|
|
inputInfo.buildSearchQuery();
|
|
const { hasSearchTerm, prepQuery } = inputInfo.searchQuery;
|
|
const items = obsidian.Platform.isDesktop
|
|
? this.getItems()
|
|
: [this.mobileVaultChooserMarker];
|
|
items.forEach((item) => {
|
|
let shouldPush = true;
|
|
if (hasSearchTerm) {
|
|
const results = this.fuzzySearchWithFallback(prepQuery, null, item.pathSegments);
|
|
Object.assign(item, results);
|
|
shouldPush = !!results.match;
|
|
}
|
|
if (shouldPush) {
|
|
suggestions.push(item);
|
|
}
|
|
});
|
|
if (hasSearchTerm) {
|
|
obsidian.sortSearchResults(suggestions);
|
|
}
|
|
}
|
|
return suggestions;
|
|
}
|
|
renderSuggestion(sugg, parentEl) {
|
|
let handled = false;
|
|
if (sugg) {
|
|
this.addClassesToSuggestionContainer(parentEl, ['qsp-suggestion-vault']);
|
|
handled = true;
|
|
if (obsidian.Platform.isDesktop) {
|
|
this.renderVaultSuggestion(sugg, parentEl);
|
|
}
|
|
else if (sugg === this.mobileVaultChooserMarker) {
|
|
this.renderMobileHintSuggestion(parentEl);
|
|
}
|
|
}
|
|
return handled;
|
|
}
|
|
renderMobileHintSuggestion(parentEl) {
|
|
this.renderContent(parentEl, 'Show mobile vault chooser', null);
|
|
}
|
|
renderVaultSuggestion(sugg, parentEl) {
|
|
const { pathSegments, matchType } = sugg;
|
|
let { match } = sugg;
|
|
let basenameMatch = null;
|
|
if (matchType === MatchType.Basename) {
|
|
basenameMatch = match;
|
|
match = null;
|
|
}
|
|
const contentEl = this.renderContent(parentEl, pathSegments.basename, basenameMatch);
|
|
const wrapperEl = contentEl.createDiv({ cls: ['suggestion-note', 'qsp-note'] });
|
|
const iconEl = wrapperEl.createSpan({ cls: ['qsp-path-indicator'] });
|
|
const pathEl = wrapperEl.createSpan({ cls: 'qsp-path' });
|
|
obsidian.setIcon(iconEl, 'folder');
|
|
obsidian.renderResults(pathEl, pathSegments.path, match);
|
|
}
|
|
onChooseSuggestion(sugg, _evt) {
|
|
let handled = false;
|
|
if (sugg) {
|
|
if (obsidian.Platform.isDesktop) {
|
|
// 12/8/23: "vault-open" is the Obsidian defined channel for open a vault
|
|
handled = electron.ipcRenderer.sendSync('vault-open', sugg.pathSegments?.path, false);
|
|
}
|
|
else if (sugg === this.mobileVaultChooserMarker) {
|
|
// It's the mobile app context, show the vault chooser
|
|
this.app.openVaultChooser();
|
|
handled = true;
|
|
}
|
|
}
|
|
return handled;
|
|
}
|
|
getItems() {
|
|
const items = [];
|
|
try {
|
|
// 12/8/23: "vault-list" is the Obsidian defined channel for retrieving
|
|
// the vault list
|
|
const vaultData = electron.ipcRenderer.sendSync('vault-list');
|
|
if (vaultData) {
|
|
for (const [id, { path, open }] of Object.entries(vaultData)) {
|
|
const basename = filenameFromPath(path);
|
|
const sugg = {
|
|
type: SuggestionType.VaultList,
|
|
match: null,
|
|
item: id,
|
|
isOpen: !!open,
|
|
pathSegments: { basename, path },
|
|
};
|
|
items.push(sugg);
|
|
}
|
|
}
|
|
}
|
|
catch (err) {
|
|
console.log('Switcher++: error retrieving list of available vaults. ', err);
|
|
}
|
|
return items.sort((a, b) => a.pathSegments.basename.localeCompare(b.pathSegments.basename));
|
|
}
|
|
}
|
|
|
|
const lastInputInfoByMode = {};
|
|
class ModeHandler {
|
|
constructor(app, settings, exKeymap) {
|
|
this.app = app;
|
|
this.settings = settings;
|
|
this.exKeymap = exKeymap;
|
|
this.sessionOpts = {};
|
|
this.noResultActionModes = [Mode.HeadingsList, Mode.WorkspaceList];
|
|
// StandardExHandler one is special in that it is not a "full" handler,
|
|
// and not attached to a mode, as a result it is not in the handlersByMode list
|
|
const standardExHandler = new StandardExHandler(app, settings);
|
|
const handlersByMode = new Map([
|
|
[Mode.SymbolList, new SymbolHandler(app, settings)],
|
|
[Mode.WorkspaceList, new WorkspaceHandler(app, settings)],
|
|
[Mode.HeadingsList, new HeadingsHandler(app, settings)],
|
|
[Mode.EditorList, new EditorHandler(app, settings)],
|
|
[Mode.BookmarksList, new BookmarksHandler(app, settings)],
|
|
[Mode.CommandList, new CommandHandler(app, settings)],
|
|
[Mode.RelatedItemsList, new RelatedItemsHandler(app, settings)],
|
|
[Mode.VaultList, new VaultHandler(app, settings)],
|
|
]);
|
|
this.handlersByMode = handlersByMode;
|
|
this.handlersByType = new Map([
|
|
[SuggestionType.CommandList, handlersByMode.get(Mode.CommandList)],
|
|
[SuggestionType.EditorList, handlersByMode.get(Mode.EditorList)],
|
|
[SuggestionType.HeadingsList, handlersByMode.get(Mode.HeadingsList)],
|
|
[SuggestionType.RelatedItemsList, handlersByMode.get(Mode.RelatedItemsList)],
|
|
[SuggestionType.Bookmark, handlersByMode.get(Mode.BookmarksList)],
|
|
[SuggestionType.SymbolList, handlersByMode.get(Mode.SymbolList)],
|
|
[SuggestionType.WorkspaceList, handlersByMode.get(Mode.WorkspaceList)],
|
|
[SuggestionType.VaultList, handlersByMode.get(Mode.VaultList)],
|
|
[SuggestionType.File, standardExHandler],
|
|
[SuggestionType.Alias, standardExHandler],
|
|
]);
|
|
this.handlersByCommand = new Map([
|
|
[settings.editorListCommand, handlersByMode.get(Mode.EditorList)],
|
|
[settings.workspaceListCommand, handlersByMode.get(Mode.WorkspaceList)],
|
|
[settings.headingsListCommand, handlersByMode.get(Mode.HeadingsList)],
|
|
[settings.bookmarksListCommand, handlersByMode.get(Mode.BookmarksList)],
|
|
[settings.commandListCommand, handlersByMode.get(Mode.CommandList)],
|
|
[settings.symbolListCommand, handlersByMode.get(Mode.SymbolList)],
|
|
[settings.symbolListActiveEditorCommand, handlersByMode.get(Mode.SymbolList)],
|
|
[settings.relatedItemsListCommand, handlersByMode.get(Mode.RelatedItemsList)],
|
|
[settings.vaultListCommand, handlersByMode.get(Mode.VaultList)],
|
|
[
|
|
settings.relatedItemsListActiveEditorCommand,
|
|
handlersByMode.get(Mode.RelatedItemsList),
|
|
],
|
|
]);
|
|
this.debouncedGetSuggestions = obsidian.debounce(this.getSuggestions.bind(this), settings.headingsSearchDebounceMilli, true);
|
|
this.reset();
|
|
}
|
|
onOpen() {
|
|
const { exKeymap, settings } = this;
|
|
exKeymap.isOpen = true;
|
|
if (settings.quickFilters?.shouldResetActiveFacets) {
|
|
Object.values(settings.quickFilters.facetList).forEach((f) => (f.isActive = false));
|
|
}
|
|
}
|
|
onClose() {
|
|
this.exKeymap.isOpen = false;
|
|
}
|
|
setSessionOpenMode(mode, chooser, sessionOpts) {
|
|
this.reset();
|
|
chooser?.setSuggestions([]);
|
|
if (mode !== Mode.Standard) {
|
|
const openModeString = this.getHandler(mode).getCommandString(sessionOpts);
|
|
Object.assign(this.sessionOpts, sessionOpts, { openModeString });
|
|
}
|
|
if (lastInputInfoByMode[mode]) {
|
|
if ((mode === Mode.CommandList && this.settings.preserveCommandPaletteLastInput) ||
|
|
(mode !== Mode.CommandList && this.settings.preserveQuickSwitcherLastInput)) {
|
|
const lastInfo = lastInputInfoByMode[mode];
|
|
this.lastInput = lastInfo.inputText;
|
|
}
|
|
}
|
|
}
|
|
insertSessionOpenModeOrLastInputString(inputEl) {
|
|
const { sessionOpts, lastInput } = this;
|
|
const openModeString = sessionOpts.openModeString ?? null;
|
|
if (lastInput && lastInput !== openModeString) {
|
|
inputEl.value = lastInput;
|
|
// `openModeString` may `null` when in standard mode
|
|
// otherwise `lastInput` starts with `openModeString`
|
|
const startsNumber = openModeString ? openModeString.length : 0;
|
|
inputEl.setSelectionRange(startsNumber, inputEl.value.length);
|
|
}
|
|
else if (openModeString !== null && openModeString !== '') {
|
|
// update UI with current command string in the case were openInMode was called
|
|
inputEl.value = openModeString;
|
|
// reset to null so user input is not overridden the next time onInput is called
|
|
sessionOpts.openModeString = null;
|
|
}
|
|
// the same logic as `openModeString`
|
|
// make sure it will not override user's normal input.
|
|
this.lastInput = null;
|
|
}
|
|
updateSuggestions(query, chooser, modal) {
|
|
const { exKeymap, settings, sessionOpts } = this;
|
|
let handled = false;
|
|
// cancel any potentially previously running debounced getSuggestions call
|
|
this.debouncedGetSuggestions.cancel();
|
|
// get the currently active leaf across all rootSplits
|
|
const activeLeaf = Handler.getActiveLeaf(this.app.workspace);
|
|
const activeSugg = ModeHandler.getActiveSuggestion(chooser);
|
|
const inputInfo = this.determineRunMode(query, activeSugg, activeLeaf, sessionOpts);
|
|
this.inputInfo = inputInfo;
|
|
const { mode } = inputInfo;
|
|
lastInputInfoByMode[mode] = inputInfo;
|
|
this.updatedKeymapForMode(inputInfo, chooser, modal, exKeymap, settings, activeLeaf);
|
|
if (mode !== Mode.Standard) {
|
|
if (mode === Mode.HeadingsList && inputInfo.parsedCommand().parsedInput?.length) {
|
|
// if headings mode and user is typing a query, delay getting suggestions
|
|
this.debouncedGetSuggestions(inputInfo, chooser, modal);
|
|
}
|
|
else {
|
|
this.getSuggestions(inputInfo, chooser, modal);
|
|
}
|
|
handled = true;
|
|
}
|
|
return handled;
|
|
}
|
|
updatedKeymapForMode(inputInfo, chooser, modal, exKeymap, settings, activeLeaf) {
|
|
const { mode } = inputInfo;
|
|
const handler = this.getHandler(mode);
|
|
const facetList = handler?.getAvailableFacets(inputInfo) ?? [];
|
|
const handleFacetKeyEvent = (facets, isReset) => {
|
|
if (isReset) {
|
|
// cycle between making all facets active/inactive
|
|
const hasActive = facets.some((v) => v.isActive === true);
|
|
handler.activateFacet(facets, !hasActive);
|
|
}
|
|
else {
|
|
// expect facets to contain only one item that needs to be toggled
|
|
handler.activateFacet(facets, !facets[0].isActive);
|
|
}
|
|
// refresh the suggestion list after changing the list of active facets
|
|
this.updatedKeymapForMode(inputInfo, chooser, modal, exKeymap, settings, activeLeaf);
|
|
this.getSuggestions(inputInfo, chooser, modal);
|
|
// prevent default handling of key press afterwards
|
|
return false;
|
|
};
|
|
const keymapConfig = {
|
|
mode,
|
|
activeLeaf,
|
|
facets: {
|
|
facetList,
|
|
facetSettings: settings.quickFilters,
|
|
onToggleFacet: handleFacetKeyEvent.bind(this),
|
|
},
|
|
};
|
|
exKeymap.updateKeymapForMode(keymapConfig);
|
|
}
|
|
renderSuggestion(sugg, parentEl) {
|
|
const { inputInfo, settings: { overrideStandardModeBehaviors }, } = this;
|
|
const { mode } = inputInfo;
|
|
const isHeadingMode = mode === Mode.HeadingsList;
|
|
let handled = false;
|
|
const systemBehaviorPreferred = new Set([
|
|
SuggestionType.Unresolved,
|
|
SuggestionType.Bookmark,
|
|
]);
|
|
if (sugg === null) {
|
|
if (isHeadingMode) {
|
|
// in Headings mode, a null suggestion should be rendered to allow for note creation
|
|
const headingHandler = this.getHandler(mode);
|
|
const searchText = inputInfo.parsedCommand(mode)?.parsedInput;
|
|
headingHandler.renderFileCreationSuggestion(parentEl, searchText);
|
|
handled = true;
|
|
}
|
|
}
|
|
else if (!systemBehaviorPreferred.has(sugg.type)) {
|
|
if (overrideStandardModeBehaviors || isHeadingMode || isExSuggestion(sugg)) {
|
|
// when overriding standard mode, or, in Headings mode, StandardExHandler should
|
|
// handle rendering for FileSuggestion and Alias suggestion
|
|
const handler = this.getHandler(sugg);
|
|
if (handler) {
|
|
if (mode === Mode.Standard) {
|
|
// suggestions in standard mode are created by core Obsidian and are
|
|
// missing some properties, try to add them
|
|
handler.addPropertiesToStandardSuggestions(inputInfo, sugg);
|
|
}
|
|
handled = handler.renderSuggestion(sugg, parentEl);
|
|
}
|
|
}
|
|
}
|
|
return handled;
|
|
}
|
|
onChooseSuggestion(sugg, evt) {
|
|
const { inputInfo, settings: { overrideStandardModeBehaviors }, } = this;
|
|
const { mode } = inputInfo;
|
|
const isHeadingMode = mode === Mode.HeadingsList;
|
|
let handled = false;
|
|
const systemBehaviorPreferred = new Set([
|
|
SuggestionType.Unresolved,
|
|
SuggestionType.Bookmark,
|
|
]);
|
|
if (sugg === null) {
|
|
if (this.noResultActionModes.includes(mode)) {
|
|
// In these modes, a null suggestion indicates that
|
|
// the <enter to create> UI action was chosen
|
|
const handler = this.getHandler(mode);
|
|
handled = !!handler?.onNoResultsCreateAction(inputInfo, evt);
|
|
}
|
|
}
|
|
else if (!systemBehaviorPreferred.has(sugg.type)) {
|
|
if (overrideStandardModeBehaviors || isHeadingMode || isExSuggestion(sugg)) {
|
|
// when overriding standard mode, or, in Headings mode, StandardExHandler should
|
|
// handle the onChoose action for File and Alias suggestion so that
|
|
// the preferOpenInNewPane setting can be handled properly
|
|
const handler = this.getHandler(sugg);
|
|
if (handler) {
|
|
handled = handler.onChooseSuggestion(sugg, evt);
|
|
}
|
|
}
|
|
}
|
|
return handled;
|
|
}
|
|
determineRunMode(query, activeSugg, activeLeaf, sessionOpts) {
|
|
const input = query ?? '';
|
|
const info = new InputInfo(input, Mode.Standard, sessionOpts);
|
|
this.addWorkspaceEnvLists(info);
|
|
if (input.length === 0) {
|
|
this.reset();
|
|
}
|
|
this.validatePrefixCommands(info, activeSugg, activeLeaf, this.settings);
|
|
return info;
|
|
}
|
|
getSuggestions(inputInfo, chooser, modal) {
|
|
chooser.setSuggestions([]);
|
|
const { mode } = inputInfo;
|
|
const suggestions = this.getHandler(mode).getSuggestions(inputInfo);
|
|
const setSuggestions = (suggs) => {
|
|
if (suggs?.length) {
|
|
chooser.setSuggestions(suggs);
|
|
ModeHandler.setActiveSuggestion(mode, chooser);
|
|
}
|
|
else {
|
|
if (this.noResultActionModes.includes(mode) &&
|
|
inputInfo.parsedCommand(mode).parsedInput) {
|
|
modal.onNoSuggestion();
|
|
}
|
|
else {
|
|
chooser.setSuggestions(null);
|
|
}
|
|
}
|
|
};
|
|
if (Array.isArray(suggestions)) {
|
|
setSuggestions(suggestions);
|
|
}
|
|
else {
|
|
suggestions.then((values) => {
|
|
setSuggestions(values);
|
|
}, (reason) => {
|
|
console.log('Switcher++: error retrieving suggestions as Promise. ', reason);
|
|
});
|
|
}
|
|
}
|
|
removeEscapeCommandCharFromInput(inputInfo, escapeCmdChar, cmdStr) {
|
|
const sansEscapeInput = inputInfo.inputTextSansEscapeChar.replace(new RegExp(`(?:${escapeRegExp(escapeCmdChar)})(?:${escapeRegExp(cmdStr)})`), cmdStr);
|
|
inputInfo.inputTextSansEscapeChar = sansEscapeInput;
|
|
return sansEscapeInput;
|
|
}
|
|
validatePrefixCommands(inputInfo, activeSugg, activeLeaf, config) {
|
|
let cmdStr = null;
|
|
let handler = null;
|
|
const activeEditorCmds = [
|
|
config.symbolListActiveEditorCommand,
|
|
config.relatedItemsListActiveEditorCommand,
|
|
];
|
|
const prefixCmds = [
|
|
config.editorListCommand,
|
|
config.workspaceListCommand,
|
|
config.headingsListCommand,
|
|
config.bookmarksListCommand,
|
|
config.commandListCommand,
|
|
config.vaultListCommand,
|
|
]
|
|
.concat(activeEditorCmds)
|
|
.map((v) => `(?:${escapeRegExp(v)})`)
|
|
// account for potential overlapping command strings
|
|
.sort((a, b) => b.length - a.length);
|
|
// regex that matches any of the prefix commands
|
|
const match = new RegExp(`^((?:${escapeRegExp(config.escapeCmdChar)})?)(${prefixCmds.join('|')})`).exec(inputInfo.inputText);
|
|
if (match) {
|
|
const containsNegation = !!match[1].length;
|
|
cmdStr = match[2];
|
|
if (containsNegation) {
|
|
this.removeEscapeCommandCharFromInput(inputInfo, config.escapeCmdChar, cmdStr);
|
|
cmdStr = null;
|
|
}
|
|
else {
|
|
handler = this.getHandler(cmdStr);
|
|
}
|
|
}
|
|
const isValidated = this.validateSourcedCommands(inputInfo, cmdStr, activeSugg, activeLeaf, config);
|
|
if (!isValidated && handler) {
|
|
inputInfo.sessionOpts.useActiveEditorAsSource = activeEditorCmds.includes(cmdStr);
|
|
const filterText = inputInfo.inputTextSansEscapeChar.slice(cmdStr.length);
|
|
handler.validateCommand(inputInfo, match.index, filterText, activeSugg, activeLeaf);
|
|
}
|
|
}
|
|
validateSourcedCommands(inputInfo, parsedPrefixCmd, activeSugg, activeLeaf, config) {
|
|
let isValidated = false;
|
|
const unmatchedHandlers = [];
|
|
const searchText = inputInfo.inputTextSansEscapeChar;
|
|
// Headings, Bookmarks, and EditorList mode can have an embedded command
|
|
const supportedModes = [
|
|
config.editorListCommand,
|
|
config.headingsListCommand,
|
|
config.bookmarksListCommand,
|
|
];
|
|
// A falsy parsedPrefixCmd indicates Standard mode since no prefix command was matched
|
|
if (!parsedPrefixCmd || supportedModes.includes(parsedPrefixCmd)) {
|
|
let match = null;
|
|
const sourcedCmds = [config.symbolListCommand, config.relatedItemsListCommand]
|
|
.map((v) => `(?:${escapeRegExp(v)})`)
|
|
.sort((a, b) => b.length - a.length);
|
|
const re = new RegExp(`((?:${escapeRegExp(config.escapeCmdChar)})?)(${sourcedCmds.join('|')})`, 'g');
|
|
while ((match = re.exec(searchText)) !== null) {
|
|
const containsNegation = !!match[1].length;
|
|
const cmdStr = match[2];
|
|
if (containsNegation) {
|
|
this.removeEscapeCommandCharFromInput(inputInfo, config.escapeCmdChar, cmdStr);
|
|
}
|
|
else {
|
|
const filterText = searchText.slice(re.lastIndex);
|
|
const handler = this.getHandler(cmdStr);
|
|
if (handler) {
|
|
const cmd = handler.validateCommand(inputInfo, match.index, filterText, activeSugg, activeLeaf);
|
|
isValidated = !!cmd?.isValidated;
|
|
// Find all sourced handlers that did not match
|
|
const unmatched = this.getSourcedHandlers().filter((v) => v !== handler);
|
|
unmatchedHandlers.push(...unmatched);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// if unmatchedHandlers has items then there was a match, so reset all others
|
|
// otherwise reset all sourced handlers
|
|
this.resetSourcedHandlers(unmatchedHandlers.length ? unmatchedHandlers : null);
|
|
return isValidated;
|
|
}
|
|
static setActiveSuggestion(mode, chooser) {
|
|
// only symbol mode currently sets an active selection
|
|
if (mode === Mode.SymbolList) {
|
|
const index = chooser.values
|
|
.filter((v) => isSymbolSuggestion(v))
|
|
.findIndex((v) => v.item.isSelected);
|
|
if (index !== -1) {
|
|
chooser.setSelectedItem(index, null);
|
|
chooser.suggestions[chooser.selectedItem].scrollIntoView(false);
|
|
}
|
|
}
|
|
}
|
|
static getActiveSuggestion(chooser) {
|
|
let activeSuggestion = null;
|
|
if (chooser?.values) {
|
|
activeSuggestion = chooser.values[chooser.selectedItem];
|
|
}
|
|
return activeSuggestion;
|
|
}
|
|
reset() {
|
|
this.inputInfo = new InputInfo();
|
|
this.sessionOpts = {};
|
|
this.resetSourcedHandlers();
|
|
}
|
|
resetSourcedHandlers(handlers) {
|
|
handlers = handlers ?? this.getSourcedHandlers();
|
|
handlers.forEach((handler) => handler?.reset());
|
|
}
|
|
getSourcedHandlers() {
|
|
const sourcedModes = [Mode.RelatedItemsList, Mode.SymbolList];
|
|
return sourcedModes.map((v) => this.getHandler(v));
|
|
}
|
|
addWorkspaceEnvLists(inputInfo) {
|
|
if (inputInfo) {
|
|
const fileBookmarks = new Map();
|
|
const nonFileBookmarks = new Set();
|
|
const openEditors = this.getHandler(Mode.EditorList).getItems();
|
|
const openEditorFiles = openEditors
|
|
.map((v) => v?.view?.file)
|
|
.filter((file) => !!file);
|
|
const openEditorFilesSet = new Set(openEditorFiles);
|
|
this.getHandler(Mode.BookmarksList)
|
|
.getItems(null)
|
|
.forEach((bInfo) => {
|
|
if (BookmarksHandler.isBookmarksPluginFileItem(bInfo.item)) {
|
|
if (bInfo.file) {
|
|
fileBookmarks.set(bInfo.file, bInfo);
|
|
}
|
|
}
|
|
else {
|
|
nonFileBookmarks.add(bInfo);
|
|
}
|
|
});
|
|
const lists = inputInfo.currentWorkspaceEnvList;
|
|
lists.openWorkspaceLeaves = new Set(openEditors);
|
|
lists.openWorkspaceFiles = new Set(openEditorFiles);
|
|
lists.fileBookmarks = fileBookmarks;
|
|
lists.nonFileBookmarks = nonFileBookmarks;
|
|
lists.attachmentFileExtensions = this.getAttachmentFileExtensions(this.app.viewRegistry, this.settings.fileExtAllowList);
|
|
const maxCount = openEditorFilesSet.size + this.settings.maxRecentFileSuggestionsOnInit;
|
|
lists.mostRecentFiles = this.getRecentFiles(openEditorFilesSet, maxCount);
|
|
}
|
|
return inputInfo;
|
|
}
|
|
getAttachmentFileExtensions(viewRegistry, exemptFileExtensions) {
|
|
let extList = new Set();
|
|
try {
|
|
const coreExts = new Set(['md', 'canvas', ...exemptFileExtensions]);
|
|
// Get the list of registered extensions excluding the markdown and canvas
|
|
const extensions = Object.keys(viewRegistry.typeByExtension).filter((ext) => !coreExts.has(ext));
|
|
extList = new Set(extensions);
|
|
}
|
|
catch (err) {
|
|
console.log('Switcher++: error retrieving attachment list from ViewRegistry', err);
|
|
}
|
|
return extList;
|
|
}
|
|
getRecentFiles(ignoreFiles, maxCount = 75) {
|
|
ignoreFiles = ignoreFiles ?? new Set();
|
|
const recentFiles = new Set();
|
|
if (maxCount > 0) {
|
|
const { workspace, vault } = this.app;
|
|
const recentFilePaths = workspace.getRecentFiles({
|
|
showMarkdown: true,
|
|
showCanvas: true,
|
|
showNonImageAttachments: true,
|
|
showImages: true,
|
|
maxCount,
|
|
});
|
|
recentFilePaths?.forEach((path) => {
|
|
const file = vault.getAbstractFileByPath(path);
|
|
if (isTFile(file) && !ignoreFiles.has(file)) {
|
|
recentFiles.add(file);
|
|
}
|
|
});
|
|
}
|
|
return recentFiles;
|
|
}
|
|
inputTextForStandardMode(input) {
|
|
const { mode, inputTextSansEscapeChar } = this.inputInfo;
|
|
let searchText = input;
|
|
if (mode === Mode.Standard && inputTextSansEscapeChar?.length) {
|
|
searchText = inputTextSansEscapeChar;
|
|
}
|
|
return searchText;
|
|
}
|
|
getHandler(kind) {
|
|
let handler;
|
|
const { handlersByMode, handlersByType, handlersByCommand } = this;
|
|
if (typeof kind === 'number') {
|
|
handler = handlersByMode.get(kind);
|
|
}
|
|
else if (isOfType(kind, 'type')) {
|
|
handler = handlersByType.get(kind.type);
|
|
}
|
|
else if (typeof kind === 'string') {
|
|
handler = handlersByCommand.get(kind);
|
|
}
|
|
return handler;
|
|
}
|
|
}
|
|
|
|
class SwitcherPlusKeymap {
|
|
get isOpen() {
|
|
return this._isOpen;
|
|
}
|
|
set isOpen(value) {
|
|
this._isOpen = value;
|
|
}
|
|
constructor(app, scope, chooser, modal, config) {
|
|
this.app = app;
|
|
this.scope = scope;
|
|
this.chooser = chooser;
|
|
this.modal = modal;
|
|
this.config = config;
|
|
this.standardKeysInfo = [];
|
|
this.customKeysInfo = [];
|
|
this.savedStandardKeysInfo = [];
|
|
this.standardInstructionsElSelector = '.prompt-instructions';
|
|
this.standardInstructionsElDataValue = 'standard';
|
|
this.facetKeysInfo = [];
|
|
this.insertIntoEditorKeysInfo = [];
|
|
this.modKey = 'Ctrl';
|
|
this.modifierToPlatformStrMap = {
|
|
Mod: 'Ctrl',
|
|
Ctrl: 'Ctrl',
|
|
Meta: 'Win',
|
|
Alt: 'Alt',
|
|
Shift: 'Shift',
|
|
};
|
|
if (obsidian.Platform.isMacOS) {
|
|
this.modKey = 'Meta';
|
|
this.modifierToPlatformStrMap = {
|
|
Mod: '⌘',
|
|
Ctrl: '⌃',
|
|
Meta: '⌘',
|
|
Alt: '⌥',
|
|
Shift: '⇧',
|
|
};
|
|
}
|
|
this.initKeysInfo();
|
|
this.removeDefaultTabKeyBinding(scope, config);
|
|
this.registerNavigationBindings(scope, config.navigationKeys);
|
|
this.registerEditorTabBindings(scope);
|
|
this.registerCloseWhenEmptyBindings(scope, config);
|
|
this.addDataAttrToInstructionsEl(modal.containerEl, this.standardInstructionsElSelector, this.standardInstructionsElDataValue);
|
|
}
|
|
initKeysInfo() {
|
|
const customFileBasedModes = [
|
|
Mode.EditorList,
|
|
Mode.HeadingsList,
|
|
Mode.RelatedItemsList,
|
|
Mode.BookmarksList,
|
|
Mode.SymbolList,
|
|
];
|
|
// standard mode keys that are registered by default, and
|
|
// should be unregistered in custom modes, then re-registered in standard mode
|
|
// example: { modifiers: 'Shift', key: 'Enter' }
|
|
const standardKeysInfo = [];
|
|
// custom mode keys that should be registered, then unregistered in standard mode
|
|
// Note: modifiers should be a comma separated string of Modifiers
|
|
// without any padding space characters
|
|
const customKeysInfo = [
|
|
{
|
|
isInstructionOnly: true,
|
|
modes: customFileBasedModes,
|
|
modifiers: null,
|
|
key: null,
|
|
func: null,
|
|
command: this.commandDisplayStr(['Mod'], '↵'),
|
|
purpose: 'open in new tab',
|
|
},
|
|
{
|
|
isInstructionOnly: true,
|
|
modes: customFileBasedModes,
|
|
modifiers: this.modKey,
|
|
key: '\\',
|
|
func: null,
|
|
command: this.commandDisplayStr(['Mod'], '\\'),
|
|
purpose: 'open to the right',
|
|
},
|
|
{
|
|
isInstructionOnly: true,
|
|
modes: customFileBasedModes,
|
|
modifiers: `${this.modKey},Shift`,
|
|
key: '\\',
|
|
func: null,
|
|
command: this.commandDisplayStr(['Mod', 'Shift'], '\\'),
|
|
purpose: 'open below',
|
|
},
|
|
{
|
|
isInstructionOnly: true,
|
|
modes: customFileBasedModes,
|
|
modifiers: this.modKey,
|
|
key: 'o',
|
|
func: null,
|
|
command: this.commandDisplayStr(['Mod'], 'o'),
|
|
purpose: 'open in new window',
|
|
},
|
|
{
|
|
isInstructionOnly: true,
|
|
modes: [Mode.CommandList],
|
|
modifiers: null,
|
|
key: null,
|
|
func: null,
|
|
command: `↵`,
|
|
purpose: 'execute command',
|
|
},
|
|
{
|
|
isInstructionOnly: true,
|
|
modes: [Mode.WorkspaceList],
|
|
modifiers: null,
|
|
key: null,
|
|
func: null,
|
|
command: `↵`,
|
|
purpose: 'open workspace',
|
|
},
|
|
];
|
|
this.standardKeysInfo.push(...standardKeysInfo);
|
|
this.customKeysInfo.push(...customKeysInfo);
|
|
}
|
|
removeDefaultTabKeyBinding(scope, config) {
|
|
if (config?.removeDefaultTabBinding) {
|
|
// 07/04/2023: Obsidian registers a binding for Tab key that only returns false
|
|
// remove this binding so Tab can be remapped
|
|
const keymap = scope.keys.find(({ modifiers, key }) => modifiers === null && key === 'Tab');
|
|
scope.unregister(keymap);
|
|
}
|
|
}
|
|
registerNavigationBindings(scope, navConfig) {
|
|
const regKeys = (keys, isNext) => {
|
|
keys.forEach(({ modifiers, key }) => {
|
|
scope.register(modifiers, key, (evt, _ctx) => {
|
|
this.navigateItems(evt, isNext);
|
|
return false;
|
|
});
|
|
});
|
|
};
|
|
regKeys(navConfig?.nextKeys ?? [], true);
|
|
regKeys(navConfig?.prevKeys ?? [], false);
|
|
}
|
|
registerFacetBinding(scope, keymapConfig) {
|
|
const { mode, facets } = keymapConfig;
|
|
if (facets?.facetList?.length) {
|
|
const { facetList, facetSettings, onToggleFacet } = facets;
|
|
const { keyList, modifiers, resetKey, resetModifiers } = facetSettings;
|
|
let currKeyListIndex = 0;
|
|
let keyHandler;
|
|
const registerFn = (modKeys, key, facetListLocal, isReset) => {
|
|
return scope.register(modKeys, key, () => onToggleFacet(facetListLocal, isReset));
|
|
};
|
|
// register each of the facets to a corresponding key
|
|
for (let i = 0; i < facetList.length; i++) {
|
|
const facet = facetList[i];
|
|
const facetModifiers = facet.modifiers ?? modifiers;
|
|
let key;
|
|
if (facet.key?.length) {
|
|
// has override key defined so use it instead of the default
|
|
key = facet.key;
|
|
}
|
|
else if (currKeyListIndex < keyList.length) {
|
|
// use up one of the default keys
|
|
key = keyList[currKeyListIndex];
|
|
++currKeyListIndex;
|
|
}
|
|
else {
|
|
// override key is not defined and no default keys left
|
|
console.log(`Switcher++: unable to register hotkey for facet: ${facet.label} in mode: ${Mode[mode]} because a trigger key is not specified`);
|
|
continue;
|
|
}
|
|
keyHandler = registerFn(facetModifiers, key, [facet], false);
|
|
this.facetKeysInfo.push({
|
|
facet,
|
|
command: key,
|
|
purpose: facet.label,
|
|
...keyHandler,
|
|
});
|
|
}
|
|
// register the toggle key
|
|
keyHandler = registerFn(resetModifiers ?? modifiers, resetKey, facetList, true);
|
|
this.facetKeysInfo.push({
|
|
facet: null,
|
|
command: resetKey,
|
|
purpose: 'toggle all',
|
|
...keyHandler,
|
|
});
|
|
}
|
|
}
|
|
registerEditorTabBindings(scope) {
|
|
const keys = [
|
|
[[this.modKey], '\\'],
|
|
[[this.modKey, 'Shift'], '\\'],
|
|
[[this.modKey], 'o'],
|
|
];
|
|
keys.forEach((v) => {
|
|
scope.register(v[0], v[1], this.useSelectedItem.bind(this));
|
|
});
|
|
}
|
|
registerCloseWhenEmptyBindings(scope, config) {
|
|
const keymaps = config.closeWhenEmptyKeys;
|
|
keymaps?.forEach(({ modifiers, key }) => {
|
|
scope.register(modifiers, key, this.closeModalIfEmpty.bind(this));
|
|
});
|
|
}
|
|
updateInsertIntoEditorCommand(mode, activeEditor, customKeysInfo, insertConfig) {
|
|
const { isEnabled, keymap, insertableEditorTypes } = insertConfig;
|
|
let keyInfo = null;
|
|
if (isEnabled) {
|
|
const excludedModes = [Mode.CommandList, Mode.WorkspaceList];
|
|
const activeViewType = activeEditor?.view?.getViewType();
|
|
const isExcluded = (activeViewType && !insertableEditorTypes.includes(activeViewType)) ||
|
|
excludedModes.includes(mode);
|
|
if (!isExcluded) {
|
|
keyInfo = customKeysInfo.find((v) => v.purpose === keymap.purpose);
|
|
if (!keyInfo) {
|
|
const { modifiers, key, purpose } = keymap;
|
|
keyInfo = {
|
|
isInstructionOnly: false,
|
|
modes: [],
|
|
func: null,
|
|
command: this.commandDisplayStr(modifiers, key),
|
|
modifiers: modifiers.join(','),
|
|
key,
|
|
purpose,
|
|
};
|
|
customKeysInfo.push(keyInfo);
|
|
}
|
|
// update the handler to capture the active editor
|
|
keyInfo.func = () => {
|
|
const { modal, chooser } = this;
|
|
modal.close();
|
|
const item = chooser.values?.[chooser.selectedItem];
|
|
this.insertIntoEditorAsLink(item, activeEditor, insertConfig);
|
|
return false;
|
|
};
|
|
keyInfo.modes = [mode];
|
|
}
|
|
}
|
|
return keyInfo;
|
|
}
|
|
updateKeymapForMode(keymapConfig) {
|
|
const { mode, activeLeaf } = keymapConfig;
|
|
const { modal, scope, savedStandardKeysInfo, standardKeysInfo, customKeysInfo, facetKeysInfo, config: { insertLinkInEditor }, } = this;
|
|
this.updateInsertIntoEditorCommand(mode, activeLeaf, customKeysInfo, insertLinkInEditor);
|
|
const customKeymaps = customKeysInfo.filter((v) => !v.isInstructionOnly);
|
|
this.unregisterKeys(scope, customKeymaps);
|
|
// remove facet keys and reset storage array
|
|
this.unregisterKeys(scope, facetKeysInfo);
|
|
facetKeysInfo.length = 0;
|
|
const customKeysToAdd = customKeymaps.filter((v) => v.modes?.includes(mode));
|
|
if (mode === Mode.Standard) {
|
|
this.registerKeys(scope, savedStandardKeysInfo);
|
|
savedStandardKeysInfo.length = 0;
|
|
// after (re)registering the standard keys, register any custom keys that
|
|
// should also work in standard mode
|
|
this.registerKeys(scope, customKeysToAdd);
|
|
this.toggleStandardInstructions(modal.containerEl, true);
|
|
}
|
|
else {
|
|
const standardKeysRemoved = this.unregisterKeys(scope, standardKeysInfo);
|
|
if (standardKeysRemoved.length) {
|
|
savedStandardKeysInfo.push(...standardKeysRemoved);
|
|
}
|
|
this.registerKeys(scope, customKeysToAdd);
|
|
this.registerFacetBinding(scope, keymapConfig);
|
|
this.showCustomInstructions(modal, keymapConfig, customKeysInfo, facetKeysInfo);
|
|
}
|
|
}
|
|
registerKeys(scope, keymaps) {
|
|
keymaps.forEach((keymap) => {
|
|
const modifiers = keymap.modifiers.split(',');
|
|
scope.register(modifiers, keymap.key, keymap.func);
|
|
});
|
|
}
|
|
unregisterKeys(scope, keyInfo) {
|
|
const keysToRemove = [...keyInfo];
|
|
const removed = [];
|
|
let i = scope.keys.length;
|
|
while (i--) {
|
|
const keymap = scope.keys[i];
|
|
const foundIndex = keysToRemove.findIndex((kRemove) => {
|
|
// when the 'Mod' modifier is registered, it gets translated to the platform
|
|
// specific version 'Meta' on MacOS or Ctrl on others, so when unregistering
|
|
// account for this conversion
|
|
const kRemoveModifiers = kRemove.modifiers
|
|
.split(',')
|
|
.map((modifier) => (modifier === 'Mod' ? this.modKey : modifier))
|
|
.join(',');
|
|
return kRemoveModifiers === keymap.modifiers && kRemove.key === keymap.key;
|
|
});
|
|
if (foundIndex >= 0) {
|
|
scope.unregister(keymap);
|
|
removed.push(keymap);
|
|
keysToRemove.splice(foundIndex, 1);
|
|
}
|
|
}
|
|
return removed;
|
|
}
|
|
addDataAttrToInstructionsEl(containerEl, selector, value) {
|
|
const el = containerEl.querySelector(selector);
|
|
el?.setAttribute('data-mode', value);
|
|
return el;
|
|
}
|
|
clearCustomInstructions(containerEl) {
|
|
const { standardInstructionsElSelector, standardInstructionsElDataValue } = this;
|
|
const selector = `${standardInstructionsElSelector}:not([data-mode="${standardInstructionsElDataValue}"])`;
|
|
const elements = containerEl.querySelectorAll(selector);
|
|
elements.forEach((el) => el.remove());
|
|
}
|
|
toggleStandardInstructions(containerEl, shouldShow) {
|
|
const { standardInstructionsElSelector } = this;
|
|
let displayValue = 'none';
|
|
if (shouldShow) {
|
|
displayValue = '';
|
|
this.clearCustomInstructions(containerEl);
|
|
}
|
|
const el = containerEl.querySelector(standardInstructionsElSelector);
|
|
if (el) {
|
|
el.style.display = displayValue;
|
|
}
|
|
}
|
|
showCustomInstructions(modal, keymapConfig, keymapInfo, facetKeysInfo) {
|
|
const { mode, facets } = keymapConfig;
|
|
const { containerEl } = modal;
|
|
const keymaps = keymapInfo.filter((keymap) => keymap.modes?.includes(mode));
|
|
this.toggleStandardInstructions(containerEl, false);
|
|
this.clearCustomInstructions(containerEl);
|
|
this.renderFacetInstructions(modal, facets?.facetSettings, facetKeysInfo);
|
|
modal.setInstructions(keymaps);
|
|
}
|
|
renderFacetInstructions(modal, facetSettings, facetKeysInfo) {
|
|
if (facetKeysInfo?.length && facetSettings.shouldShowFacetInstructions) {
|
|
const modifiersToString = (modifiers) => {
|
|
return modifiers?.toString().replace(',', ' ');
|
|
};
|
|
const containerEl = modal.modalEl.createDiv('prompt-instructions');
|
|
// render the preamble
|
|
let instructionEl = containerEl.createDiv();
|
|
instructionEl.createSpan({
|
|
cls: 'prompt-instruction-command',
|
|
text: `filters | ${modifiersToString(facetSettings.modifiers)}`,
|
|
});
|
|
// render each key instruction
|
|
facetKeysInfo.forEach((facetKeyInfo) => {
|
|
const { facet, command, purpose } = facetKeyInfo;
|
|
let modifiers;
|
|
let key;
|
|
let activeCls = null;
|
|
if (facet) {
|
|
// Note: the command only contain the key, the modifiers has to be derived
|
|
key = command;
|
|
modifiers = facet.modifiers;
|
|
if (facet.isActive) {
|
|
activeCls = ['qsp-filter-active'];
|
|
}
|
|
}
|
|
else {
|
|
// Note: only the reset key is expected to not have an associated facet
|
|
key = facetSettings.resetKey;
|
|
modifiers = facetSettings.resetModifiers;
|
|
}
|
|
// if a modifier is specified for this specific facet, it overrides the
|
|
// default modifier so display that too. Otherwise, just show the key alone
|
|
const commandDisplayText = modifiers
|
|
? `(${modifiersToString(modifiers)}) ${key}`
|
|
: `${key}`;
|
|
instructionEl = containerEl.createDiv();
|
|
instructionEl.createSpan({
|
|
cls: 'prompt-instruction-command',
|
|
text: commandDisplayText,
|
|
});
|
|
instructionEl.createSpan({
|
|
cls: activeCls,
|
|
text: purpose,
|
|
});
|
|
});
|
|
}
|
|
}
|
|
closeModalIfEmpty(evt, _ctx) {
|
|
const { modal, config } = this;
|
|
if (config.shouldCloseModalOnBackspace && !modal?.inputEl.value) {
|
|
modal.close();
|
|
evt.preventDefault();
|
|
}
|
|
}
|
|
useSelectedItem(evt, _ctx) {
|
|
this.chooser.useSelectedItem(evt);
|
|
}
|
|
insertIntoEditorAsLink(sugg, activeLeaf, insertConfig) {
|
|
const { app: { workspace, fileManager, vault }, } = this;
|
|
const activeMarkdownView = workspace.getActiveViewOfType(obsidian.MarkdownView);
|
|
const isActiveMarkdown = activeMarkdownView?.leaf === activeLeaf;
|
|
const activeFile = activeMarkdownView?.file;
|
|
if (isActiveMarkdown && activeFile) {
|
|
const linkStr = generateMarkdownLink(fileManager, vault, sugg, activeFile.path, insertConfig);
|
|
if (linkStr) {
|
|
activeMarkdownView.editor?.replaceSelection(linkStr);
|
|
}
|
|
}
|
|
}
|
|
navigateItems(evt, isNext) {
|
|
const { isOpen, chooser } = this;
|
|
if (isOpen) {
|
|
let index = chooser.selectedItem;
|
|
index = isNext ? ++index : --index;
|
|
chooser.setSelectedItem(index, evt);
|
|
}
|
|
}
|
|
commandDisplayStr(modifiers, key) {
|
|
let displayStr = '';
|
|
if (modifiers && key) {
|
|
const { modifierToPlatformStrMap } = this;
|
|
const modifierStr = modifiers
|
|
.map((modifier) => {
|
|
return modifierToPlatformStrMap[modifier]?.toLocaleLowerCase();
|
|
})
|
|
.join(' ');
|
|
displayStr = `${modifierStr} ${key}`;
|
|
}
|
|
return displayStr;
|
|
}
|
|
}
|
|
|
|
function createSwitcherPlus(app, plugin) {
|
|
const SystemSwitcherModal = getSystemSwitcherInstance(app)
|
|
?.QuickSwitcherModal;
|
|
if (!SystemSwitcherModal) {
|
|
console.log('Switcher++: unable to extend system switcher. Plugin UI will not be loaded. Use the builtin switcher instead.');
|
|
return null;
|
|
}
|
|
const SwitcherPlusModal = class extends SystemSwitcherModal {
|
|
constructor(app, plugin) {
|
|
super(app, plugin.options.builtInSystemOptions);
|
|
this.plugin = plugin;
|
|
const { options } = plugin;
|
|
options.shouldShowAlias = this.shouldShowAlias;
|
|
const exKeymap = new SwitcherPlusKeymap(app, this.scope, this.chooser, this, options);
|
|
this.exMode = new ModeHandler(app, options, exKeymap);
|
|
}
|
|
openInMode(mode, sessionOpts) {
|
|
this.exMode.setSessionOpenMode(mode, this.chooser, sessionOpts);
|
|
super.open();
|
|
}
|
|
onOpen() {
|
|
this.exMode.onOpen();
|
|
super.onOpen();
|
|
}
|
|
onClose() {
|
|
super.onClose();
|
|
this.exMode.onClose();
|
|
}
|
|
updateSuggestions() {
|
|
const { exMode, inputEl, chooser } = this;
|
|
exMode.insertSessionOpenModeOrLastInputString(inputEl);
|
|
if (!exMode.updateSuggestions(inputEl.value, chooser, this)) {
|
|
super.updateSuggestions();
|
|
}
|
|
}
|
|
getSuggestions(input) {
|
|
const query = this.exMode.inputTextForStandardMode(input);
|
|
return super.getSuggestions(query);
|
|
}
|
|
onChooseSuggestion(item, evt) {
|
|
if (!this.exMode.onChooseSuggestion(item, evt)) {
|
|
super.onChooseSuggestion(item, evt);
|
|
}
|
|
}
|
|
renderSuggestion(value, parentEl) {
|
|
if (!this.exMode.renderSuggestion(value, parentEl)) {
|
|
super.renderSuggestion(value, parentEl);
|
|
}
|
|
}
|
|
};
|
|
return new SwitcherPlusModal(app, plugin);
|
|
}
|
|
|
|
const COMMAND_DATA = [
|
|
{
|
|
id: 'switcher-plus:open',
|
|
name: 'Open in Standard Mode',
|
|
mode: Mode.Standard,
|
|
iconId: 'lucide-search',
|
|
ribbonIconEl: null,
|
|
},
|
|
{
|
|
id: 'switcher-plus:open-editors',
|
|
name: 'Open in Editor Mode',
|
|
mode: Mode.EditorList,
|
|
iconId: 'lucide-file-edit',
|
|
ribbonIconEl: null,
|
|
},
|
|
{
|
|
id: 'switcher-plus:open-symbols',
|
|
name: 'Open Symbols for selected suggestion or editor',
|
|
mode: Mode.SymbolList,
|
|
iconId: 'lucide-dollar-sign',
|
|
ribbonIconEl: null,
|
|
},
|
|
{
|
|
id: 'switcher-plus:open-symbols-active',
|
|
name: 'Open Symbols for the active editor',
|
|
mode: Mode.SymbolList,
|
|
iconId: 'lucide-dollar-sign',
|
|
ribbonIconEl: null,
|
|
sessionOpts: { useActiveEditorAsSource: true },
|
|
},
|
|
{
|
|
id: 'switcher-plus:open-workspaces',
|
|
name: 'Open in Workspaces Mode',
|
|
mode: Mode.WorkspaceList,
|
|
iconId: 'lucide-album',
|
|
ribbonIconEl: null,
|
|
},
|
|
{
|
|
id: 'switcher-plus:open-headings',
|
|
name: 'Open in Headings Mode',
|
|
mode: Mode.HeadingsList,
|
|
iconId: 'lucide-file-search',
|
|
ribbonIconEl: null,
|
|
},
|
|
{
|
|
// Note: leaving this id with the old starred plugin name so that user
|
|
// don't have to update their hotkey mappings when they upgrade
|
|
id: 'switcher-plus:open-starred',
|
|
name: 'Open in Bookmarks Mode',
|
|
mode: Mode.BookmarksList,
|
|
iconId: 'lucide-bookmark',
|
|
ribbonIconEl: null,
|
|
},
|
|
{
|
|
id: 'switcher-plus:open-commands',
|
|
name: 'Open in Commands Mode',
|
|
mode: Mode.CommandList,
|
|
iconId: 'run-command',
|
|
ribbonIconEl: null,
|
|
},
|
|
{
|
|
id: 'switcher-plus:open-related-items',
|
|
name: 'Open Related Items for selected suggestion or editor',
|
|
mode: Mode.RelatedItemsList,
|
|
iconId: 'lucide-file-plus-2',
|
|
ribbonIconEl: null,
|
|
},
|
|
{
|
|
id: 'switcher-plus:open-related-items-active',
|
|
name: 'Open Related Items for the active editor',
|
|
mode: Mode.RelatedItemsList,
|
|
iconId: 'lucide-file-plus-2',
|
|
ribbonIconEl: null,
|
|
sessionOpts: { useActiveEditorAsSource: true },
|
|
},
|
|
{
|
|
id: 'switcher-plus:open-vaults',
|
|
name: 'Open in Vaults Mode',
|
|
mode: Mode.VaultList,
|
|
iconId: 'vault',
|
|
ribbonIconEl: null,
|
|
},
|
|
];
|
|
class SwitcherPlusPlugin extends obsidian.Plugin {
|
|
async onload() {
|
|
const options = new SwitcherPlusSettings(this);
|
|
await options.updateDataAndLoadSettings();
|
|
this.options = options;
|
|
this.addSettingTab(new SwitcherPlusSettingTab(this.app, this, options));
|
|
this.registerRibbonCommandIcons();
|
|
COMMAND_DATA.forEach(({ id, name, mode, iconId, sessionOpts }) => {
|
|
this.registerCommand(id, name, mode, iconId, sessionOpts);
|
|
});
|
|
}
|
|
registerCommand(id, name, mode, iconId, sessionOpts) {
|
|
this.addCommand({
|
|
id,
|
|
name,
|
|
icon: iconId,
|
|
checkCallback: (checking) => {
|
|
return this.createModalAndOpen(mode, checking, sessionOpts);
|
|
},
|
|
});
|
|
}
|
|
registerRibbonCommandIcons() {
|
|
// remove any registered icons
|
|
COMMAND_DATA.forEach((data) => {
|
|
data.ribbonIconEl?.remove();
|
|
data.ribbonIconEl = null;
|
|
});
|
|
// map to keyed object
|
|
const commandDataByMode = COMMAND_DATA.reduce((acc, curr) => {
|
|
acc[curr.mode] = curr;
|
|
return acc;
|
|
}, {});
|
|
this.options.enabledRibbonCommands.forEach((command) => {
|
|
const data = commandDataByMode[Mode[command]];
|
|
if (data) {
|
|
data.ribbonIconEl = this.addRibbonIcon(data.iconId, data.name, () => {
|
|
this.createModalAndOpen(data.mode, false);
|
|
});
|
|
}
|
|
});
|
|
}
|
|
createModalAndOpen(mode, isChecking, sessionOpts) {
|
|
// modal needs to be created dynamically (same as system switcher)
|
|
// as system options are evaluated in the modal constructor
|
|
const modal = createSwitcherPlus(this.app, this);
|
|
if (!modal) {
|
|
return false;
|
|
}
|
|
if (!isChecking) {
|
|
modal.openInMode(mode, sessionOpts);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
module.exports = SwitcherPlusPlugin;
|
|
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["../../src/types/sharedTypes.ts","../../src/utils/utils.ts","../../src/utils/frontMatterParser.ts","../../src/settings/facetConstants.ts","../../node_modules/ts-deepmerge/esm/index.js","../../src/settings/switcherPlusSettings.ts","../../src/settings/settingsTabSection.ts","../../src/settings/bookmarksSettingsTabSection.ts","../../src/settings/commandListSettingsTabSection.ts","../../src/settings/relatedItemsSettingsTabSection.ts","../../src/settings/generalSettingsTabSection.ts","../../src/settings/workspaceSettingsTabSection.ts","../../src/settings/editorSettingsTabSection.ts","../../src/settings/headingsSettingsTabSection.ts","../../src/settings/symbolSettingsTabSection.ts","../../src/settings/vaultListSettingsTabSection.ts","../../src/settings/switcherPlusSettingTab.ts","../../src/switcherPlus/inputInfo.ts","../../src/Handlers/handler.ts","../../src/Handlers/workspaceHandler.ts","../../src/Handlers/standardExHandler.ts","../../src/Handlers/editorHandler.ts","../../src/Handlers/bookmarksHandler.ts","../../src/Handlers/headingsHandler.ts","../../src/Handlers/symbolHandler.ts","../../src/Handlers/commandHandler.ts","../../src/Handlers/relatedItemsHandler.ts","../../src/Handlers/vaultHandler.ts","../../src/switcherPlus/modeHandler.ts","../../src/switcherPlus/switcherPlusKeymap.ts","../../src/switcherPlus/switcherPlus.ts","../../src/main.ts"],"sourcesContent":null,"names":["parseLinktext","Setting","Modal","PluginSettingTab","prepareQuery","Keymap","Platform","setIcon","renderResults","normalizePath","fuzzySearch","View","FileView","sortSearchResults","ipcRenderer","debounce","MarkdownView","Plugin"],"mappings":"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","x_google_ignoreList":[4]}
|