Obsidian Vault Integration

Copyexport interface Options extends ReadFilesOptions {
  convert?: ConvertOptions;
  out?: WriteFilesOptions;
}
 
export async function fromVault(options: Options) {
  const files = await readVaultFiles(options);
  const converted = await convertVaultFiles(files, options.convert);
 
  await writeVaultFiles(converted, options.out);
}

Copyexport async function writeVaultFiles(files: OutputFile[], options: WriteFilesOptions = {}) {
  const { publicDir = 'public', contentDir = 'content/docs/vault' } = options;
 
  const map = {
    asset: publicDir,
    content: contentDir,
    data: contentDir,
    custom: '',
  } as const;
 
  await Promise.all(
    files.map(async (file) => {
      const mappedPath = path.join(map[file.type], file.path);
 
      await fs.mkdir(path.dirname(mappedPath), { recursive: true });
      await fs.writeFile(mappedPath, file.content);
    }),
  );
}

Copyexport function buildStorage(
  rawFiles: VaultFile[],
  options: VaultStorageOptions = {},
): VaultStorage {
  const {
    url = (file) => {
      const segs = normalize(file)
        .split('/')
        .filter((v) => v.length > 0);
      return `/${segs.join('/')}`;
    },
    outputPath: outputPathOption = 'simple',
    enforceMdx = true,
  } = options;
  const getOutputPath =
    typeof outputPathOption === 'function'
      ? outputPathOption
      : createRenameOutput(outputPathOption);
 
  const storage = new Map<string, ParsedFile>();
 
  for (const rawFile of rawFiles) {
    const normalizedPath = normalize(rawFile.path);
    let outPath = getOutputPath(normalizedPath, rawFile);
    let parsed: ParsedFile;
 
    const ext = path.extname(normalizedPath);
 
    if (['.json', '.yaml', '.yml', '.toml'].includes(ext)) {
      parsed = {
        format: 'data',
        path: normalizedPath,
        _raw: rawFile._raw,
        outPath,
        content: rawFile.content,
      };
    } else if (['.md', '.mdx'].includes(ext)) {
      const { data, content } = frontmatter(String(rawFile.content));
      if (enforceMdx) {
        outPath = outPath.slice(0, -path.extname(outPath).length) + '.mdx';
      }
 
      parsed = {
        format: 'content',
        _raw: rawFile._raw,
        path: normalizedPath,
        outPath,
        frontmatter: frontmatterSchema.parse(data),
        content,
      };
    } else {
      parsed = {
        format: 'media',
        path: normalizedPath,
        _raw: rawFile._raw,
        outPath,
        content: rawFile.content,
        url: url(outPath, rawFile),
      };
    }
 
    storage.set(normalizedPath, parsed);
  }
 
  return { files: storage };
}

Copyfunction normalize(filePath: string): string {
  filePath = slash(filePath);
  if (filePath.startsWith('../')) throw new Error(`${filePath} points outside of vault folder`);
 
  return filePath.startsWith('./') ? filePath.slice(2) : filePath;
}

Copyvisit(tree, 'paragraph', (node, index, parent) => {
  if (typeof index !== 'number' || !parent) return;
 
  const replaceParagraph: RootContent[] = [node];
  let parents: Parent[] = [];
 
  function traverse(cur: RootContent) {
    if (cur.type === 'text') {
      const output = resolveParagraphText(cur.value, sourceFile, resolver);
      const idx = parents[0].children.indexOf(cur);
      let insertIdx = idx;
 
      parents[0].children.splice(insertIdx, 1);
      for (const item of output) {
        if (item.inParagraph) {
          parents[0].children.splice(insertIdx, 0, ...item.children);
          insertIdx += item.children.length;
        } else {
          replaceParagraph.push(...item.children);
          // clone parents
          parents = structuredClone(parents);
          // removed inserted elements
          parents[0].children.splice(idx, insertIdx - idx);
          insertIdx = idx;
          replaceParagraph.push(parents.at(-1) as Paragraph);
        }
      }
 
      return;
    }
 
    if ('children' in cur && Array.isArray(cur.children)) {
      parents.unshift(cur);
      for (const child of cur.children) {
        traverse(child);
      }
      parents.shift();
    }
  }
 
  traverse(node);
  parent.children.splice(index, 1, ...replaceParagraph);
});

