@player-ui/markdown-plugin 0.4.0--canary.143.5197

package/dist/index.esm.js

@@ -0,0 +1,298 @@
+import { NodeType, resolveDataRefsInString } from '@player-ui/player';
+import { fromMarkdown } from 'mdast-util-from-markdown';
+
+var __defProp$1 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+function swapMarkdownType(asset) {
+  return __spreadProps$1(__spreadValues$1({}, asset), { type: "text" });
+}
+const textTransformer = ({ astNode, asset, mappers }) => {
+  const { value } = astNode;
+  return mappers.text({
+    originalAsset: asset,
+    value
+  });
+};
+const emphasisTransformer = ({
+  astNode,
+  asset,
+  mappers,
+  transformers: transformers2
+}) => {
+  if (mappers.emphasis) {
+    const { children } = astNode;
+    const value = children.map((node) => transformers2[node.type]({ astNode: node, asset, mappers, transformers: transformers2 }));
+    return mappers.emphasis({
+      originalAsset: asset,
+      value
+    });
+  }
+  return swapMarkdownType(asset);
+};
+const strongTransformer = ({
+  astNode,
+  asset,
+  mappers,
+  transformers: transformers2
+}) => {
+  if (mappers.strong) {
+    const { children } = astNode;
+    const value = children.map((node) => transformers2[node.type]({ astNode: node, asset, mappers, transformers: transformers2 }));
+    return mappers.strong({
+      originalAsset: asset,
+      value
+    });
+  }
+  return swapMarkdownType(asset);
+};
+const paragraphTransformer = ({
+  astNode,
+  asset,
+  mappers,
+  transformers: transformers2
+}) => {
+  const { children } = astNode;
+  if (children.every(({ type }) => Boolean(mappers[type]))) {
+    const value = children.map((node) => transformers2[node.type]({ astNode: node, asset, mappers, transformers: transformers2 }));
+    return mappers.paragraph({
+      originalAsset: asset,
+      value
+    });
+  }
+  return swapMarkdownType(asset);
+};
+const listTransformer = ({
+  astNode,
+  asset,
+  mappers,
+  transformers: transformers2
+}) => {
+  if (mappers.list) {
+    const { children, ordered, start } = astNode;
+    const value = children.map((node) => transformers2[node.type]({ astNode: node, asset, mappers, transformers: transformers2 }));
+    return mappers.list({
+      originalAsset: asset,
+      value,
+      ordered: Boolean(ordered),
+      start: start || void 0
+    });
+  }
+  return swapMarkdownType(asset);
+};
+const listItemTransformer = ({
+  astNode,
+  asset,
+  mappers,
+  transformers: transformers2
+}) => {
+  const { children } = astNode;
+  const value = children.map((node) => transformers2[node.type]({ astNode: node, asset, mappers, transformers: transformers2 }));
+  const mapper = mappers.listItem || mappers.paragraph;
+  return mapper({
+    originalAsset: asset,
+    value
+  });
+};
+const linkTransformer = ({
+  astNode,
+  asset,
+  mappers,
+  transformers: transformers2
+}) => {
+  if (mappers.link) {
+    const { children, url } = astNode;
+    const value = children.map((node) => transformers2[node.type]({ astNode: node, asset, mappers, transformers: transformers2 }));
+    return mappers.link({
+      originalAsset: asset,
+      href: url,
+      value
+    });
+  }
+  return swapMarkdownType(asset);
+};
+const imageTransformer = ({ astNode, asset, mappers }) => {
+  if (mappers.image) {
+    const { title, url, alt } = astNode;
+    return mappers.image({
+      originalAsset: asset,
+      src: url,
+      value: title || alt || ""
+    });
+  }
+  return swapMarkdownType(asset);
+};
+const blockquoteTransformer = ({
+  astNode,
+  asset,
+  mappers,
+  transformers: transformers2
+}) => {
+  if (mappers.blockquote) {
+    const { children } = astNode;
+    const value = children.map((node) => transformers2[node.type]({ astNode: node, asset, mappers, transformers: transformers2 }));
+    return mappers.blockquote({
+      originalAsset: asset,
+      value
+    });
+  }
+  return swapMarkdownType(asset);
+};
+const inlineCodeTransformer = ({
+  astNode,
+  asset,
+  mappers
+}) => {
+  if (mappers.inlineCode) {
+    const { value } = astNode;
+    return mappers.inlineCode({
+      originalAsset: asset,
+      value
+    });
+  }
+  return swapMarkdownType(asset);
+};
+const codeTransformer = ({ astNode, asset, mappers }) => {
+  if (mappers.code) {
+    const { value, lang } = astNode;
+    return mappers.code({
+      originalAsset: asset,
+      value,
+      lang: lang || void 0
+    });
+  }
+  return swapMarkdownType(asset);
+};
+const horizontalRuleTransformer = ({
+  asset,
+  mappers
+}) => {
+  if (mappers.horizontalRule) {
+    return mappers.horizontalRule({
+      originalAsset: asset,
+      value: "---"
+    });
+  }
+  return swapMarkdownType(asset);
+};
+const headingTransformer = ({
+  astNode,
+  asset,
+  mappers,
+  transformers: transformers2
+}) => {
+  if (mappers.heading) {
+    const { children, depth } = astNode;
+    const value = children.map((node) => transformers2[node.type]({ astNode: node, asset, mappers, transformers: transformers2 }));
+    return mappers.heading({
+      originalAsset: asset,
+      value,
+      depth
+    });
+  }
+  return swapMarkdownType(asset);
+};
+const transformers = {
+  horizontalRule: horizontalRuleTransformer,
+  text: textTransformer,
+  emphasis: emphasisTransformer,
+  strong: strongTransformer,
+  blockquote: blockquoteTransformer,
+  list: listTransformer,
+  listItem: listItemTransformer,
+  link: linkTransformer,
+  image: imageTransformer,
+  paragraph: paragraphTransformer,
+  code: codeTransformer,
+  heading: headingTransformer,
+  inlineCode: inlineCodeTransformer
+};
+
+function parseAssetMarkdownContent({
+  asset,
+  mappers,
+  parser
+}) {
+  const { children } = fromMarkdown(asset.value);
+  return children.map((node) => {
+    const transformer = transformers[node.type];
+    const content = transformer({
+      astNode: node,
+      asset,
+      mappers,
+      transformers
+    });
+    return (parser == null ? void 0 : parser(content, children.length > 1 ? NodeType.Value : NodeType.Asset)) || null;
+  });
+}
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+class MarkdownPlugin {
+  constructor(mappers) {
+    this.name = "MarkdownPlugin";
+    this.mappers = mappers;
+  }
+  apply(player) {
+    player.hooks.view.tap(this.name, (view) => {
+      view.hooks.resolver.tap(this.name, (resolver) => {
+        resolver.hooks.beforeResolve.tap(this.name, (node, options) => {
+          if ((node == null ? void 0 : node.type) === NodeType.Asset && node.value.type === "markdown") {
+            const resolvedContent = resolveDataRefsInString(node.value.value, {
+              evaluate: options.evaluate,
+              model: options.data.model
+            });
+            const parsed = parseAssetMarkdownContent({
+              asset: __spreadProps(__spreadValues({}, node.value), {
+                value: resolvedContent
+              }),
+              mappers: this.mappers,
+              parser: options.parseNode
+            });
+            if (parsed.length === 1) {
+              return parsed[0];
+            }
+            return __spreadProps(__spreadValues({}, node), { nodeType: NodeType.MultiNode, values: parsed });
+          }
+          return node;
+        });
+      });
+    });
+  }
+}
+
+export { MarkdownPlugin };
+//# sourceMappingURL=index.esm.js.map