1
0
silverbullet/packages/plugs/core/mount.ts
2022-07-06 12:18:33 +02:00

191 lines
5.0 KiB
TypeScript

import { PageMeta } from "@silverbulletmd/common/types";
import {
deleteFile,
getFileMeta,
listFiles,
readFile,
writeFile,
} from "@plugos/plugos-syscall/fs";
import { parseMarkdown } from "@silverbulletmd/plugos-silverbullet-syscall/markdown";
import {
findNodeOfType,
renderToText,
replaceNodesMatching,
} from "@silverbulletmd/common/tree";
import { readPage } from "@silverbulletmd/plugos-silverbullet-syscall/space";
import YAML from "yaml";
const globalMountPrefix = "🚪 ";
type MountPoint = {
prefix: string;
path: string;
perm: "rw" | "ro";
};
let mountPointCache: MountPoint[] = [];
async function updateMountPoints() {
let mountPointsText = "";
try {
let { text } = await readPage("MOUNTS");
mountPointsText = text;
} catch {
// No MOUNTS file, so that's all folks!
mountPointCache = [];
return;
}
let tree = await parseMarkdown(mountPointsText);
let codeTextNode = findNodeOfType(tree, "CodeText");
if (!codeTextNode) {
console.error("Could not find yaml block in MOUNTS");
return;
}
let mountsYaml = codeTextNode.children![0].text;
let mountList = YAML.parse(mountsYaml!);
if (!Array.isArray(mountList)) {
console.error("Invalid MOUNTS file, should have array of mount points");
return;
}
for (let mountPoint of mountList) {
if (!mountPoint.prefix) {
console.error("Invalid mount point, no prefix specified", mountPoint);
return;
}
if (!mountPoint.path) {
console.error("Invalid mount point, no path specified", mountPoint);
return;
}
if (!mountPoint.perm) {
mountPoint.perm = "rw";
}
}
mountPointCache = mountList;
}
async function translateLinksWithPrefix(
text: string,
prefix: string
): Promise<string> {
prefix = `${globalMountPrefix}${prefix}`;
let tree = await parseMarkdown(text);
replaceNodesMatching(tree, (tree) => {
if (tree.type === "WikiLinkPage") {
// Add the prefix in the link text
tree.children![0].text = prefix + tree.children![0].text;
}
return undefined;
});
text = renderToText(tree);
return text;
}
async function translateLinksWithoutPrefix(text: string, prefix: string) {
prefix = `${globalMountPrefix}${prefix}`;
let tree = await parseMarkdown(text);
replaceNodesMatching(tree, (tree) => {
if (tree.type === "WikiLinkPage") {
// Remove the prefix in the link text
let text = tree.children![0].text!;
if (text.startsWith(prefix)) {
tree.children![0].text = text.substring(prefix.length);
}
}
return undefined;
});
return renderToText(tree);
}
function lookupMountPoint(fullPath: string): {
resolvedPath: string;
mountPoint: MountPoint;
} {
fullPath = fullPath.substring(globalMountPrefix.length);
for (let mp of mountPointCache) {
if (fullPath.startsWith(mp.prefix)) {
return {
resolvedPath: `${mp.path}/${fullPath.substring(mp.prefix.length)}`,
mountPoint: mp,
};
}
}
throw new Error("No mount point found for " + fullPath);
}
export async function readPageMounted(
name: string
): Promise<{ text: string; meta: PageMeta }> {
await updateMountPoints();
let { resolvedPath, mountPoint } = lookupMountPoint(name);
let { text, meta } = await readFile(`${resolvedPath}.md`);
return {
text: await translateLinksWithPrefix(text, mountPoint.prefix),
meta: {
name: name,
lastModified: meta.lastModified,
perm: mountPoint.perm,
},
};
}
export async function writePageMounted(
name: string,
text: string
): Promise<PageMeta> {
await updateMountPoints();
let { resolvedPath, mountPoint } = lookupMountPoint(name);
text = await translateLinksWithoutPrefix(text, mountPoint.prefix);
let meta = await writeFile(`${resolvedPath}.md`, text);
return {
name: name,
lastModified: meta.lastModified,
perm: mountPoint.perm,
};
}
export async function deletePageMounted(name: string): Promise<void> {
await updateMountPoints();
let { resolvedPath, mountPoint } = lookupMountPoint(name);
if (mountPoint.perm === "rw") {
await deleteFile(`${resolvedPath}.md`);
} else {
throw new Error("Deleting read-only page");
}
}
export async function getPageMetaMounted(name: string): Promise<PageMeta> {
await updateMountPoints();
let { resolvedPath, mountPoint } = lookupMountPoint(name);
let meta = await getFileMeta(`${resolvedPath}.md`);
return {
name,
lastModified: meta.lastModified,
perm: mountPoint.perm,
};
}
export async function listPagesMounted(): Promise<PageMeta[]> {
await updateMountPoints();
let allPages: PageMeta[] = [];
for (let mp of mountPointCache) {
let files = await listFiles(mp.path, true);
for (let file of files) {
if (!file.name.endsWith(".md")) {
continue;
}
allPages.push({
name: `${globalMountPrefix}${mp.prefix}${file.name.substring(
0,
file.name.length - 3
)}`,
lastModified: file.lastModified,
perm: mp.perm,
});
}
}
return allPages;
}