@netfoundry/docusaurus-shared 0.0.168

package/src/css/vars-dark.css

@@ -0,0 +1,7 @@
+html[data-theme="dark"] {
+    /*--nf-docs-max-width: 100px;*/
+    /*--nf-docs-main-color: pink;*/
+    .container {
+        /*background: orange;*/
+    }
+}

package/src/css/vars.css

@@ -0,0 +1,8 @@
+:root {
+    --ifm-navbar-height: 50px;
+    --nf-docs-max-width: 1400px;
+    /*--nf-docs-main-color: purple;*/
+    .container {
+        /*background: sandybrown;*/
+    }
+}

package/src/docusaurus-envhelper.ts

@@ -0,0 +1,105 @@
+import type { LoadContext, Plugin } from '@docusaurus/types';
+
+// Safe in browser & Node: check globalThis.process only by property access on a known object.
+// 1) Use Node's env if present; 2) else use browser-injected __DOCUSAURUS_ENV__; 3) else {}
+type Env = Record<string, string | undefined>;
+const g: any = typeof globalThis !== "undefined" ? globalThis : {};
+
+const RUNTIME_ENV: Env = (() => {
+    if (g.process && typeof g.process.env === "object") return g.process.env as Env;
+    if (g.__DOCUSAURUS_ENV__) return g.__DOCUSAURUS_ENV__ as Env;
+    return {};
+})();
+
+const getEnv = (k: string, d?: string) =>
+    (RUNTIME_ENV[k] ?? d) as string | undefined;
+
+const ORIGIN =
+    getEnv("DOCUSAURUS_URL") ||
+    (typeof window !== "undefined" ? window.location.origin : "http://localhost");
+
+export const DOCUSAURUS_DEBUG = getEnv("DOCUSAURUS_DEBUG") === "true";
+export const DOCUSAURUS_URL = ORIGIN;
+export const DOCUSAURUS_BASE_PATH = getEnv("DOCUSAURUS_BASE_PATH", "/base-url");
+export const DOCUSAURUS_DOCS_PATH = getEnv("DOCUSAURUS_DOCS_PATH", "/docs-path");
+export const DOCUSAURUS_CANONICAL_DOMAIN = getEnv("DOCUSAURUS_CANONICAL_DOMAIN", "canonical.domain.missing.local");
+export const hotjarId = getEnv("ZITI_HOTJAR_APPID", "6443327")!;
+
+export function cleanUrl(path: string) {
+    return path.replace(/([^:]\/)\/+/g, "$1");
+}
+
+export function docUrl(base: string, path: string): string {
+    return cleanUrl(`${base}/${path}`);
+}
+
+export function absoluteUrl(base: string, path: string): string {
+    return cleanUrl(`${base}/${DOCUSAURUS_DOCS_PATH}/${path}`);
+}
+
+export function addDocsRedir(base: string, redirectsArr: { to: string; from: string[] }[]) {
+    if (getEnv("DEPLOY_ENV") === "kinsta") {
+        redirectsArr.push({
+            to: docUrl(base, "/learn/introduction/"),
+            from: [docUrl(base, "/docs")],
+        });
+    }
+}
+
+
+
+
+
+interface HotjarThemeConfig {
+    applicationId: string;
+}
+
+export function pluginHotjar(context: LoadContext): Plugin {
+    const { siteConfig } = context;
+    const { themeConfig } = siteConfig;
+    const { hotjar } = themeConfig as { hotjar?: HotjarThemeConfig };
+
+    if (!hotjar) {
+        throw new Error(
+            `You need to specify 'hotjar' object in 'themeConfig' with 'applicationId' field in it to use docusaurus-plugin-hotjar`,
+        );
+    }
+
+    const { applicationId } = hotjar;
+
+    if (!applicationId) {
+        throw new Error(
+            'You specified the `hotjar` object in `themeConfig` but the `applicationId` field was missing. ' +
+            'Please ensure this is not a mistake.',
+        );
+    }
+
+    const isProd = process.env.NODE_ENV === 'production';
+
+    return {
+        name: 'docusaurus-plugin-hotjar',
+
+        injectHtmlTags() {
+            console.log(`[hotjar] applicationId = ${applicationId} isProd = ${isProd}`);
+            if (!isProd) {
+                return {};
+            }
+
+            return {
+                headTags: [
+                    {
+                        tagName: 'script',
+                        innerHTML: `(function(h,o,t,j,a,r){
+  h.hj=h.hj||function(){(h.hj.q=h.hj.q||[]).push(arguments)};
+  h._hjSettings={hjid:${applicationId},hjsv:6};
+  a=o.getElementsByTagName('head')[0];
+  r=o.createElement('script');r.async=1;
+  r.src=t+h._hjSettings.hjid+j+h._hjSettings.hjsv;
+  a.appendChild(r);
+})(window,document,'https://static.hotjar.com/c/hotjar-','.js?sv=');`,
+                    },
+                ],
+            };
+        },
+    };
+}

