@player-ui/markdown-plugin 0.3.1--canary.193.5900

package/dist/index.cjs.js

@@ -0,0 +1,314 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var player = require('@player-ui/player');
+var mdastUtilFromMarkdown = require('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 } = mdastUtilFromMarkdown.fromMarkdown(asset.value);
+  const isMultiParagraph = children.length > 1;
+  if (isMultiParagraph) {
+    const value = children.map((node) => {
+      const transformer2 = transformers[node.type];
+      return transformer2({
+        astNode: node,
+        asset,
+        mappers,
+        transformers
+      });
+    });
+    const collection = mappers.collection({
+      originalAsset: asset,
+      value
+    });
+    return (parser == null ? void 0 : parser(collection, player.NodeType.Asset)) || null;
+  }
+  const transformer = transformers[children[0].type];
+  const content = transformer({
+    astNode: children[0],
+    asset,
+    mappers,
+    transformers
+  });
+  return (parser == null ? void 0 : parser(content, player.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$1) {
+    player$1.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) === player.NodeType.Asset && node.value.type === "markdown") {
+            const resolvedContent = player.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
+            });
+            return parsed;
+          }
+          return node;
+        });
+      });
+    });
+  }
+}
+
+exports.MarkdownPlugin = MarkdownPlugin;
+//# sourceMappingURL=index.cjs.js.map

package/dist/index.d.ts

@@ -0,0 +1,144 @@
+import { PlayerPlugin, Player } from '@player-ui/player';
+import { Asset } from '@player-ui/types';
+
+interface BaseArgs {
+    /**
+     * Unparsed Asset
+     */
+    originalAsset: Asset;
+}
+declare type LiteralMapper<T extends object = object> = (args: {
+    /**
+     * markdown element value
+     */
+    value: string;
+} & BaseArgs & T) => Asset;
+declare type CompositeMapper<T extends object = object> = (args: {
+    /**
+     * array of assets resulted from the recursion over the AST node children
+     */
+    value: Asset[];
+} & BaseArgs & T) => Asset;
+declare type FallbackMapper = (args: {
+    /**
+     * markdown element value
+     */
+    value: string | Asset[];
+} & BaseArgs) => Asset;
+interface Mappers {
+    /**
+     * required text Asset
+     */
+    text: LiteralMapper;
+    /**
+     * required paragraph (composite) Asset
+     */
+    paragraph: CompositeMapper;
+    /**
+     * required collection Asset to wrap arrays of assets
+     */
+    collection: CompositeMapper;
+    /**
+     * strong markdown (e.g. **bold**)
+     */
+    strong?: CompositeMapper;
+    /**
+     * emphasis markdown (e.g. *italic*)
+     */
+    emphasis?: CompositeMapper;
+    /**
+     * blockquote markdown (e.g. > blockquote)
+     */
+    blockquote?: CompositeMapper;
+    /**
+     * ordered or unordered list markdown (e.g. 1. item\n2. item, - item\n- item)
+     */
+    list?: CompositeMapper<{
+        /**
+         * Whether the list is ordered or not.
+         */
+        ordered: boolean;
+        /**
+         * The starting list number.
+         */
+        start?: number;
+    }>;
+    /**
+     * horizontalRule markdown (e.g. ---)
+     */
+    horizontalRule?: LiteralMapper;
+    /**
+     * link markdown (e.g. `[text](url)`)
+     */
+    link?: CompositeMapper<{
+        /**
+         * Link URL
+         */
+        href: string;
+    }>;
+    /**
+     * image markdown (e.g. `![alt](url)`)
+     */
+    image?: LiteralMapper<{
+        /**
+         * Image source URL
+         */
+        src: string;
+    }>;
+    /**
+     * code block markdown (e.g. ```code```)
+     */
+    code?: LiteralMapper<{
+        /**
+         * The language of the code block.
+         */
+        lang?: string;
+    }>;
+    /**
+     * heading markdown (e.g. # heading)
+     */
+    heading?: CompositeMapper<{
+        /**
+         * The heading depth.
+         */
+        depth: number;
+    }>;
+    /**
+     * inline code markdown (e.g. `code`)
+     */
+    inlineCode?: LiteralMapper;
+    /**
+     * list item markdown (e.g. - item)
+     */
+    listItem?: CompositeMapper;
+}
+declare type Transformer<T = any> = (args: {
+    /**
+     * AST Node (e.g. Link)
+     */
+    astNode: T;
+    /**
+     * Player Asset
+     */
+    asset: Asset;
+    /**
+     * Record off mappers (markdown element -> Asset)
+     */
+    mappers: Mappers;
+    /**
+     * Record of parsers (e.g., { link :linkParser })
+     */
+    transformers: Record<string, Transformer>;
+}) => Asset;
+
+/**
+ * A plugin that parses markdown written into text assets using the given converters for markdown features into existing assets.
+ */
+declare class MarkdownPlugin implements PlayerPlugin {
+    name: string;
+    private mappers;
+    constructor(mappers: Mappers);
+    apply(player: Player): void;
+}
+
+export { BaseArgs, CompositeMapper, FallbackMapper, LiteralMapper, Mappers, MarkdownPlugin, Transformer };