ts-ag 0.0.1-dev.1 → 0.0.1-dev.2

package/src/rehype/flat-toc.ts

@@ -0,0 +1,78 @@
+import type { Root, RootContent, Element } from 'hast';
+import type { Plugin } from 'unified';
+import type { VFile } from 'vfile';
+import { unified } from 'unified';
+import rehypeParse from 'rehype-parse';
+
+/**
+ * This rehype plugin extracts the headings from the markdown elements but also the raw elements.
+ * So we get html headings in the TOC as well
+ *
+ * It sets the file.data.fm.toc to a flat map of the toc
+ */
+export const extractToc: Plugin<[], Root> = () => {
+  return (tree: Root, file: VFile) => {
+    const details = tree.children.flatMap(extractDetails);
+    if (file.data.fm === undefined) file.data.fm = {};
+    // @ts-expect-error its untyped but for svmdex it is there
+    file.data.fm.toc = details;
+  };
+};
+export type Toc = TocEntry[];
+export type TocEntry = {
+  level: number;
+  id: string;
+  value: string;
+};
+
+function extractDetails(
+  content:
+    | RootContent
+    | {
+        type: 'raw';
+        value: string;
+      }
+): TocEntry[] {
+  if (content.type === 'element' && content.tagName.startsWith('h') && 'id' in content.properties) {
+    const value =
+      content.children.length === 1 && content.children[0].type === 'text'
+        ? content.children[0].value
+        : content.properties.id;
+    return [
+      {
+        level: parseInt(content.tagName.slice(1)),
+        id: content.properties.id,
+        value
+      }
+    ];
+  } else if (content.type === 'raw') {
+    const parsed = parseRaw(content.value);
+    return parsed.flatMap(extractDetails);
+  }
+  return [];
+}
+
+/**
+ * Parses raw HTML and returns a flat array of all heading (h1-h6) elements as HAST nodes.
+ */
+export function parseRaw(raw: string): Element[] {
+  // Parse the HTML string into a HAST Root node
+  const tree = unified()
+    .use(rehypeParse, { fragment: true }) // allow parsing HTML fragments
+    .parse(raw) as Root;
+
+  // Helper function to recursively find heading elements
+  function collectHeadings(node: RootContent): Element[] {
+    if (node.type === 'element' && /^h[1-6]$/.test(node.tagName)) {
+      return [node];
+    }
+    // Check children recursively
+    if ('children' in node && Array.isArray(node.children)) {
+      return node.children.flatMap(collectHeadings);
+    }
+    return [];
+  }
+
+  // Flatten all headings found in the tree
+  return tree.children.flatMap(collectHeadings);
+}

package/src/rehype/index.ts

@@ -0,0 +1 @@
+export * from './browser.js'

package/src/scripts/clean.ts

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+interface Args {
+  dirExcludes: string[];
+  dirIncludes: string[];
+}
+
+function parseArgs(): Args {
+  const args = process.argv.slice(2);
+  const dirExcludes: string[] = [];
+  const dirIncludes: string[] = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--dir-excludes' && args[i + 1]) {
+      dirExcludes.push(args[i + 1]);
+      i++;
+    } else if (args[i] === '--dir-includes' && args[i + 1]) {
+      dirIncludes.push(args[i + 1]);
+      i++;
+    }
+  }
+  return { dirExcludes, dirIncludes };
+}
+
+function shouldExclude(dir: string, excludes: string[]): boolean {
+  return excludes.some((ex) => path.basename(dir) === ex);
+}
+
+function shouldInclude(dir: string, includes: string[]): boolean {
+  if (includes.length === 0) return true;
+  return includes.some((inc) => dir.includes(inc));
+}
+
+function removeDir(targetPath: string) {
+  if (fs.existsSync(targetPath)) {
+    fs.rmSync(targetPath, { recursive: true, force: true });
+    console.log(`Removed: ${targetPath}`);
+  }
+}
+
+function clean(root: string, args: Args) {
+  const entries = fs.readdirSync(root, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(root, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === 'node_modules') continue;
+      if (entry.name === 'dist') {
+        const distParentDir = path.dirname(fullPath);
+        const siblingDirs = fs
+          .readdirSync(distParentDir, { withFileTypes: true })
+          .filter((d) => d.isDirectory())
+          .map((d) => d.name);
+
+        const shouldExcludeSibling = args.dirExcludes.some((ex) => siblingDirs.includes(ex));
+        const shouldIncludeSibling =
+          args.dirIncludes.length === 0 || args.dirIncludes.some((inc) => siblingDirs.includes(inc));
+
+        if (!shouldExcludeSibling && shouldIncludeSibling) {
+          removeDir(fullPath);
+        }
+        continue;
+      }
+      if (!shouldExclude(fullPath, args.dirExcludes)) {
+        clean(fullPath, args);
+      }
+    } else if (entry.name === 'tsconfig.tsbuildinfo') {
+      removeDir(fullPath);
+    }
+  }
+}
+
+const args = parseArgs();
+clean(process.cwd(), args);

package/src/utils/fs.ts

@@ -0,0 +1,42 @@
+import { lstat, mkdir, readFile, writeFile } from 'fs/promises';
+import { dirname } from 'path';
+import chalk from 'chalk';
+
+/**
+ * @returns true if a filepath exists
+ */
+export async function exists(filePath: string): Promise<boolean> {
+  try {
+    await lstat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Writes data to a filepath if it is different
+ */
+export async function writeIfDifferent(filePath: string, newData: string) {
+  // Ensure the directory exists
+  const directory = dirname(filePath);
+  if (!(await exists(directory))) {
+    await mkdir(directory, { recursive: true });
+  }
+
+  // Check if the file exists
+  if (await exists(filePath)) {
+    // Read the existing file content
+    const existingData = await readFile(filePath, 'utf8');
+
+    // Compare the existing data with the new data
+    if (existingData === newData) {
+      // console.log('File contents are identical. No write needed.');
+      return;
+    }
+  }
+
+  // Write the new data if it's different or the file doesn't exist
+  await writeFile(filePath, newData, 'utf8');
+  console.log(chalk.green('Writing to'), filePath);
+}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './fs.js'