@p-buddy/parkdown 0.0.0

package/src/utils.test.ts

@@ -0,0 +1,238 @@
+import { describe, expect, test } from "vitest";
+import { parse, nodeSort, getAllPositionNodes, extractContent, replaceWithContent, getContentInBetween, } from "./utils";
+
+describe(nodeSort.name, () => {
+  test("should sort nodes by line number", () => {
+    const ast = parse.md(lorem.md[0]);
+    let previousLine = 0;
+    let previousColumn = 0;
+    for (const node of getAllPositionNodes(ast).sort(nodeSort)) {
+      const lineIncreased = node.position.start.line > previousLine;
+      const lineStayedTheSame = node.position.start.line === previousLine;
+      const columnIncreased = node.position.start.column > previousColumn;
+      const columnStayedTheSame = node.position.start.column === previousColumn;
+      expect(lineIncreased || (lineStayedTheSame && (columnIncreased || columnStayedTheSame))).toBe(true);
+      previousLine = node.position.start.line;
+      previousColumn = node.position.start.column;
+    }
+    previousLine += 1;
+    previousColumn = 0;
+    for (const node of getAllPositionNodes(ast).sort(nodeSort.reverse)) {
+      const lineDecreased = node.position.start.line < previousLine;
+      const lineStayedTheSame = node.position.start.line === previousLine;
+      const columnDecreased = node.position.start.column < previousColumn;
+      const columnStayedTheSame = node.position.start.column === previousColumn;
+      expect(lineDecreased || (lineStayedTheSame && (columnDecreased || columnStayedTheSame))).toBe(true);
+      previousLine = node.position.start.line;
+      previousColumn = node.position.start.column;
+    }
+  });
+})
+
+const getLinkAndCommentAst = (markdown: string) => {
+  const ast = parse.md(markdown);
+  const links = getAllPositionNodes(ast, "link");
+  expect(links.length).toBe(1);
+  const comments = getAllPositionNodes(ast, "html");
+  expect(comments.length).toBe(1);
+  return { link: links[0], comment: comments[0], ast, markdown };
+}
+
+describe(extractContent.name, () => {
+  test("should extract content from nodes", () => {
+    const { link, comment, ast, markdown } = getLinkAndCommentAst(`
+# Title
+
+[link](http://example.com)
+hello
+<!-- comment -->`
+    );
+
+    let content = extractContent(markdown, link);
+    expect(content).toBe("[link](http://example.com)");
+
+    content = extractContent(markdown, comment);
+    expect(content).toBe("<!-- comment -->");
+
+    content = extractContent(markdown, link, comment);
+    expect(content).toBe("[link](http://example.com)\nhello\n<!-- comment -->");
+    expect(content).toBe(extractContent(markdown, comment, link));
+  })
+})
+
+describe(replaceWithContent.name, () => {
+  test("should replace content with new content", () => {
+    const { link, comment, ast, markdown } = getLinkAndCommentAst(`
+# Title
+
+[link](http://example.com)
+hello
+<!-- comment -->
+
+ahoy!`
+    );
+    const content = replaceWithContent(markdown, "new content", link, comment);
+    expect(content).toBe("\n# Title\n\nnew content\n\nahoy!");
+  })
+});
+
+describe(getContentInBetween.name, () => {
+  test("should get content in between two multiline nodes", () => {
+    const { link, comment, ast, markdown } = getLinkAndCommentAst(`
+# Title
+
+[link](http://example.com)
+hello
+<!-- comment -->`
+    );
+    const content = getContentInBetween(markdown, link, comment);
+    expect(content).toBe("\nhello\n");
+  });
+
+  test("should get content in between two singleline nodes", () => {
+    const { link, comment, ast, markdown } = getLinkAndCommentAst(`
+# Title
+
+[link](http://example.com) hello <!-- comment -->`
+    );
+    const content = getContentInBetween(markdown, link, comment);
+    expect(content).toBe(" hello ");
+  })
+});
+
+interface PsuedoDir {
+  [key: string]: PsuedoDir | string;
+}
+
+export class PsuedoFilesystem {
+  constructor(readonly root: PsuedoDir, options?: { setContentToPath?: boolean }) {
+    const { setContentToPath = false } = options ?? {};
+    if (setContentToPath) PsuedoFilesystem.SetAllFileContentToPath(this.root);
+  }
+
+  getFileFromAbsolutePath(path: string) {
+    return path.split("/").reduce((acc, part) => (acc as Record<string, PsuedoDir>)[part], this.root) as any as string;
+  }
+
+  static SetAllFileContentToPath(root: PsuedoDir, prefix?: string) {
+    for (const key in root) {
+      const value = root[key];
+      const path = prefix ? `${prefix}/${key}` : key;
+      if (typeof value === "string") root[key] = path;
+      else this.SetAllFileContentToPath(value, path);
+    }
+  }
+}
+
+export const lorem = {
+  md: [
+    `# Vi nactusque pelle at floribus irata quamvis
+
+## Moenibus voluptas ludit
+
+Lorem markdownum cornua, iter quiete, officiumque arbor vocisque, [alti
+lumina](http://fundae.io/illa.aspx) Agenore. Vendit ob meos, mihi monitis saxum
+noster, est eandem ante, tuos sopitus scopulis volentem. Rege semper iaculo
+protinus poenae curribus increpat Stygias scire: prohibent, et regis in.
+Profanos mecum muneris, dum iudicis eurus non sua accepit auras utque staret.
+
+## Filius virgo culpa reliquit
+
+Illa moenia vepre clauso o **praemia** fluidoque primo est, modo tamen tumultu
+adorat: rogumque ursa **in**. Solum consensistis illis, Ithacis cuncti ver vidit
+carbasa fluctibus ratione eundem mihi. Vineta *unda*, nec victricia, nullaque,
+inploravere *poteram quae erat* et videt summas regia ferunt se, se?
+
+## Illa nuncupat ante proxima habenti prodit
+
+Sua qui passis barbam *mira*: adfer pericula; aut. Tua purpuraque passim
+attulerat lanas monitae Turnus patrium cuius fuerat stupet exercent sine.
+Incaluitque premebat ad elisa ut meruisse dum *solutis*, damnare. Texit Libycas,
+est nunc Phoebus. Dominaeque meriti caligine vestigia *extentam* citra tecto
+undas impetus alma, quam radix.
+
+1. Umbras laudare per telo lacrimis
+2. Saturno Andraemon Iovem
+3. Cum eadem
+4. Vacent Britannos neque quae rupit socialia pulcherrime
+5. Vidit morsu
+
+## Aut visam
+
+Micantes *flecti*. Capitolia et aut haec *Latoius manet submersum* et non tumens
+paternis. Ope cornua calidumque artes. Quoque forma, quae gemitus sanguine per
+cunctos hanc est haec abstulit acumine morte hoc fui.
+
+> Trepidare cum expellere pectus Ismenus tempora fulminis pater; coniunctaque
+> vocabis placandam et ebori separat. Regna inpensius pater accipienda epytus
+> *Phryges cum angustis* vehit; nec summo excutit Aulidaque partibus texitur
+> perque indomitas frater. Sua ferens discedet et quae, sonantia, comminus
+> *ego*, auras. Dives **ille dubitate eum** poterit adest marito bracchia nec
+> tune, discordemque tanti credas caede hactenus, dumque. At et agros Laiades,
+> illa virtute adorat, est mox palmiferos robore flere ubera.
+
+Color genuumque natis Pactolides plangore concipiunt proxima est, aliquid,
+iraque ad natus quoque? **Quoque et** et classe fidemque incepta qui cumque
+latitans ac [vestrum](http://fallitquevolucris.org/fuerant-eris).`,
+    `# Ipse oculis praecipitata nostro
+
+## Victis ferroque umbram mors plenis
+
+Lorem markdownum, angues nec pecudis ponat dabitur qua resedit. Genitor tellus
+et loqui hac: et nullae regnaque, est. Durescit videri. Nunc navita cruento,
+cum, puerilibus aequor. Pro saepe [iamque](http://saturnoquod.com/nullum),
+statione noverat, simul teneri hoc idem opem: Peleus.
+
+## Pro nisi vaticinos posse
+
+Clymenen nec caesa reddi. Vocat cum, spectare in tamen te fugacibus, haut. Solus
+extulit insistere pugnas praestatque modo purpureis venenata [tumet
+sed](http://www.mihi-duc.com/ferro) curru sanguine levatus magnanimo. Dulichium
+indulsit.
+
+## Humano Gorgoneum portus nil pavens laboriferi rapui
+
+Faciles non, Iris vero [medeatur reclusis](http://www.tendere.io/somnus) digna
+et sumptis est feres viae hic huc barbae salus laetos. Et ante! Quid lumen Isi:
+nec Rhenum, profecturas priorum aegide medias in coniugis cinctaque ad ignis
+posito. Nubila in alternaque Procnes terrae adferre sentit postquam cui rerum
+nubilus fulvas iam illis cum virgultis, unda [ipse
+tamen](http://www.terra.org/nam.html).
+
+    var port = uncForumRt(ccd * dpi_udp(1, 1, 52557),
+            pppoe_scraping_switch.passive(adf_domain, floating +
+            standaloneDnsPppoe, trashFileLed / safe_error_recursive), 2);
+    if (-2) {
+        bpsPOn = hardwareIso(1);
+        vaporware_biometrics.wddm_spool_compile += multimediaStation(
+                drop_property_boot, sms, crop_excel(2, snmp_truncate_inkjet));
+    }
+    softMetadata.installer = 4;
+    var hdtv = printer_json_southbridge;
+
+## Multorum pellant famularia praeterea humo
+
+Carmine demisi super nantis **telo**! Dicimus requievit, lurida extenuant
+**diverso paventis venter** ore medio deposuitque ex fons: Iuno latratibus.
+Mediaque tum *Eurus*, unam nympha casu ille licet sinu est modo, celasse tamen.
+
+## Quem puto suis semper expers hominis Placatus
+
+**Sidera arma**; Iuventae loca victis: necis acies ducunt ipse non **precesque
+petit demptos** effetus: oculis mittunt. In nam vox regia sustinet nervosque
+obsceno Delphi haec genetrix Nereus [versasque
+quaeratur](http://te-urbem.net/aqua). Terga deae natalis *Aetnen* ingemuit, cum
+arserunt vertice **egimus** fama visa illic ipsamque.
+
+1. Post petit unum accepisse obsequio populator praesagia
+2. Terrena iam mora libera
+3. Suas astra inflata litore crimine
+
+Quibus viribus referam **est posse** Iphis extulerat oscula, clivum, tantum
+patres formam villis [hic pruinas
+remisit](http://quaeebur.com/condi-summas.aspx). In qui cum, **lac fugavi
+Perseus**. Me iusta habitabat stabat tam locum similes pulsant; manu palantesque
+deae cohaesit, nec ut opiferque fugientem eurus. Eodem vivit Aiaci minas non,
+radices in petent audacia volabat pro dedit ducibusque et vertice abstinuit.`
+  ] as const
+}

