cantip 0.1.0

package/scripts/obsidian/markdown.ts

@@ -0,0 +1,56 @@
+import { fromMarkdown } from 'mdast-util-from-markdown'
+import { remark } from 'remark'
+import remarkFrontmatter from 'remark-frontmatter'
+import remarkGfm from 'remark-gfm'
+import remarkMath from 'remark-math'
+import { VFile } from 'vfile'
+
+import { remarkObsidian, type TransformContext } from './remark.ts'
+
+let processor: ReturnType<typeof remark> | undefined
+
+export async function transformMarkdownToString(
+  filePath: string,
+  markdown: string,
+  context: TransformContext,
+): Promise<TransformResult> {
+  const file = await getProcessor(context).process(getVFile(filePath, markdown, context))
+
+  return {
+    aliases: file.data.aliases,
+    content: String(file),
+    skip: file.data.skip === true,
+    type: file.data.isMdx === true ? 'mdx' : 'markdown',
+  }
+}
+
+export async function transformMarkdownToAST(filePath: string, markdown: string, context: TransformContext) {
+  const { content } = await transformMarkdownToString(filePath, markdown, context)
+  return fromMarkdown(content)
+}
+
+function getProcessor(context: TransformContext): ReturnType<typeof remark> {
+  processor ??= remark()
+    .data('settings', { resourceLink: true })
+    .use(remarkGfm)
+    .use(remarkMath, { singleDollarTextMath: context.singleDollarTextMath })
+    .use(remarkFrontmatter)
+    .use(remarkObsidian)
+
+  return processor
+}
+
+function getVFile(filePath: string, markdown: string, context: TransformContext) {
+  return new VFile({
+    data: { ...context },
+    path: filePath,
+    value: markdown,
+  })
+}
+
+interface TransformResult {
+  aliases: string[] | undefined
+  content: string
+  skip: boolean
+  type: 'markdown' | 'mdx'
+}

package/scripts/obsidian/obsidian.ts

