@hpcc-js/markdown-it-plugins 1.5.4 → 1.5.6

package/src/ecl-lang/index.ts

@@ -1,12 +1,12 @@
-import type { LanguageInput } from "shiki";
-
-import ecl_lang from "./ecl.tmLanguage.json" with { type: "json" };
-
-export function eclLang(): LanguageInput {
-    const retVal = {
-        ...ecl_lang,
-        name: "ecl"
-    } as unknown as LanguageInput;
-    return retVal;
-}
-
+import type { LanguageInput } from "shiki";
+
+import ecl_lang from "./ecl.tmLanguage.json" with { type: "json" };
+
+export function eclLang(): LanguageInput {
+    const retVal = {
+        ...ecl_lang,
+        name: "ecl"
+    } as unknown as LanguageInput;
+    return retVal;
+}
+

package/src/fence.ts

@@ -1,59 +1,59 @@
-import type MarkdownIt from "markdown-it";
-import type { Options } from "markdown-it";
-import type Token from "markdown-it/lib/token.mjs";
-import type Renderer from "markdown-it/lib/renderer.mjs";
-import { RenderNode } from "./render.ts";
-import { ENV_KEY, executeSrc, FenceInfo, fenceInfoDefaults, generatePlaceholders, showSrc } from "./util.ts";
-
-const deserializeFenceInfo = (attrs: string): FenceInfo =>
-    attrs
-        .split(/\s+/)
-        .reduce((acc: FenceInfo, pair, idx: number) => {
-            if (idx === 0) {
-                acc.type = pair as "js" | "javascript" | string;
-                return acc;
-            }
-
-            const [key, value] = pair.split("=") as [keyof FenceInfo, string];
-            switch (key) {
-                case "exec":
-                case "echo":
-                case "hide":
-                    acc[key] = value !== "false";
-                    break;
-            }
-            return acc;
-        }, { ...fenceInfoDefaults })
-    ;
-
-const proxy = (tokens: Token[], idx: number, options: Options, _env: any, self: Renderer) => self.renderToken(tokens, idx, options);
-
-export function hookFence(md: MarkdownIt) {
-    const defaultFenceRenderer = md.renderer.rules.fence || proxy;
-    const fenceRenderer = (tokens: Token[], idx: number, options: Options, env: { [ENV_KEY]?: RenderNode[] }, self: Renderer) => {
-        const token = tokens[idx];
-        const fenceInfo = deserializeFenceInfo(token.info);
-        if (fenceInfo.type === "javascript") {
-            fenceInfo.type = "js";
-        }
-        token.content += "\n";
-        let preHtml = "";
-        switch (fenceInfo.type) {
-            case "js":
-                if (executeSrc(fenceInfo)) {
-                    if (!env[ENV_KEY]) {
-                        env[ENV_KEY] = [];
-                    }
-                    preHtml += generatePlaceholders(token.content, fenceInfo, env);
-                }
-                if (showSrc(fenceInfo)) {
-                    return preHtml + defaultFenceRenderer(tokens, idx, options, env, self);
-                }
-                break;
-            default:
-                return preHtml + defaultFenceRenderer(tokens, idx, options, env, self);
-        }
-        return preHtml;
-    };
-    md.renderer.rules.fence = fenceRenderer;
-}
+import type MarkdownIt from "markdown-it";
+import type { Options } from "markdown-it";
+import type Token from "markdown-it/lib/token.mjs";
+import type Renderer from "markdown-it/lib/renderer.mjs";
+import { RenderNode } from "./render.ts";
+import { ENV_KEY, executeSrc, FenceInfo, fenceInfoDefaults, generatePlaceholders, showSrc } from "./util.ts";
+
+const deserializeFenceInfo = (attrs: string): FenceInfo =>
+    attrs
+        .split(/\s+/)
+        .reduce((acc: FenceInfo, pair, idx: number) => {
+            if (idx === 0) {
+                acc.type = pair as "js" | "javascript" | string;
+                return acc;
+            }
+
+            const [key, value] = pair.split("=") as [keyof FenceInfo, string];
+            switch (key) {
+                case "exec":
+                case "echo":
+                case "hide":
+                    acc[key] = value !== "false";
+                    break;
+            }
+            return acc;
+        }, { ...fenceInfoDefaults })
+    ;
+
+const proxy = (tokens: Token[], idx: number, options: Options, _env: any, self: Renderer) => self.renderToken(tokens, idx, options);
+
+export function hookFence(md: MarkdownIt) {
+    const defaultFenceRenderer = md.renderer.rules.fence || proxy;
+    const fenceRenderer = (tokens: Token[], idx: number, options: Options, env: { [ENV_KEY]?: RenderNode[] }, self: Renderer) => {
+        const token = tokens[idx];
+        const fenceInfo = deserializeFenceInfo(token.info);
+        if (fenceInfo.type === "javascript") {
+            fenceInfo.type = "js";
+        }
+        token.content += "\n";
+        let preHtml = "";
+        switch (fenceInfo.type) {
+            case "js":
+                if (executeSrc(fenceInfo)) {
+                    if (!env[ENV_KEY]) {
+                        env[ENV_KEY] = [];
+                    }
+                    preHtml += generatePlaceholders(token.content, fenceInfo, env);
+                }
+                if (showSrc(fenceInfo)) {
+                    return preHtml + defaultFenceRenderer(tokens, idx, options, env, self);
+                }
+                break;
+            default:
+                return preHtml + defaultFenceRenderer(tokens, idx, options, env, self);
+        }
+        return preHtml;
+    };
+    md.renderer.rules.fence = fenceRenderer;
+}