Copyconst RegexWikilink = /!?\[\[(?<content>([^\]]|\\])+)]]/g;
const RegexContent =
  /^(?<name>(?:\\#|\\\||[^#|])*)(?:#(?<heading>(?:\\\||[^|])+))?(?:\|(?<alias>.+))?$/;

Copyfunction resolveWikilink(
  isEmbed: boolean,
  content: string,
  sourceFile: ParsedFile,
  resolver: VaultResolver,
): RootContent | undefined {
  const match = RegexContent.exec(content);
  if (!match?.groups) return;
 
  const { name, heading, alias } = match.groups as {
    name: string;
    heading?: string;
    alias?: string;
  };
 
  const isHeadingOnly = name.length === 0 && heading;
 
  if (isEmbed) {
    const ref = isHeadingOnly ? sourceFile : resolver.resolveAny(name, sourceFile.path);
 
    if (!ref || ref.format === 'data') {
      console.warn(`failed to resolve ${name} wikilink`);
      return;
    }
 
    if (ref.format === 'content') {
      console.warn(
        'some features of embed content blocks are not supported yet, use at your own risk.',
      );
 
      return {
        type: 'mdxJsxFlowElement',
        name: 'include',
        attributes: [],
        children: [
          {
            type: 'paragraph',
            children: [
              {
                type: 'text',
                value: getFileHref(ref, sourceFile, heading),
              },
            ],
          },
        ],
      } satisfies MdxJsxFlowElement;
    }
 
    if (alias) console.warn('we do not support specifying image size like `![[image.png|300]].');
 
    return {
      type: 'image',
      url: ref.url ?? getFileHref(ref, sourceFile, heading),
      alt: name,
    };
  }
 
  let url: string;
 
  if (isHeadingOnly) {
    url = `#${getHeadingHash(heading)}`;
  } else {
    const ref = resolver.resolveAny(name, sourceFile.path);
 
    if (!ref) {
      console.warn(`failed to resolve ${name} wikilink`);
      return;
    }
 
    url = getFileHref(ref, sourceFile, heading);
  }
 
  return {
    type: 'link',
    url,
    data: {
      isWikiLink: true,
    },
    children: [
      {

Copyconst RegexCalloutHead = /^\[!(?<type>\w+)](?<collapsible>\+)?/;

Copyfunction resolveCallout(node: Blockquote) {
  const head = node.children[0];
  if (!head || head.type !== 'paragraph') return;
  const textNode = head.children[0];
  if (!textNode || textNode.type !== 'text') return;
 
  const match = RegexCalloutHead.exec(textNode.value);
  if (!match) return;
 
  textNode.value = textNode.value.slice(match[0].length).trimStart();
 
  const [title, rest] = separate(/\r?\n/, head.children) ?? [head.children];
  const body = node.children.slice(1);
  if (rest) {
    body.unshift({
      type: 'paragraph',
      children: rest as PhrasingContent[],
    });
  }
 
  return createCallout(
    match[1],
    [
      {
        type: 'paragraph',
        children: title as PhrasingContent[],
      },
    ],
    body,
  );
}

Copyconst Regex = /(?<!\\)\^(?<block_id>\w+)$/m;

Copyvisit(tree, 'paragraph', (node) => {
  let id: string | undefined;
 
  visit(
    node,
    ['link', 'text', 'mdxJsxFlowElement'],
    (textNode) => {
      if (textNode.type !== 'text') return 'skip';
 
      const value = textNode.value;
      const match = Regex.exec(value);
      // if last text node isn't a block id, skip
      if (!match) return false;
 
      id = match[1];
      textNode.value =
        value.slice(0, match.index).trimEnd() + value.slice(match.index + match[0].length);
      return false;
    },
    true,
  );
 
  if (id) {
    replace(node, {
      type: 'mdxJsxFlowElement',
      name: 'section',
      attributes: [
        {
          type: 'mdxJsxAttribute',
          name: 'id',
          value: `^${id}`,
        },
      ],
      children: [
        {
          ...node,
        },
      ],
    } satisfies MdxJsxFlowElement);
  }
 
  return 'skip';
});