@@ -0,0 +1,229 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+import { z } from 'zod'
+import decodeUriComponent from 'decode-uri-component'
+import { slug } from 'github-slugger'
+import { globby } from 'globby'
+import yaml from 'yaml'
+
+import type { ObsidianConfig } from './types.ts'
+
+import { isDirectory, isFile } from './fs.ts'
+import { getExtension, isAnchor, slashify, slugifyPath, stripExtension } from './path.ts'
+import { isAssetFile } from './files.ts'
+
+const obsidianAppConfigSchema = z.object({
+  newLinkFormat: z.union([z.literal('absolute'), z.literal('relative'), z.literal('shortest')]).default('shortest'),
+  useMarkdownLinks: z.boolean().default(false),
+})
+
+const obsidianFrontmatterSchema = z.object({
+  aliases: z
+    .array(z.string())
+    .optional()
+    .nullable()
+    .transform((aliases) => aliases?.map((alias) => slug(alias))),
+  cover: z.string().optional().nullable(),
+  description: z.string().optional().nullable(),
+  image: z.string().optional().nullable(),
+  permalink: z.string().optional().nullable(),
+  publish: z
+    .union([z.boolean(), z.literal('true'), z.literal('false')])
+    .optional()
+    .nullable()
+    .transform((publish) => publish === undefined || publish === 'true' || publish === true),
+  tags: z.array(z.string()).optional().nullable(),
+})
+
+const imageFileFormats = new Set(['.avif', '.bmp', '.gif', '.jpeg', '.jpg', '.png', '.svg', '.webp'])
+const audioFileFormats = new Set(['.flac', '.m4a', '.mp3', '.wav', '.ogg', '.wav', '.3gp'])
+const videoFileFormats = new Set(['.mkv', '.mov', '.mp4', '.ogv', '.webm'])
+const otherFileFormats = new Set(['.pdf'])
+
+const fileFormats = new Set([...imageFileFormats, ...audioFileFormats, ...videoFileFormats, ...otherFileFormats])
+
+export async function getVault(config: ObsidianConfig): Promise<Vault> {
+  const vaultPath = path.resolve(config.vault)
+
+  if (!(await isDirectory(vaultPath))) {
+    throw new Error(`The provided vault path is not a directory.\n> Provided path: ${vaultPath}`)
+  }
+
+  // A real Obsidian vault carries `.obsidian/app.json`; a plain "loose content
+  // folder" (a supported input mode) does not. For the latter, fall back to
+  // Obsidian's own defaults (shortest wikilinks) instead of erroring, so users
+  // can point a project `source` at any directory of markdown.
+  const options = (await isVaultDirectory(config, vaultPath))
+    ? await getVaultOptions(config, vaultPath)
+    : { linkFormat: 'shortest' as const, linkSyntax: 'wikilink' as const }
+
+  return {
+    options,
+    path: slashify(vaultPath),
+  }
+}
+
+export function getObsidianPaths(vault: Vault, ignore: ObsidianConfig['ignore'] = []) {
+  return globby(['**/*.md', ...[...fileFormats].map((fileFormat) => `**/*${fileFormat}`)], {
+    absolute: true,
+    cwd: vault.path,
+    ignore,
+  })
+}
+
+export function getObsidianVaultFiles(vault: Vault, obsidianPaths: string[]): VaultFile[] {
+  const allFileNames = obsidianPaths.map((obsidianPath) => path.basename(obsidianPath))
+
+  return obsidianPaths.map((obsidianPath, index) => {
+    const baseFileName = allFileNames[index] as string
+    let fileName = baseFileName
+
+    const type = isAssetFile(fileName) ? 'asset' : isObsidianFile(fileName) ? 'file' : 'content'
+
+    if (type === 'asset') {
+      fileName = slugifyPath(fileName)
+    }
+
+    const filePath = getObsidianRelativePath(vault, obsidianPath)
+    const fileSlug = slugifyObsidianPath(filePath)
+
+    return createVaultFile({
+      fileName,
+      fsPath: obsidianPath,
+      path: type === 'asset' ? fileSlug : filePath,
+      slug: fileSlug,
+      stem: stripExtension(fileName),
+      type,
+      uniqueFileName: allFileNames.filter((currentFileName) => currentFileName === baseFileName).length === 1,
+    })
+  })
+}
+
+export function getObsidianRelativePath(vault: Vault, obsidianPath: string) {
+  return obsidianPath.replace(vault.path, '')
+}
+
+export function slugifyObsidianPath(obsidianPath: string) {
+  const segments = obsidianPath.split('/')
+
+  return segments
+    .map((segment, index) => {
+      const isLastSegment = index === segments.length - 1
+
+      if (!isLastSegment) {
+        return slug(decodeUriComponent(segment))
+      } else if (isObsidianFile(segment) && !isAssetFile(segment)) {
+        return decodeUriComponent(segment)
+      } else if (isAssetFile(segment)) {
+        return `${slug(decodeUriComponent(stripExtension(segment)))}${getExtension(segment)}`
+      }
+
+      return slug(decodeUriComponent(stripExtension(segment)))
+    })
+    .join('/')
+}
+
+export function slugifyObsidianAnchor(obsidianAnchor: string) {
+  if (obsidianAnchor.length === 0) {
+    return ''
+  }
+
+  let anchor = isAnchor(obsidianAnchor) ? obsidianAnchor.slice(1) : obsidianAnchor
+
+  if (isObsidianBlockAnchor(anchor)) {
+    anchor = anchor.replace('^', 'block-')
+  }
+
+  return `#${slug(decodeURIComponent(anchor))}`
+}
+
+export function isObsidianBlockAnchor(anchor: string) {
+  return anchor.startsWith('#^') || anchor.startsWith('^')
+}
+
+export function isObsidianFile(filePath: string, type?: 'image' | 'audio' | 'video' | 'other') {
+  const formats: Set<string> =
+    type === undefined
+      ? fileFormats
+      : type === 'image'
+        ? imageFileFormats
+        : type === 'audio'
+          ? audioFileFormats
+          : type === 'video'
+            ? videoFileFormats
+            : otherFileFormats
+
+  return formats.has(getExtension(filePath))
+}
+
+export function parseObsidianFrontmatter(content: string): ObsidianFrontmatter | undefined {
+  try {
+    const raw: unknown = yaml.parse(content)
+    return { ...obsidianFrontmatterSchema.parse(raw), raw: raw as ObsidianFrontmatter['raw'] }
+  } catch {
+    return
+  }
+}
+
+export function createVaultFile(baseVaultFile: BaseVaultFile) {
+  return {
+    ...baseVaultFile,
+    isEqualFileName(otherFileName: string) {
+      return (isAssetFile(otherFileName) ? slugifyPath(otherFileName) : otherFileName) === this.fileName
+    },
+    isEqualStem(otherStem: string) {
+      return (isAssetFile(otherStem) ? slugifyPath(otherStem) : otherStem) === this.stem
+    },
+  }
+}
+
+async function isVaultDirectory(config: ObsidianConfig, vaultPath: string) {
+  const configPath = path.join(vaultPath, config.configFolder)
+  return (await isDirectory(configPath)) && (await isFile(path.join(configPath, 'app.json')))
+}
+
+async function getVaultOptions(config: ObsidianConfig, vaultPath: string): Promise<VaultOptions> {
+  const appConfigPath = path.join(vaultPath, config.configFolder, 'app.json')
+
+  try {
+    const appConfigData = await fs.readFile(appConfigPath, 'utf8')
+    const appConfig = obsidianAppConfigSchema.parse(JSON.parse(appConfigData))
+
+    return {
+      linkFormat: appConfig.newLinkFormat,
+      linkSyntax: appConfig.useMarkdownLinks ? 'markdown' : 'wikilink',
+    }
+  } catch (error) {
+    throw new Error('Failed to read Obsidian vault app configuration.', { cause: error })
+  }
+}
+
+export interface Vault {
+  options: VaultOptions
+  path: string
+}
+
+interface VaultOptions {
+  linkFormat: 'absolute' | 'relative' | 'shortest'
+  linkSyntax: 'markdown' | 'wikilink'
+}
+
+interface BaseVaultFile {
+  fileName: string
+  fsPath: string
+  path: string
+  slug: string
+  stem: string
+  type: 'asset' | 'content' | 'file'
+  uniqueFileName: boolean
+}
+
+export interface VaultFile extends BaseVaultFile {
+  isEqualFileName: (otherFileName: string) => boolean
+  isEqualStem: (otherStem: string) => boolean
+}
+
+export type ObsidianFrontmatter = z.output<typeof obsidianFrontmatterSchema> & {
+  raw: Record<string | number, unknown>
+}