package/src/docusaurus-plugins/index.ts

@@ -0,0 +1,7 @@
+export * from './logger'
+export * from './remarkYouTube';
+export * from './remarkScopedPath';
+export * from './remarkReplaceMetaUrl'
+export * from './remarkCodeSections'
+export * from './remarkYamlTable'
+export * from './timedPlugin'

package/src/docusaurus-plugins/logger.ts

@@ -0,0 +1,38 @@
+import { writeFileSync, appendFileSync, existsSync } from 'fs'
+import { join } from 'path'
+
+export enum LogLevel {
+    Silent = 0,
+    Info = 1,
+    Debug = 2,
+}
+
+const LOG = join(process.cwd(), 'remark-plugins.log')
+
+export class Logger {
+    constructor(private level: LogLevel, private name: string) {}
+    log(msg: unknown, level: LogLevel = LogLevel.Info) {
+        if (this.level === LogLevel.Silent) return
+        if (level > this.level) return
+
+        const text = String(msg)
+        if (!text.trim()) return
+
+        const line = `[${this.name}] ${LogLevel[level]} ${text}`
+        if (!existsSync(LOG)) writeFileSync(LOG, '')
+        appendFileSync(LOG, `[${new Date().toISOString()}] ${line}\n`)
+    }
+}
+
+export function resolveLogLevel(val: unknown): LogLevel {
+    if (typeof val === "number" && LogLevel[val] !== undefined) {
+        return val as LogLevel
+    }
+    if (typeof val === "string") {
+        const key = val[0].toUpperCase() + val.slice(1).toLowerCase()
+        if (key in LogLevel) {
+            return LogLevel[key as keyof typeof LogLevel]
+        }
+    }
+    return LogLevel.Silent
+}

package/src/docusaurus-plugins/remarkCodeSections.ts