package/src/utils.ts

@@ -0,0 +1,184 @@
+import { unified, type Plugin } from 'unified';
+import remarkParse from 'remark-parse';
+import { visit } from 'unist-util-visit';
+import hash from 'stable-hash';
+
+export type AstRoot = typeof remarkParse extends Plugin<any, any, infer Root>
+/**/ ? Root
+/**/ : never;
+
+export type MarkdownNode = AstRoot["children"][number];
+export type NodeType = MarkdownNode["type"];
+export type SpecificNode<T extends NodeType> = MarkdownNode & { type: T };
+
+type RequiredDeep<T> = {
+  [P in keyof T]-?: T[P] extends object | undefined ? RequiredDeep<T[P]> : T[P];
+};
+
+export type HasPosition = RequiredDeep<Pick<MarkdownNode, "position">>;
+export type Position = HasPosition['position'];
+export type Point = Position['start' | 'end'];
+
+export const nodeSort = (a: HasPosition, b: HasPosition) => a.position.start.offset - b.position.start.offset;
+
+nodeSort.reverse = (a: HasPosition, b: HasPosition) => nodeSort(b, a);
+
+export const hasPosition = <T extends MarkdownNode>(node: T): node is T & HasPosition =>
+  node.position !== undefined && node.position.start.offset !== undefined && node.position.end.offset !== undefined;
+
+const processor = unified().use(remarkParse);
+
+export const parse = {
+  md: (markdown: string) => processor.parse(markdown) satisfies AstRoot
+} as const;
+
+export const getAllPositionNodes = <T extends NodeType>(ast: AstRoot, type?: T) => {
+  type Node = SpecificNode<T> & HasPosition & { parentID: string; siblingIndex: number; siblingCount: number };
+  const nodes: Node[] = [];
+  visit(ast, (node, siblingIndex, parent) => {
+    if (node.type === "root") return;
+    else if (type && node.type !== type) return;
+    else if (hasPosition(node)) {
+      const parentID = hash(parent);
+      const siblingCount = (parent?.children.length ?? 0) - 1;
+      nodes.push({ ...node, parentID, siblingIndex, siblingCount } as Node);
+    }
+  });
+  return nodes;
+}
+
+export type PositionNode<T extends NodeType> = ReturnType<typeof getAllPositionNodes<T>>[number];
+
+export type Link = PositionNode<"link">;
+export type Html = PositionNode<"html">;
+
+export const linkHasNoText = (node: Link) => node.children.length === 0;
+
+export const extractContent = (markdown: string, ...nodes: HasPosition[]) => {
+  if (nodes.length === 0) throw new Error("No nodes to extract content from");
+  nodes.sort(nodeSort);
+  const head = nodes.at(0)!;
+  const tail = nodes.at(-1)!;
+  return markdown.slice(head.position.start.offset, tail.position.end.offset);
+}
+
+export const replaceWithContent = (markdown: string, content: string, ...nodes: HasPosition[]) => {
+  if (nodes.length === 0) throw new Error("No nodes to replace content from");
+  nodes.sort(nodeSort);
+  const head = nodes.at(0)!;
+  const tail = nodes.at(-1)!;
+  return markdown.slice(0, head.position.start.offset) + content + markdown.slice(tail.position.end.offset);
+}
+
+export const getContentInBetween = (markdown: string, a: HasPosition, b: HasPosition) => {
+  const head = Math.min(a.position.end.offset, b.position.end.offset);
+  const tail = Math.max(a.position.start.offset, b.position.start.offset);
+  return markdown.slice(head, tail);
+}
+
+type Join<T extends string[], D extends string> =
+  T extends []
+    /**/ ? ''
+    /**/ : T extends [infer F extends string]
+      /**/ ? F
+      /**/ : T extends [infer F extends string, ...infer R extends string[]]
+        /**/ ? `${F}${D}${Join<R, D>}`
+        /**/ : string;
+
+export const spaced = <T extends string[]>(...args: T) => args.join(" ") as Join<T, " ">;
+export const lined = <T extends string[]>(...args: T) => args.join("\n") as Join<T, "\n">;
+
+export const start = ({ position: { start } }: HasPosition) => start;
+
+const offsetIndex = ({ start, end }: Position, offset: number) =>
+  ({ start: { line: start.line + offset, column: start.column + offset }, end: { line: end.line + offset, column: end.column + offset } });
+
+export const zeroIndexed = (position: Position) => offsetIndex(position, -1);
+export const oneIndexed = (position: Position) => offsetIndex(position, 1);
+
+export const seperateQueryParams = (path: string): [lhs: string, query: string] => {
+  const parts = path.split("?");
+  return parts.length > 1 ? [parts.slice(0, -1).join("?"), parts.at(-1)!] : [path, ""];
+}
+
+export const getQueryParams = (path: string) => seperateQueryParams(path)[1];
+
+export const removeQueryParams = (path: string) => seperateQueryParams(path)[0];
+
+
+export class Intervals {
+  private intervals: Array<[number, number]> = [];
+
+  push(start: number, end: number) {
+    this.intervals.push([Math.min(start, end), Math.max(start, end)]);
+  }
+
+  combine(rhs: Intervals) {
+    this.intervals.push(...rhs.intervals);
+  }
+
+  collapse() {
+    const { intervals } = this;
+    if (!intervals.length) return (this.intervals = []);
+
+    intervals.sort((a, b) => a[0] - b[0]);
+
+    const result: typeof this.intervals = [];
+    let [currStart, currEnd] = intervals[0];
+
+    for (let i = 1; i < intervals.length; i++) {
+      const [start, end] = intervals[i];
+      if (start <= currEnd) currEnd = Math.max(currEnd, end);
+      else {
+        result.push([currStart, currEnd]);
+        currStart = start;
+        currEnd = end;
+      }
+    }
+    result.push([currStart, currEnd]);
+
+    return (this.intervals = result);
+  }
+
+  subtract(rhs: Intervals) {
+    const { intervals } = this;
+    const { intervals: remove } = rhs;
+
+    if (!intervals.length || !remove.length) return intervals;
+
+    let result = [...intervals];
+    for (const [removeStart, removeEnd] of remove) {
+      const updated: typeof this.intervals = [];
+
+      for (const [start, end] of result) {
+        if (removeEnd <= start || removeStart >= end) {
+          updated.push([start, end]);
+          continue;
+        }
+
+        if (removeStart > start) updated.push([start, removeStart]);
+        if (removeEnd < end) updated.push([removeEnd, end]);
+      }
+
+      result = updated;
+    }
+
+    return (this.intervals = result);
+  }
+}
+
+export const COMMA_NOT_IN_PARENTHESIS = /,\s*(?![^()]*\))/;
+
+/** p▼: sanitize */
+const sanitizations: [from: RegExp | string, to: string][] = [
+  [/'''/g, `"`],
+  [/''/g, `'`],
+  [/parkdown:\s+/g, ``],
+  [/p▼:\s+/g, ``],
+]
+
+export const sanitize = (replacement: string, space: string = "-") => {
+  const sanitized = sanitizations.reduce((acc, [from, to]) => acc.replaceAll(from, to), replacement)
+  return space ? sanitized.replaceAll(space, " ") : sanitized;
+}
+/** p▼: sanitize */

package/src/wrap.ts

@@ -0,0 +1,61 @@
+import { createParser, type MethodDefinition } from "./api/";
+
+/** p▼: definition */
+const definitions = [
+  /**
+   * Wraps the content in a markdown-formatted code block.
+   * @param lang The language of the code block (defaults to the file extension).
+   * @param meta Additional metadata to include in the top line of the code block (i.e. to the right of the `lang`).
+   * @example [](<url>?wrap=code)
+   * @example [](<url>?wrap=code())
+   * @example [](<url>?wrap=code(ts))
+   * @example [](<url>?wrap=code(,some-meta))
+   */
+  "code(lang?: string, meta?: string)",
+
+  /**
+   * Wraps the content in a markdown-formatted blockquote 
+   * (using the `>` character if the content is a single line, 
+   * or the `<blockquote>` tag if the content is a multi-line block).
+   * @example [](<url>?wrap=quote)
+   * @example [](<url>?wrap=quote())
+   * @example [](<url>?wrap=quote(,))
+   */
+  "quote()",
+
+  /**
+   * Wraps the content in a markdown-formatted dropdown (using the `<details>` and `<summary>` tags).
+   * @param summary The summary text of the dropdown.
+   * @param open Whether the dropdown should be open by default.
+   * @param space The space character to use between words in the summary (defaults to `-`).
+   * @example [](<url>?wrap=dropdown(hello-world))
+   * @example [](<url>?wrap=dropdown('hello,-world',true))
+   * @example [](<url>?wrap=dropdown(hello_world,,_)) 
+   */
+  "dropdown(summary: string, open?: boolean, space?: string)",
+
+] /** p▼: definition */ satisfies (MethodDefinition)[];
+
+/** p▼: Default-Space */
+const DEFAULT_SPACE = "-";
+/** p▼: Default-Space */
+
+const parse = createParser(definitions);
+
+export const wrap = (content: string, query: string, details?: { extension: string, inline: boolean }): string => {
+  const parsed = parse(query);
+  const isSingleLine = details?.inline && !content.includes("\n\n");
+
+  switch (parsed.name) {
+    case "code":
+      const lang = parsed.lang ?? details?.extension ?? "";
+      const meta = parsed.meta ? ` ${parsed.meta}` : "";
+      return `\`\`\`${lang}${meta}\n${content}\n\`\`\``;
+    case "quote":
+      return isSingleLine ? `> ${content}` : `<blockquote>\n\n${content}\n\n</blockquote>\n`;
+    case "dropdown":
+      const head = `<details${parsed.open ? " open" : ""}>`;
+      const summary = `<summary>${parsed.summary.split(parsed.space ?? DEFAULT_SPACE).join(" ")}</summary>`;
+      return ["", head, summary, "", content, "</details>", ""].join("\n");
+  }
+}

package/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "compilerOptions": {
+    "moduleResolution": "bundler",
+  }
+}

package/vite.cli.config.ts

@@ -0,0 +1,23 @@
+import { defineConfig } from 'vite';
+import { resolve } from 'node:path';
+import { externalizeDeps } from 'vite-plugin-externalize-deps'
+import { name as packageName } from './package.json';
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      '.': packageName,
+      './': packageName,
+      './index': packageName,
+    },
+  },
+  plugins: [externalizeDeps({ nodeBuiltins: true, include: [packageName] })],
+  build: {
+    lib: {
+      fileName: 'cli',
+      entry: resolve(__dirname, 'src/cli.ts'),
+      formats: ['es']
+    },
+    emptyOutDir: false,
+  }
+});

package/vite.config.ts

@@ -0,0 +1,20 @@
+import { resolve } from 'node:path';
+import { defineConfig } from 'vitest/config';
+import dts from 'vite-plugin-dts';
+import { externalizeDeps } from 'vite-plugin-externalize-deps';
+
+const testPattern = "src/**/*.{test,spec}.{js,ts}"
+
+export default defineConfig({
+  plugins: [dts({ exclude: testPattern, rollupTypes: true }), externalizeDeps({ nodeBuiltins: true })],
+  build: {
+    lib: {
+      name: 'index',
+      fileName: 'index',
+      entry: resolve(__dirname, 'src/index.ts'),
+    },
+  },
+  test: {
+    include: [testPattern],
+  },
+})