package/src/index.ts

@@ -1,47 +1,47 @@
-import type MarkdownIt from "markdown-it";
-import { render } from "./render.ts";
-import { ENV_KEY } from "./util.ts";
-import { hookTemplateLiterals } from "./template-literal.ts";
-import { hookFence } from "./fence.ts";
-
-function hookRender(md: MarkdownIt) {
-    const originalRender = md.render;
-    md.render = (src: string, _env?: any): string => {
-        const env = { ..._env };
-        const retVal = originalRender.call(md, src, env);
-        render(env[ENV_KEY] ?? []);
-        return retVal;
-    };
-}
-
-function hookVitepressRender(md: MarkdownIt) {
-
-    const originalRender = md.render;
-    md.render = (src: string, env?: any): string => {
-        const myEnv = env ?? {};
-        let retVal = originalRender.call(md, src, myEnv);
-        if (env[ENV_KEY]?.length) {
-            const content = encodeURI(JSON.stringify(env[ENV_KEY]));
-            retVal += `<RenderComponent content="${content}" />`;
-        }
-        return retVal;
-    };
-}
-
-export interface ObservableOptions {
-    vitePress?: boolean;
-}
-
-export function observable(md: MarkdownIt, opts: ObservableOptions = {}) {
-    hookTemplateLiterals(md);
-    hookFence(md);
-    if (opts.vitePress) {
-        hookVitepressRender(md);
-    } else {
-        hookRender(md);
-    }
-}
-
-export {
-    render
-};
+import type MarkdownIt from "markdown-it";
+import { render } from "./render.ts";
+import { ENV_KEY } from "./util.ts";
+import { hookTemplateLiterals } from "./template-literal.ts";
+import { hookFence } from "./fence.ts";
+
+function hookRender(md: MarkdownIt) {
+    const originalRender = md.render;
+    md.render = (src: string, _env?: any): string => {
+        const env = { ..._env };
+        const retVal = originalRender.call(md, src, env);
+        render(env[ENV_KEY] ?? []);
+        return retVal;
+    };
+}
+
+function hookVitepressRender(md: MarkdownIt) {
+
+    const originalRender = md.render;
+    md.render = (src: string, env?: any): string => {
+        const myEnv = env ?? {};
+        let retVal = originalRender.call(md, src, myEnv);
+        if (env[ENV_KEY]?.length) {
+            const content = encodeURI(JSON.stringify(env[ENV_KEY]));
+            retVal += `<RenderComponent content="${content}" />`;
+        }
+        return retVal;
+    };
+}
+
+export interface ObservableOptions {
+    vitePress?: boolean;
+}
+
+export function observable(md: MarkdownIt, opts: ObservableOptions = {}) {
+    hookTemplateLiterals(md);
+    hookFence(md);
+    if (opts.vitePress) {
+        hookVitepressRender(md);
+    } else {
+        hookRender(md);
+    }
+}
+
+export {
+    render
+};

package/src/loader.ts