@@ -0,0 +1,115 @@
+import {visit} from "unist-util-visit"
+import type {Plugin} from "unified"
+import type {Node} from "unist"
+import {Logger, LogLevel, resolveLogLevel} from "./logger"
+
+interface Options {
+    logLevel?: LogLevel
+}
+
+export const remarkCodeSections: Plugin<[Options?]> = (options?: Options) => {
+    const logger = new Logger(resolveLogLevel(options?.logLevel), "remarkCodeSections")
+
+    const desc_text = "@desc:"
+    const command_text = "@command:"
+    const code_text = "@code:"
+    const results_text = "@results:"
+
+    return (tree: Node) => {
+        visit(tree, "code", (node: any, index: number, parent: any) => {
+            if (!node?.value) return
+
+            const hasActivator = /@desc:|@command:|@code:|@results:/.test(node.value)
+            if (!hasActivator) return
+
+            logger.log(node, LogLevel.Debug)
+            if (node.lang && node.lang.startsWith("example")) {
+                const lang = node.lang.replace("example-", "").trim()
+                const lines = node.value.split("\n")
+                let description = "", command = "", code = "", results = "", codeTitle = ""
+                let currentSection = ""
+
+                lines.forEach((line: string) => {
+                    if (line.startsWith(desc_text)) {
+                        currentSection = "description"
+                        description = line.replace(desc_text, "").trim()
+                    } else if (line.startsWith(command_text)) {
+                        currentSection = "command"
+                        command = line.replace(command_text, "").trim()
+                    } else if (line.startsWith(code_text)) {
+                        currentSection = "code"
+                        codeTitle = line.replace(code_text, "").trim()
+                    } else if (line.startsWith(results_text)) {
+                        currentSection = "results"
+                        results = line.replace(results_text, "").trim()
+                    } else {
+                        if (currentSection === "description") description += `\n${line}`
+                        else if (currentSection === "command") command += `\n${line}`
+                        else if (currentSection === "code") code += `\n${line}`
+                        else if (currentSection === "results") results += `\n${line}`
+                    }
+                })
+
+                const divWrapper = {
+                    type: "div",
+                    data: { hName: "div", hProperties: { className: "code-section" } },
+                    children: [] as any[],
+                }
+
+                if (description) {
+                    const descDiv = {
+                        type: "div",
+                        data: { hName: "div", hProperties: { className: "code-section-desc" } },
+                        children: [] as any[],
+                    }
+                    descDiv.children.push(
+                        { type: "paragraph", children: [{ type: "strong", children: [{ type: "text", value: "Description:" }] }] },
+                        { type: "paragraph", children: [{ type: "text", value: description.trim() }], data: { hProperties: { style: "padding-bottom: 10px;" } } },
+                    )
+                    divWrapper.children.push(descDiv)
+                }
+
+                if (command) {
+                    const cmdDiv = {
+                        type: "div",
+                        data: { hName: "div", hProperties: { className: "code-section-command" } },
+                        children: [] as any[],
+                    }
+                    cmdDiv.children.push(
+                        { type: "paragraph", children: [{ type: "strong", children: [{ type: "text", value: "Command:" }] }] },
+                        { type: "code", lang: "sh", value: command.trim() },
+                    )
+                    divWrapper.children.push(cmdDiv)
+                }
+
+                if (code) {
+                    const codeDiv = {
+                        type: "div",
+                        data: { hName: "div", hProperties: { className: "code-section-code" } },
+                        children: [] as any[],
+                    }
+                    codeDiv.children.push(
+                        { type: "paragraph", children: [{ type: "strong", children: [{ type: "text", value: codeTitle }] }] },
+                        { type: "code", lang, value: code.trim() },
+                    )
+                    divWrapper.children.push(codeDiv)
+                }
+
+                if (results) {
+                    const resultsDiv = {
+                        type: "div",
+                        data: { hName: "div", hProperties: { className: "code-section-results" } },
+                        children: [] as any[],
+                    }
+                    resultsDiv.children.push(
+                        { type: "paragraph", children: [{ type: "strong", children: [{ type: "text", value: "Results:" }] }] },
+                        { type: "code", lang: "buttonless", value: results.trim() },
+                    )
+                    divWrapper.children.push(resultsDiv)
+                }
+
+                parent.children.splice(index, 1, divWrapper)
+            }
+        })
+    }
+}

package/src/docusaurus-plugins/remarkReplaceMetaUrl.ts

@@ -0,0 +1,35 @@
+import { Plugin } from 'unified'
+import { visit } from 'unist-util-visit'
+import { Root } from 'mdast'
+import {Logger, LogLevel, resolveLogLevel} from './logger'
+
+console.log("🦖 remarkReplaceMetaUrl plugin loaded")
+
+interface Options {
+    from: string
+    to: string
+    logLevel?: LogLevel
+}
+
+export const remarkReplaceMetaUrl: Plugin<[Options], Root> = (options?: Options) => {
+    const { from = '', to = '', logLevel = LogLevel.Silent } = options ?? {}
+    const logger = new Logger(resolveLogLevel(options?.logLevel), 'remarkReplaceMetaUrl')
+
+    logger.log(`initialized: replacing "${from}" → "${to}"`)
+
+    return (tree: Root) => {
+        visit(tree, 'mdxJsxFlowElement', (node: any) => {
+            if (node.name === 'meta' && Array.isArray(node.attributes)) {
+                for (const attr of node.attributes) {
+                    if (attr.name === 'content' && typeof attr.value === 'string' && attr.value.includes(from)) {
+                        const newVal = attr.value.replace(from, to)
+                        logger.log(`rewriting: "${attr.value}" → "${newVal}"`, LogLevel.Info)
+                        attr.value = newVal
+                    }
+                }
+            }
+        })
+    }
+}
+
+export default remarkReplaceMetaUrl

package/src/docusaurus-plugins/remarkScopedPath.ts

