@diplodoc/mermaid-extension 0.0.1 → 0.0.2

package/hooks/index.d.ts

@@ -0,0 +1 @@
+export { useMermaid } from './useMermaid';

package/hooks/index.js

@@ -0,0 +1,46 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/hooks/useMermaid.ts
+import { useEffect, useState, useCallback } from "react";
+function useMermaid() {
+  const [mermaid, setMermaid] = useState(null);
+  const render = useCallback((config) => __async(this, null, function* () {
+    if (mermaid) {
+      mermaid.initialize(config);
+      return mermaid.run();
+    }
+  }), [mermaid]);
+  useEffect(() => {
+    (window.mermaidJsonp = window.mermaidJsonp || []).push(setMermaid);
+    return () => {
+      const index = window.mermaidJsonp.indexOf(setMermaid);
+      if (index > -1) {
+        window.mermaidJsonp.splice(index, 1);
+      }
+    };
+  }, []);
+  return render;
+}
+export {
+  useMermaid
+};
+//# sourceMappingURL=index.js.map

package/hooks/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/hooks/useMermaid.ts"],
+  "sourcesContent": ["import type { MermaidConfig } from 'mermaid';\nimport { useEffect, useState, useCallback } from 'react';\nimport { Callback } from '../@types/common';\n\nexport function useMermaid() {\n    const [ mermaid, setMermaid ] = useState<Parameters<Callback>[0] | null>(null);\n    const render = useCallback(async (config: MermaidConfig) => {\n        if (mermaid) {\n            mermaid.initialize(config);\n            return mermaid.run();\n        }\n    }, [ mermaid ]);\n\n    useEffect(() => {\n        (window.mermaidJsonp = window.mermaidJsonp || []).push(setMermaid);\n\n        return () => {\n            const index = window.mermaidJsonp.indexOf(setMermaid);\n            if (index > -1) {\n                window.mermaidJsonp.splice(index, 1);\n            }\n        };\n    }, []);\n\n    return render;\n}"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AACA,SAAS,WAAW,UAAU,mBAAmB;AAG1C,SAAS,aAAa;AACzB,QAAM,CAAE,SAAS,UAAW,IAAI,SAAyC,IAAI;AAC7E,QAAM,SAAS,YAAY,CAAO,WAA0B;AACxD,QAAI,SAAS;AACT,cAAQ,WAAW,MAAM;AACzB,aAAO,QAAQ,IAAI;AAAA,IACvB;AAAA,EACJ,IAAG,CAAE,OAAQ,CAAC;AAEd,YAAU,MAAM;AACZ,KAAC,OAAO,eAAe,OAAO,gBAAgB,CAAC,GAAG,KAAK,UAAU;AAEjE,WAAO,MAAM;AACT,YAAM,QAAQ,OAAO,aAAa,QAAQ,UAAU;AACpD,UAAI,QAAQ,IAAI;AACZ,eAAO,aAAa,OAAO,OAAO,CAAC;AAAA,MACvC;AAAA,IACJ;AAAA,EACJ,GAAG,CAAC,CAAC;AAEL,SAAO;AACX;",
+  "names": []
+}

package/hooks/useMermaid.d.ts

@@ -0,0 +1,2 @@
+import type { MermaidConfig } from 'mermaid';
+export declare function useMermaid(): (config: MermaidConfig) => Promise<void>;

package/package.json

