131 lines
3.5 KiB
TypeScript
131 lines
3.5 KiB
TypeScript
import { getString } from "../utils/locale";
|
|
import { formatPath } from "../utils/str";
|
|
|
|
export { createNoteFromTemplate, createNoteFromMD, createNote };
|
|
|
|
function getLibraryParentId() {
|
|
return ZoteroPane.getSelectedItems().filter((item) => item.isRegularItem())[0]
|
|
?.id;
|
|
}
|
|
|
|
function getReaderParentId() {
|
|
const currentReader = Zotero.Reader.getByTabID(Zotero_Tabs.selectedID);
|
|
const parentItemId = Zotero.Items.get(
|
|
currentReader?.itemID || -1,
|
|
).parentItemID;
|
|
return parentItemId;
|
|
}
|
|
|
|
async function createNoteFromTemplate(noteType: "standalone"): Promise<void>;
|
|
async function createNoteFromTemplate(
|
|
noteType: "item",
|
|
parentType: "reader" | "library",
|
|
): Promise<void>;
|
|
async function createNoteFromTemplate(
|
|
noteType: "standalone" | "item",
|
|
parentType?: "reader" | "library",
|
|
) {
|
|
if (noteType === "item") {
|
|
const parentItemId =
|
|
parentType === "reader" ? getReaderParentId() : getLibraryParentId();
|
|
if (!parentItemId) {
|
|
Zotero.getMainWindow().alert(getString("alert.notValidParentItemError"));
|
|
return;
|
|
}
|
|
addon.hooks.onShowTemplatePicker("create", {
|
|
noteType,
|
|
parentItemId,
|
|
// Only pre-select the top item if the parent is a reader item
|
|
topItemIds: parentType === "reader" ? [parentItemId] : undefined,
|
|
});
|
|
} else {
|
|
addon.hooks.onShowTemplatePicker("create", {
|
|
noteType,
|
|
});
|
|
}
|
|
}
|
|
|
|
async function createNoteFromMD() {
|
|
// Check if we can create a note
|
|
if (!(await createNote({ dryRun: true }))) {
|
|
return;
|
|
}
|
|
|
|
const syncNotes = Zotero.getMainWindow().confirm(
|
|
getString("alert-syncImportedNotes"),
|
|
);
|
|
|
|
const filepaths = await new ztoolkit.FilePicker(
|
|
"Import MarkDown",
|
|
"multiple",
|
|
[[`MarkDown(*.md)`, `*.md`]],
|
|
).open();
|
|
|
|
if (!filepaths) {
|
|
return;
|
|
}
|
|
|
|
for (const filepath of filepaths) {
|
|
const noteItem = await createNote();
|
|
if (!noteItem) {
|
|
continue;
|
|
}
|
|
await addon.api.$import.fromMD(filepath, {
|
|
noteId: noteItem.id,
|
|
ignoreVersion: true,
|
|
});
|
|
if (noteItem && syncNotes) {
|
|
const pathSplit = PathUtils.split(formatPath(filepath));
|
|
addon.api.sync.updateSyncStatus(noteItem.id, {
|
|
itemID: noteItem.id,
|
|
path: formatPath(pathSplit.slice(0, -1).join("/")),
|
|
filename: pathSplit.pop() || "",
|
|
lastsync: new Date().getTime(),
|
|
md5: "",
|
|
noteMd5: Zotero.Utilities.Internal.md5(noteItem.getNote(), false),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
async function createNote(): Promise<Zotero.Item | false>;
|
|
async function createNote(options: {
|
|
dryRun: true;
|
|
noSave?: boolean;
|
|
}): Promise<boolean>;
|
|
async function createNote(options: {
|
|
dryRun?: false;
|
|
noSave?: boolean;
|
|
}): Promise<Zotero.Item | false>;
|
|
async function createNote(
|
|
options: { dryRun?: boolean; noSave?: boolean } = {},
|
|
) {
|
|
let noteItem: Zotero.Item;
|
|
const ZoteroPane = Zotero.getActiveZoteroPane();
|
|
|
|
const cView = ZoteroPane.collectionsView;
|
|
if (!cView) {
|
|
Zotero.getMainWindow().alert(getString("alert.notValidCollectionError"));
|
|
return false;
|
|
}
|
|
const cRow = cView.selectedTreeRow;
|
|
if (["library", "group", "collection"].includes(cRow.type)) {
|
|
if (options.dryRun) {
|
|
return true;
|
|
}
|
|
noteItem = new Zotero.Item("note");
|
|
noteItem.libraryID = ZoteroPane.getSelectedLibraryID();
|
|
if (cRow.type === "collection") {
|
|
noteItem.addToCollection(cRow.ref.id);
|
|
}
|
|
} else {
|
|
Zotero.getMainWindow().alert(getString("alert.notValidCollectionError"));
|
|
return false;
|
|
}
|
|
|
|
if (!options.noSave) {
|
|
await noteItem.saveTx();
|
|
}
|
|
return noteItem;
|
|
}
|