@@ -0,0 +1,70 @@
+import { Plugin } from 'unified'
+import { visit } from 'unist-util-visit'
+import { Image, Link } from 'mdast'
+import { MdxJsxFlowElement, MdxjsEsm } from 'mdast-util-mdx'
+import {Logger, LogLevel, resolveLogLevel} from './logger'
+
+console.log("🦖 remarkScopedPath plugin module loaded")
+
+interface ScopedPathOptions {
+    from: string
+    to: string
+}
+interface Options {
+    mappings: ScopedPathOptions[]
+    logLevel?: LogLevel
+}
+
+export const remarkScopedPath: Plugin<[Options]> = (options?: Options) => {
+    const { mappings = [], logLevel = LogLevel.Silent } = options ?? {}
+    const logger = new Logger(resolveLogLevel(options?.logLevel), 'remarkScopedPath')
+
+    logger.log(`initialized with ${mappings.length} mappings`)
+
+    return (tree, file) => {
+        const filePath = file?.path || file?.history?.slice(-1)[0] || 'unknown'
+        logger.log(`processing file: ${filePath}`, LogLevel.Debug)
+
+        const rewrite = (val: string, from: string, to: string, ctx: string) => {
+            if (val.startsWith(from)) {
+                const newVal = val.replace(from, to)
+                logger.log(`🔄 ${ctx} ${val} → ${newVal}`, LogLevel.Info)
+                return newVal
+            }
+            return val
+        }
+
+        visit(tree, 'image', (node: Image) => {
+            for (const { from, to } of mappings) node.url = rewrite(node.url, from, to, 'img')
+        })
+
+        visit(tree, 'link', (node: Link) => {
+            for (const { from, to } of mappings) node.url = rewrite(node.url, from, to, 'link')
+        })
+
+        visit(tree, 'mdxJsxFlowElement', (node: MdxJsxFlowElement) => {
+            node.attributes?.forEach(attr => {
+                if (attr.type === 'mdxJsxAttribute' && typeof attr.value === 'string') {
+                    for (const { from, to } of mappings)
+                        attr.value = rewrite(attr.value, from, to, `jsx <${node.name}> ${attr.name}:`)
+                }
+            })
+        })
+
+        visit(tree, 'mdxjsEsm', (node: MdxjsEsm) => {
+            for (const { from, to } of mappings) {
+                const re = new RegExp(`(['"])${from}/`, 'g')
+                const newVal = node.value.replace(re, `$1${to}/`)
+                if (newVal !== node.value) {
+                    logger.log(
+                        `esm rewrite (${from} → ${to}):\n--- before ---\n${node.value}\n--- after ---\n${newVal}`,
+                        LogLevel.Info
+                    )
+                    node.value = newVal
+                }
+            }
+        })
+
+        logger.log(` `, LogLevel.Debug)
+    }
+}

package/src/docusaurus-plugins/remarkYamlTable.ts

@@ -0,0 +1,83 @@
+import { Plugin } from 'unified'
+import { visit } from 'unist-util-visit'
+import yaml from 'js-yaml'
+import { Parent } from 'unist'
+import { Literal } from 'unist'
+import {Logger, LogLevel, resolveLogLevel} from './logger'
+
+console.log("🦖 remarkYamlTable plugin module loaded")
+
+interface Code extends Literal {
+    type: 'code'
+    lang?: string
+    value: string
+}
+
+interface TableCell {
+    type: 'tableCell'
+    children: { type: 'text'; value: string }[]
+}
+
+interface TableRow {
+    type: 'tableRow'
+    children: TableCell[]
+}
+
+interface Table {
+    type: 'table'
+    align: (null | 'left' | 'right' | 'center')[]
+    children: TableRow[]
+}
+
+interface Options {
+    logLevel?: LogLevel
+}
+
+export const remarkYamlTable: Plugin<[Options]> = (options?: Options) => {
+    const { logLevel = LogLevel.Silent } = options ?? {}
+    const logger = new Logger(resolveLogLevel(options?.logLevel), 'remarkYamlTable')
+
+    logger.log('initialized')
+
+    return (tree) => {
+        visit(tree, 'code', (node: Code, index: number | undefined, parent: Parent | undefined) => {
+            if (!parent || index === undefined) return
+            if (node.lang === 'yaml-table') {
+                try {
+                    const data = yaml.load(node.value)
+                    if (Array.isArray(data) && data.length > 0 && typeof data[0] === 'object') {
+                        const headers = Object.keys(data[0] as Record<string, unknown>)
+
+                        const tableRows: TableRow[] = (data as Record<string, unknown>[]).map((row) => ({
+                            type: 'tableRow',
+                            children: headers.map<TableCell>((header) => ({
+                                type: 'tableCell',
+                                children: [{ type: 'text', value: String(row[header] ?? '') }],
+                            })),
+                        }))
+
+                        const tableNode: Table = {
+                            type: 'table',
+                            align: headers.map(() => null),
+                            children: [
+                                {
+                                    type: 'tableRow',
+                                    children: headers.map<TableCell>((header) => ({
+                                        type: 'tableCell',
+                                        children: [{ type: 'text', value: header }],
+                                    })),
+                                },
+                                ...tableRows,
+                            ],
+                        }
+
+                        parent.children[index] = tableNode
+                        logger.log(`generated table with ${headers.length} columns and ${data.length} rows`, LogLevel.Info)
+                    }
+                } catch (error) {
+                    logger.log(`YAML parsing error: ${(error as Error).message}`, LogLevel.Info)
+                }
+            }
+        })
+    }
+}