@@ -1,154 +1,154 @@
-import { existsSync } from "node:fs";
-import { readdir, readFile } from "node:fs/promises";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import { dsvFormat, autoType } from "d3-dsv";
-import { LoaderResolver, } from "@observablehq/framework/dist/loader.js";
-import { getResolvers } from "@observablehq/framework/dist/resolvers.js";
-import { normalizeConfig } from "@observablehq/framework/dist/config.js";
-import { parseMarkdown } from "@observablehq/framework/dist/markdown.js";
-
-function getOptions({ path, ...config }) {
-    return { ...normalizeConfig(config), path };
-}
-
-export class DataFile {
-
-    private filePath: string;
-    private options: any;
-    private resolvers: any;
-    readonly ext: string;
-
-    protected constructor(filePath, options, resolvers) {
-        this.filePath = filePath;
-        this.options = options;
-        this.resolvers = resolvers;
-        this.ext = path.extname(filePath).substring(1);
-    }
-
-    static async attach(partialPath: string, root: string = path.resolve(".")) {
-        const exists = existsSync(path.resolve(root, partialPath));
-        const loaders = new LoaderResolver({ root, interpreters: {} });
-        const loader = loaders.find(partialPath);
-        if (loader) {
-            await loader.load();
-            const ext = path.extname(partialPath);
-            const options = getOptions({ root, path: "dummy.md" });
-            const page = parseMarkdown(`\${FileAttachment('${partialPath}')${ext}()}`, options);
-            const resolvers = await getResolvers(page, options);
-            resolvers.resolveFile(partialPath);
-            return new DataFile(exists ? path.resolve(root, partialPath) : path.resolve(path.join(root, ".observablehq", "cache", partialPath)), options, resolvers);
-        }
-    }
-
-    async myResolve(module: string) {
-        const partialPath = await this.resolvers.resolveImport(module);
-        return path.resolve(path.join(this.options.root, ".observablehq", "cache", partialPath));
-    }
-
-    async myImport(module: string) {
-        if (module === "npm:apache-arrow") {
-            return import("apache-arrow");
-        }
-        const fullPath = await this.myResolve(module);
-        const href = pathToFileURL(fullPath).href;
-        return import(href).catch((error) => {
-            console.error(error);
-        });
-    }
-
-    buffer(): Promise<Buffer> {
-        return readFile(this.filePath);
-    }
-
-    arrayBuffer() {
-        return this.buffer().then(buffer => buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength));
-    }
-
-    text(encoding: BufferEncoding = "utf8") {
-        return readFile(this.filePath, encoding);
-    }
-
-    json() {
-        return this.text().then(txt => {
-            return JSON.parse(txt);
-        });
-    }
-
-    dsv({ delimiter = ",", array = false, typed = false } = {}) {
-        return this.text().then(text => {
-            const format = dsvFormat(delimiter);
-            const parse: any = array ? format.parseRows : format.parse;
-            return parse(text, typed && autoType);
-        });
-    }
-
-    csv(options?) {
-        return this.dsv({ ...options, delimiter: "," });
-    }
-
-    tsv(options?) {
-        return this.dsv({ ...options, delimiter: "\t" });
-    }
-
-    arrow() {
-        return Promise.all([this.myImport("npm:apache-arrow"), this.arrayBuffer()]).then(([Arrow, response]) => {
-            return Arrow.tableFromIPC(response);
-        });
-    }
-
-    parquet() {
-        return this.myResolve("npm:parquet-wasm/esm/parquet_wasm_bg.wasm").then(wasmBytes => {
-            const wasmFile = new DataFile(wasmBytes, this.options, this.resolvers);
-            return Promise.all([
-                this.myImport("npm:apache-arrow"),
-                this.myImport("npm:parquet-wasm"),
-                wasmFile.arrayBuffer(),
-                this.arrayBuffer()
-            ]).then(([Arrow, Parquet, wasm, buffer]) => {
-                Parquet.initSync(wasm);
-                return Arrow.tableFromIPC(Parquet.readParquet(new Uint8Array(buffer)).intoIPCStream());
-            });
-        });
-    }
-
-    fetch() {
-        if (this[this.ext]) {
-            return this[this.ext]();
-        }
-    }
-}
-
-const regex = /^(.+\.(csv|tsv|txt|json|arrow|parquet))(?:\..*)?$/;
-interface FileInfo {
-    path: string;
-    data: any;
-}
-export async function findDataFiles(directory: string, recursive: boolean = false): Promise<FileInfo[]> {
-    const files = await readdir(directory, { withFileTypes: true });
-    let dataFiles: FileInfo[] = [];
-
-    for (const file of files) {
-        const fullPath = path.join(directory, file.name);
-        if (file.isDirectory() && recursive) {
-            const nestedFiles = await findDataFiles(fullPath, recursive);
-            dataFiles = dataFiles.concat(nestedFiles);
-        } else if (file.isFile()) {
-            const match = file.name.match(regex);
-            if (match) {
-                const _path = path.join(directory, match[1]);
-                dataFiles.push({
-                    path: _path,
-                    data: await DataFile.attach(_path)
-                });
-            }
-        }
-    }
-    return dataFiles;
-}
-
-export async function fetchData(partialPath: string) {
-    const dataFile = await DataFile.attach(partialPath);
-    return dataFile?.fetch();
-}
-
+import { existsSync } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { dsvFormat, autoType } from "d3-dsv";
+import { LoaderResolver, } from "@observablehq/framework/dist/loader.js";
+import { getResolvers } from "@observablehq/framework/dist/resolvers.js";
+import { normalizeConfig } from "@observablehq/framework/dist/config.js";
+import { parseMarkdown } from "@observablehq/framework/dist/markdown.js";
+
+function getOptions({ path, ...config }) {
+    return { ...normalizeConfig(config), path };
+}
+
+export class DataFile {
+
+    private filePath: string;
+    private options: any;
+    private resolvers: any;
+    readonly ext: string;
+
+    protected constructor(filePath, options, resolvers) {
+        this.filePath = filePath;
+        this.options = options;
+        this.resolvers = resolvers;
+        this.ext = path.extname(filePath).substring(1);
+    }
+
+    static async attach(partialPath: string, root: string = path.resolve(".")) {
+        const exists = existsSync(path.resolve(root, partialPath));
+        const loaders = new LoaderResolver({ root, interpreters: {} });
+        const loader = loaders.find(partialPath);
+        if (loader) {
+            await loader.load();
+            const ext = path.extname(partialPath);
+            const options = getOptions({ root, path: "dummy.md" });
+            const page = parseMarkdown(`\${FileAttachment('${partialPath}')${ext}()}`, options);
+            const resolvers = await getResolvers(page, options);
+            resolvers.resolveFile(partialPath);
+            return new DataFile(exists ? path.resolve(root, partialPath) : path.resolve(path.join(root, ".observablehq", "cache", partialPath)), options, resolvers);
+        }
+    }
+
+    async myResolve(module: string) {
+        const partialPath = await this.resolvers.resolveImport(module);
+        return path.resolve(path.join(this.options.root, ".observablehq", "cache", partialPath));
+    }
+
+    async myImport(module: string) {
+        if (module === "npm:apache-arrow") {
+            return import("apache-arrow");
+        }
+        const fullPath = await this.myResolve(module);
+        const href = pathToFileURL(fullPath).href;
+        return import(href).catch((error) => {
+            console.error(error);
+        });
+    }
+
+    buffer(): Promise<Buffer> {
+        return readFile(this.filePath);
+    }
+
+    arrayBuffer() {
+        return this.buffer().then(buffer => buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength));
+    }
+
+    text(encoding: BufferEncoding = "utf8") {
+        return readFile(this.filePath, encoding);
+    }
+
+    json() {
+        return this.text().then(txt => {
+            return JSON.parse(txt);
+        });
+    }
+
+    dsv({ delimiter = ",", array = false, typed = false } = {}) {
+        return this.text().then(text => {
+            const format = dsvFormat(delimiter);
+            const parse: any = array ? format.parseRows : format.parse;
+            return parse(text, typed && autoType);
+        });
+    }
+
+    csv(options?) {
+        return this.dsv({ ...options, delimiter: "," });
+    }
+
+    tsv(options?) {
+        return this.dsv({ ...options, delimiter: "\t" });
+    }
+
+    arrow() {
+        return Promise.all([this.myImport("npm:apache-arrow"), this.arrayBuffer()]).then(([Arrow, response]) => {
+            return Arrow.tableFromIPC(response);
+        });
+    }
+
+    parquet() {
+        return this.myResolve("npm:parquet-wasm/esm/parquet_wasm_bg.wasm").then(wasmBytes => {
+            const wasmFile = new DataFile(wasmBytes, this.options, this.resolvers);
+            return Promise.all([
+                this.myImport("npm:apache-arrow"),
+                this.myImport("npm:parquet-wasm"),
+                wasmFile.arrayBuffer(),
+                this.arrayBuffer()
+            ]).then(([Arrow, Parquet, wasm, buffer]) => {
+                Parquet.initSync(wasm);
+                return Arrow.tableFromIPC(Parquet.readParquet(new Uint8Array(buffer)).intoIPCStream());
+            });
+        });
+    }
+
+    fetch() {
+        if (this[this.ext]) {
+            return this[this.ext]();
+        }
+    }
+}
+
+const regex = /^(.+\.(csv|tsv|txt|json|arrow|parquet))(?:\..*)?$/;
+interface FileInfo {
+    path: string;
+    data: any;
+}
+export async function findDataFiles(directory: string, recursive: boolean = false): Promise<FileInfo[]> {
+    const files = await readdir(directory, { withFileTypes: true });
+    let dataFiles: FileInfo[] = [];
+
+    for (const file of files) {
+        const fullPath = path.join(directory, file.name);
+        if (file.isDirectory() && recursive) {
+            const nestedFiles = await findDataFiles(fullPath, recursive);
+            dataFiles = dataFiles.concat(nestedFiles);
+        } else if (file.isFile()) {
+            const match = file.name.match(regex);
+            if (match) {
+                const _path = path.join(directory, match[1]);
+                dataFiles.push({
+                    path: _path,
+                    data: await DataFile.attach(_path)
+                });
+            }
+        }
+    }
+    return dataFiles;
+}
+
+export async function fetchData(partialPath: string) {
+    const dataFile = await DataFile.attach(partialPath);
+    return dataFile?.fetch();
+}
+