@@ -1,15 +1,28 @@
 {
   "name": "@diplodoc/mermaid-extension",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Mermaid plugin for Diplodoc transformer and builder",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
+  "main": "plugin/index.js",
+  "types": "plugin/index.d.ts",
+  "exports": {
+    ".": "./plugin/index.js",
+    "./runtime": {
+      "require": {
+        "default": "./runtime/index.js"
+      },
+      "browser": {
+        "default": "./runtime/index.js"
+      }
+    },
+    "./hooks": "./hooks/index.js"
+  },
   "scripts": {
     "build": "run-p build:*",
-    "build:lib": "esbuild src/plugin/index.ts --bundle --platform=node --outfile=lib/index.js --sourcemap",
-    "build:hooks": "esbuild src/hooks/index.ts --bundle --platform=neutral --target=es6 --outfile=hooks/index.js --external:react --sourcemap",
-    "build:runtime": "esbuild src/runtime/index.ts --bundle --minify --sourcemap --outfile=dist/runtime.js",
-    "build:declarations": "tsc --emitDeclarationOnly --outFile lib/index.d.ts",
+    "build:plugin": "./esbuild/plugin.sh",
+    "build:hooks": "./esbuild/hooks.sh",
+    "build:runtime": "./esbuild/runtime.sh",
+    "build:declarations": "tsc --emitDeclarationOnly --outDir .",
+    "prepublish": "npm run build",
     "test": "jest"
   },
   "keywords": [
@@ -18,6 +31,11 @@
   ],
   "author": "",
   "license": "ISC",
+  "files": [
+    "plugin",
+    "runtime",
+    "hooks"
+  ],
   "optionalDependencies": {
     "react": "^18.2.0"
   },

package/plugin/index.d.ts

@@ -0,0 +1 @@
+export { transform } from './transform';

package/plugin/index.js

@@ -0,0 +1,128 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugin/index.ts
+var plugin_exports = {};
+__export(plugin_exports, {
+  transform: () => transform
+});
+module.exports = __toCommonJS(plugin_exports);
+
+// src/plugin/transform.ts
+var import_node_path = require("node:path");
+var import_node_fs = require("node:fs");
+var import_markdown_it = __toESM(require("markdown-it"));
+function isMermaidBlock(token) {
+  return token.type === "fence" && token.info.match(/^\s*mermaid(\s*|$)/);
+}
+function hidden(box, field, value) {
+  if (!(field in box)) {
+    Object.defineProperty(box, field, {
+      enumerable: false,
+      value
+    });
+  }
+  return box;
+}
+function copy(from, to) {
+  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(to), { recursive: true });
+  (0, import_node_fs.copyFileSync)(from, to);
+}
+var registerTransforms = (md, {
+  classes,
+  runtime,
+  bundle,
+  output,
+  updateTokens
+}) => {
+  const applyTransforms = ({ tokens, env }) => {
+    hidden(env, "bundled", /* @__PURE__ */ new Set());
+    const blocks = tokens.filter(isMermaidBlock);
+    if (updateTokens && blocks.length) {
+      blocks.forEach((token) => {
+        token.type = "mermaid";
+        token.attrSet("class", `mermaid ${classes}`);
+      });
+    }
+    if (blocks.length) {
+      env.meta = env.meta || {};
+      env.meta.script = env.meta.script || [];
+      env.meta.script.push(runtime);
+      if (bundle) {
+        const file = (0, import_node_path.join)("@diplodoc/mermaid-extension", "runtime");
+        if (!env.bundled.has(file)) {
+          env.bundled.add(file);
+          copy(require.resolve(file), (0, import_node_path.join)(output, runtime));
+        }
+      }
+    }
+  };
+  try {
+    md.core.ruler.after("fence", "mermaid", applyTransforms);
+  } catch (e) {
+    md.core.ruler.push("mermaid", applyTransforms);
+  }
+};
+function transform(options = {}) {
+  const { runtime = "_assets/mermaid-extension.js", classes = "yfm-mermaid", bundle = true } = options;
+  const plugin = function(md, { output }) {
+    registerTransforms(md, {
+      classes,
+      runtime,
+      bundle,
+      output,
+      updateTokens: true
+    });
+    md.renderer.rules.mermaid = (tokens, idx) => {
+      const token = tokens[idx];
+      const code = encodeURIComponent(token.content.trim());
+      return `<div class="mermaid" data-content="${code}"></div>`;
+    };
+  };
+  Object.assign(plugin, {
+    collect(input, { destRoot }) {
+      const md = new import_markdown_it.default().use((md2) => {
+        registerTransforms(md2, {
+          classes,
+          runtime,
+          bundle,
+          output: destRoot,
+          updateTokens: false
+        });
+      });
+      md.parse(input, {});
+    }
+  });
+  return plugin;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  transform
+});
+//# sourceMappingURL=index.js.map