package/scripts/obsidian/path.ts

@@ -0,0 +1,60 @@
+import path from 'node:path'
+
+import { slug } from 'github-slugger'
+
+export function getExtension(filePath: string) {
+  return path.parse(filePath).ext
+}
+
+export function stripExtension(filePath: string) {
+  return path.parse(filePath).name
+}
+
+export function extractPathAndAnchor(filePathAndAnchor: string): [string, string | undefined] {
+  const [filePath, fileAnchor] = filePathAndAnchor.split('#', 2)
+  return [filePath as string, fileAnchor]
+}
+
+export function isAnchor(filePath: string): filePath is `#${string}` {
+  return filePath.startsWith('#')
+}
+
+export function slugifyPath(filePath: string) {
+  const segments = filePath.split('/')
+  return segments
+    .map((segment, index) => {
+      const isLastSegment = index === segments.length - 1
+      if (!isLastSegment) {
+        return slug(segment)
+      }
+      const parsedPath = path.parse(segment)
+      return `${slug(parsedPath.name)}${parsedPath.ext}`
+    })
+    .join('/')
+}
+
+export function slashify(filePath: string) {
+  const isExtendedLengthPath = filePath.startsWith('\\\\?\\')
+  if (isExtendedLengthPath) {
+    return filePath
+  }
+  return filePath.replaceAll('\\', '/')
+}
+
+export function osPath(filePath: string) {
+  return filePath.replaceAll('/', path.sep)
+}
+
+function stripLeadingSlash(href: string) {
+  if (href.startsWith('/')) href = href.slice(1)
+  return href
+}
+
+function stripTrailingSlash(href: string) {
+  if (href.endsWith('/')) href = href.slice(0, -1)
+  return href
+}
+
+export function stripLeadingAndTrailingSlashes(href: string): string {
+  return stripTrailingSlash(stripLeadingSlash(href))
+}

package/scripts/obsidian/rehype.ts

@@ -0,0 +1,60 @@
+import type { Element, ElementContent, Root } from 'hast'
+import type { Literal } from 'mdast'
+import { CONTINUE, SKIP, visit } from 'unist-util-visit'
+
+const blockIdentifierRegex = /(?<identifier> *\^(?<name>[\w-]+))$/
+
+export function rehypeObsidian() {
+  return function transformer(tree: Root) {
+    visit(tree, 'element', (node) => {
+      if (node.tagName === 'blockquote') {
+        const lastChild = node.children.at(-1)
+        if (
+          lastChild?.type !== 'element' ||
+          !(lastChild.tagName === 'p' || lastChild.tagName === 'ul' || lastChild.tagName === 'ol')
+        ) {
+          return CONTINUE
+        }
+        const lastGrandChild = lastChild.children.at(-1)
+        if (lastChild.tagName === 'p') {
+          return transformBlockIdentifier(node, lastGrandChild)
+        } else if (lastGrandChild?.type === 'element' && lastGrandChild.tagName === 'li') {
+          return transformBlockIdentifier(node, lastGrandChild.children.at(-1))
+        }
+      } else if (node.tagName === 'p' || node.tagName === 'li') {
+        return transformBlockIdentifier(node, node.children.at(-1))
+      }
+      return CONTINUE
+    })
+  }
+}
+
+function transformBlockIdentifier(reference: Element, node: ElementContent | undefined) {
+  if (!isNodeWithValue(node)) {
+    return CONTINUE
+  }
+  const identifier = getBlockIdentifer(node)
+  if (!identifier) {
+    return CONTINUE
+  }
+  node.value = node.value.slice(0, identifier.length * -1)
+  reference.properties = reference.properties ?? {}
+  reference.properties['id'] = `block-${identifier.name}`
+  return SKIP
+}
+
+function isNodeWithValue(node: ElementContent | undefined): node is NodeWithValue {
+  return node !== undefined && 'value' in node
+}
+
+function getBlockIdentifer(node: NodeWithValue): { length: number; name: string } | undefined {
+  const match = blockIdentifierRegex.exec(node.value)
+  const identifier = match?.groups?.['identifier']
+  const name = match?.groups?.['name']
+  if (!identifier || !name) {
+    return undefined
+  }
+  return { length: identifier.length, name }
+}
+
+type NodeWithValue = ElementContent & Literal