package/src/docusaurus-plugins/remarkYouTube.ts

@@ -0,0 +1,56 @@
+import type { Plugin } from 'unified'
+import { visit } from 'unist-util-visit'
+import type { Node } from 'unist'
+import {Logger, LogLevel, resolveLogLevel} from './logger'
+
+console.log("🦖 remarkYouTube plugin module loaded")
+
+interface YouTubeOptions {
+    logLevel?: LogLevel
+}
+
+export const remarkYouTube: Plugin<[YouTubeOptions]> = (options?: YouTubeOptions) => {
+    const { logLevel = LogLevel.Silent } = options ?? {}
+    const logger = new Logger(resolveLogLevel(options?.logLevel), 'remarkYouTube')
+
+    logger.log('initialized')
+
+    return (tree: Node) => {
+        visit(tree, ['link', 'text'], (node: any, index: number | undefined, parent: any) => {
+            if (!parent || typeof index !== 'number') return
+            let raw = node.url || node.value || ''
+            let ytUrl = raw.trim()
+
+            const hashnodeMatch = ytUrl.match(/^%\[(.+)\]$/)
+            if (hashnodeMatch) {
+                ytUrl = hashnodeMatch[1]
+                logger.log(`hashnode-style embed detected: ${ytUrl}`, LogLevel.Info)
+            }
+
+            const m =
+                ytUrl.match(/youtube\.com\/watch\?v=([A-Za-z0-9_-]+)/) ||
+                ytUrl.match(/youtu\.be\/([A-Za-z0-9_-]+)/) ||
+                ytUrl.match(/youtube-nocookie\.com\/watch\?v=([A-Za-z0-9_-]+)/)
+
+            if (m) {
+                logger.log(`rewriting YouTube URL: ${ytUrl} → videoId=${m[1]}`, LogLevel.Debug)
+                parent.children.splice(index, 1, {
+                    type: 'mdxJsxFlowElement',
+                    name: 'LiteYouTubeEmbed',
+                    attributes: [
+                        { type: 'mdxJsxAttribute', name: 'id', value: m[1] },
+                        { type: 'mdxJsxAttribute', name: 'title', value: 'YouTube video' },
+                    ],
+                })
+            }
+        })
+
+        visit(tree, 'text', (node: any, index: number | undefined, parent: any) => {
+            if (!parent || typeof index !== 'number') return
+            if (node.value.trim() === '%[' || node.value.trim() === ']') {
+                logger.log(`stripping hashnode bracket artifact: ${node.value}`, LogLevel.Debug)
+                parent.children.splice(index, 1)
+            }
+        })
+    }
+}

package/src/docusaurus-plugins/timedPlugin.ts

@@ -0,0 +1,22 @@
+import { Plugin } from "unified"
+import {Logger, LogLevel, resolveLogLevel} from './logger'
+
+export function timedPlugin<T extends Plugin>(
+    name: string,
+    plugin: T,
+    opts: { logLevel?: LogLevel } = {}
+): T {
+    const { logLevel = LogLevel.Info } = opts
+    const logger = new Logger(resolveLogLevel(opts?.logLevel), name)
+
+    return ((...args: any[]) => {
+        const instance = (plugin as any)(...args)
+        return (tree: any, file: any) => {
+            const start = Date.now()
+            const res = instance(tree, file)
+            const dur = Date.now() - start
+            logger.log(`⏱ finished in ${dur}ms`)
+            return res
+        }
+    }) as any
+}

package/src/global.d.ts

@@ -0,0 +1 @@
+declare module '*.module.css';

package/src/index.ts

@@ -0,0 +1,3 @@
+// src/index.ts
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+export const version: string = require('../package.json').version;

package/src/node.ts

@@ -0,0 +1 @@
+export * from './docusaurus-envhelper';

package/src/plugins.ts

@@ -0,0 +1 @@
+export * from './docusaurus-plugins'

package/src/ui.ts

@@ -0,0 +1,2 @@
+export * from './components';
+export * from './docusaurus-envhelper'

package/src/version.ts

@@ -0,0 +1 @@
+export const version = '0.0.168';