package/plugin/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/plugin/index.ts", "../src/plugin/transform.ts"],
+  "sourcesContent": ["export { transform } from './transform';", "import { join, dirname } from 'node:path';\nimport { mkdirSync, copyFileSync } from 'node:fs';\nimport MarkdownIt from 'markdown-it';\nimport type { MarkdownItPluginCb, MarkdownItPluginOpts } from '@doc-tools/transform/lib/plugins/typings';\nimport type ParserCore from 'markdown-it/lib/parser_core';\nimport type Token from 'markdown-it/lib/token';\n\nexport type PluginOptions = {\n    runtime: string;\n    classes: string;\n    bundle: boolean;\n}\n\nfunction isMermaidBlock(token: Token) {\n    return token.type === 'fence' && token.info.match(/^\\s*mermaid(\\s*|$)/);\n}\n\nfunction hidden<B extends Record<string | symbol, unknown>, F extends string | symbol, V>(\n    box: B,\n    field: F,\n    value: V\n) {\n    if (!(field in box)) {\n        Object.defineProperty(box, field, {\n            enumerable: false,\n            value: value\n        });\n    }\n\n    return box as B & { [P in F]: V };\n}\n\nfunction copy(from: string, to: string) {\n    mkdirSync(dirname(to), { recursive: true });\n    copyFileSync(from, to);\n}\n\nconst registerTransforms = (md: MarkdownIt, {\n    classes, runtime, bundle, output, updateTokens\n}: PluginOptions & {\n    output: string,\n    updateTokens: boolean\n}) => {\n    const applyTransforms: ParserCore.RuleCore = ({ tokens, env }) => {\n        hidden(env, 'bundled', new Set<string>());\n\n        const blocks = tokens.filter(isMermaidBlock);\n\n        if (updateTokens && blocks.length) {\n            blocks.forEach((token) => {\n                token.type = 'mermaid';\n                token.attrSet('class', `mermaid ${ classes }`);\n            });\n        }\n\n        if (blocks.length) {\n            env.meta = env.meta || {};\n            env.meta.script = env.meta.script || [];\n            env.meta.script.push(runtime);\n\n            if (bundle) {\n                const file = join(PACKAGE, 'runtime');\n                if (!env.bundled.has(file)) {\n                    env.bundled.add(file);\n\n                    copy(require.resolve(file), join(output, runtime));\n                }\n            }\n        }\n    }\n\n    try {\n        md.core.ruler.after('fence', 'mermaid', applyTransforms);\n    } catch (e) {\n        md.core.ruler.push('mermaid', applyTransforms);\n    }\n}\n\ntype InputOptions = MarkdownItPluginOpts & {\n    destRoot: string;\n};\n\nexport function transform(options: Partial<PluginOptions> = {}) {\n    const { runtime = '_assets/mermaid-extension.js', classes = 'yfm-mermaid', bundle = true } = options;\n\n    const plugin: MarkdownItPluginCb<{ output: string }> = function(md: MarkdownIt, { output }) {\n        registerTransforms(md, {\n            classes,\n            runtime,\n            bundle,\n            output,\n            updateTokens: true\n        });\n\n        md.renderer.rules.mermaid = (tokens, idx) => {\n            const token = tokens[idx];\n            const code = encodeURIComponent(token.content.trim());\n\n            return `<div class=\"mermaid\" data-content=\"${ code }\"></div>`;\n        };\n    };\n\n    Object.assign(plugin, {\n        collect(input: string, { destRoot }: InputOptions) {\n            const md = new MarkdownIt().use((md) => {\n                registerTransforms(md, {\n                    classes,\n                    runtime,\n                    bundle,\n                    output: destRoot,\n                    updateTokens: false\n                });\n            });\n\n            md.parse(input, {});\n        }\n    });\n\n    return plugin;\n}"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,uBAA8B;AAC9B,qBAAwC;AACxC,yBAAuB;AAWvB,SAAS,eAAe,OAAc;AAClC,SAAO,MAAM,SAAS,WAAW,MAAM,KAAK,MAAM,oBAAoB;AAC1E;AAEA,SAAS,OACL,KACA,OACA,OACF;AACE,MAAI,EAAE,SAAS,MAAM;AACjB,WAAO,eAAe,KAAK,OAAO;AAAA,MAC9B,YAAY;AAAA,MACZ;AAAA,IACJ,CAAC;AAAA,EACL;AAEA,SAAO;AACX;AAEA,SAAS,KAAK,MAAc,IAAY;AACpC,oCAAU,0BAAQ,EAAE,GAAG,EAAE,WAAW,KAAK,CAAC;AAC1C,mCAAa,MAAM,EAAE;AACzB;AAEA,IAAM,qBAAqB,CAAC,IAAgB;AAAA,EACxC;AAAA,EAAS;AAAA,EAAS;AAAA,EAAQ;AAAA,EAAQ;AACtC,MAGM;AACF,QAAM,kBAAuC,CAAC,EAAE,QAAQ,IAAI,MAAM;AAC9D,WAAO,KAAK,WAAW,oBAAI,IAAY,CAAC;AAExC,UAAM,SAAS,OAAO,OAAO,cAAc;AAE3C,QAAI,gBAAgB,OAAO,QAAQ;AAC/B,aAAO,QAAQ,CAAC,UAAU;AACtB,cAAM,OAAO;AACb,cAAM,QAAQ,SAAS,WAAY,SAAU;AAAA,MACjD,CAAC;AAAA,IACL;AAEA,QAAI,OAAO,QAAQ;AACf,UAAI,OAAO,IAAI,QAAQ,CAAC;AACxB,UAAI,KAAK,SAAS,IAAI,KAAK,UAAU,CAAC;AACtC,UAAI,KAAK,OAAO,KAAK,OAAO;AAE5B,UAAI,QAAQ;AACR,cAAM,WAAO,uBAAK,+BAAS,SAAS;AACpC,YAAI,CAAC,IAAI,QAAQ,IAAI,IAAI,GAAG;AACxB,cAAI,QAAQ,IAAI,IAAI;AAEpB,eAAK,QAAQ,QAAQ,IAAI,OAAG,uBAAK,QAAQ,OAAO,CAAC;AAAA,QACrD;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ;AAEA,MAAI;AACA,OAAG,KAAK,MAAM,MAAM,SAAS,WAAW,eAAe;AAAA,EAC3D,SAAS,GAAP;AACE,OAAG,KAAK,MAAM,KAAK,WAAW,eAAe;AAAA,EACjD;AACJ;AAMO,SAAS,UAAU,UAAkC,CAAC,GAAG;AAC5D,QAAM,EAAE,UAAU,gCAAgC,UAAU,eAAe,SAAS,KAAK,IAAI;AAE7F,QAAM,SAAiD,SAAS,IAAgB,EAAE,OAAO,GAAG;AACxF,uBAAmB,IAAI;AAAA,MACnB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,cAAc;AAAA,IAClB,CAAC;AAED,OAAG,SAAS,MAAM,UAAU,CAAC,QAAQ,QAAQ;AACzC,YAAM,QAAQ,OAAO,GAAG;AACxB,YAAM,OAAO,mBAAmB,MAAM,QAAQ,KAAK,CAAC;AAEpD,aAAO,sCAAuC;AAAA,IAClD;AAAA,EACJ;AAEA,SAAO,OAAO,QAAQ;AAAA,IAClB,QAAQ,OAAe,EAAE,SAAS,GAAiB;AAC/C,YAAM,KAAK,IAAI,mBAAAA,QAAW,EAAE,IAAI,CAACC,QAAO;AACpC,2BAAmBA,KAAI;AAAA,UACnB;AAAA,UACA;AAAA,UACA;AAAA,UACA,QAAQ;AAAA,UACR,cAAc;AAAA,QAClB,CAAC;AAAA,MACL,CAAC;AAED,SAAG,MAAM,OAAO,CAAC,CAAC;AAAA,IACtB;AAAA,EACJ,CAAC;AAED,SAAO;AACX;",
+  "names": ["MarkdownIt", "md"]
+}

package/plugin/transform.d.ts

@@ -0,0 +1,9 @@
+import type { MarkdownItPluginCb } from '@doc-tools/transform/lib/plugins/typings';
+export type PluginOptions = {
+    runtime: string;
+    classes: string;
+    bundle: boolean;
+};
+export declare function transform(options?: Partial<PluginOptions>): MarkdownItPluginCb<{
+    output: string;
+}>;

package/runtime/index.d.ts

@@ -0,0 +1 @@
+export {};