@podlite/markdown 0.0.31 → 0.0.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@podlite/markdown",
-  "version": "0.0.31",
+  "version": "0.0.32",
   "description": "Bidirectional Markdown support for Podlite — parse .md files, embed Markdown blocks",
   "main": "./lib/index.cjs",
   "homepage": "https://podlite.org",
@@ -17,6 +17,13 @@
     "type": "opencollective",
     "url": "https://opencollective.com/podlite"
   },
+  "files": [
+    "lib",
+    "esm",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
   "scripts": {
     "clean": "rm -rf dist lib esm tsconfig.tsbuildinfo",
     "test": "yarn g:jest  --passWithNoTests",
@@ -47,7 +54,7 @@
     "compatibility"
   ],
   "dependencies": {
-    "@podlite/schema": "0.0.38",
+    "@podlite/schema": "0.0.39",
     "react": "^16.0.0 || ^17.0.0 || ^18",
     "react-dom": "^16.0.0 || ^17.0.0 || ^18",
     "react-is": "^18.0.0",

package/jest.config.js

@@ -1 +0,0 @@
-module.exports = require('../../jest.config')

package/jest.tsconfig.json

@@ -1 +0,0 @@
-{ "extends": "../../jest.tsconfig.json" }

package/scripts/build.ts

@@ -1,16 +0,0 @@
-import { build } from 'esbuild'
-
-build({
-  bundle: true,
-  entryPoints: ['src/index.tsx'],
-  external: ['react', 'react-dom'],
-  minify: true,
-  format: 'cjs',
-  target: 'node14',
-  platform: 'node',
-  sourcemap: true,
-  outfile: 'lib/index.cjs',
-}).catch(e => {
-  console.log('Build not successful', e.message)
-  process.exit(1)
-})

package/scripts/build_esm.ts

@@ -1,18 +0,0 @@
-import { build, BuildOptions } from 'esbuild'
-const opt: BuildOptions = {
-  tsconfig: 'tsconfig-esm.json',
-}
-build({
-  bundle: true,
-  entryPoints: ['src/index.tsx'],
-  external: ['react', 'react-dom'],
-  minify: false,
-  format: 'esm',
-  target: 'es2019',
-  sourcemap: true,
-  outfile: 'lib/index.esm.js',
-  ...opt,
-}).catch(e => {
-  console.log('Build not successful', e.message)
-  process.exit(1)
-})

package/src/index.tsx

@@ -1,26 +0,0 @@
-import { content as nodeContent, Plugins } from '@podlite/schema'
-import { Plugin } from '@podlite/schema'
-import { md2ast } from './tools'
-
-export const plugin: Plugin = {
-  toAst: (_, processor) => (node, ctx) => {
-    if (typeof node !== 'string' && 'type' in node && 'content' in node && node.type === 'block') {
-      const content = node.content[0]
-      if (content && typeof content !== 'string' && 'location' in node && 'value' in content) {
-        const lineOffset = node.location.start.line
-        return { ...node, content: md2ast(content, { lineOffset }) }
-      }
-      return node
-    }
-  },
-  toJSX: helper => {
-    return nodeContent
-  },
-}
-export const PluginRegister: Plugins = {
-  Markdown: plugin, //TODO: deprecate it
-  markdown: plugin,
-}
-
-export { md2ast as parseMd } from './tools'
-export default plugin

package/src/tools.ts

@@ -1,224 +0,0 @@
-import { unified } from 'unified'
-import markdown from 'remark-parse'
-import remarkGfm from 'remark-gfm'
-import remarkMath from 'remark-math'
-
-import {
-  toAny,
-  AstTree,
-  BlockImage,
-  mkBlock,
-  mkFomattingCode,
-  mkFomattingCodeL,
-  mkVerbatim,
-  Location,
-  mkMarkupCodeF,
-  mkFormulaBlock,
-} from '@podlite/schema'
-import { mkRootBlock } from '@podlite/schema'
-import { mkImage } from '@podlite/schema'
-import { mkCaption } from '@podlite/schema'
-import { mkFomattingCodeO } from '@podlite/schema'
-
-type Md2astArgs = { lineOffset?: number }
-export const md2ast = (src: string, { lineOffset }: Md2astArgs = { lineOffset: 0 }): AstTree => {
-  // first convert mardown to ast
-  const md_tree = unified().use(markdown).use(remarkGfm).use(remarkMath).parse(src)
-
-  // first pass : collect linkRefs
-  let definitionMap = {}
-  const applyLineOffset = (
-    (offset: number) =>
-    (location: Location): Location => {
-      const { start, end } = location
-      return {
-        start: {
-          ...start,
-          line: start.line + offset,
-        },
-        end: {
-          ...end,
-          line: end.line + offset,
-        },
-      }
-    }
-  )(lineOffset)
-  toAny({ processor: 1 })
-    .use({
-      '*:*': (writer, processor) => (node, ctx, interator) => {
-        if (node.children) interator(node.children, { ...ctx })
-      },
-    })
-    .use({
-      ':definition': (writer, processor) => (node, ctx, interator) => {
-        definitionMap[node.identifier] = node
-      },
-    })
-    .run(md_tree)
-
-  // second stage - make Universal AST nodes
-  const uast = []
-  const res = toAny({ processor: 1 })
-    .use({
-      '*:*': (writer, processor) => (node, ctx, interator) => {
-        console.warn('[Podlite:md2ast]- unhandled MD node')
-        console.warn(JSON.stringify(node, null, 2))
-        if (node.children) interator(node.children, { ...ctx })
-      },
-    })
-    .use({
-      ':root': (writer, processor) => (node, ctx, interator) => {
-        const { children, position, ...attr } = node
-        return mkRootBlock({}, interator(children, ctx))
-      },
-      ':math': (writer, processor) => (node, ctx, interator) => {
-        const { value, children, position, ...attr } = node
-        return mkFormulaBlock({ value, location: applyLineOffset(position) })
-      },
-      ':inlineMath': (writer, processor) => (node, ctx, interator) => {
-        const { value, children, position, ...attr } = node
-        return mkMarkupCodeF(value)
-      },
-
-      ':heading': (writer, processor) => (node, ctx, interator) => {
-        const { children, position, ...attr } = node
-        return mkBlock(
-          { type: 'block', level: node.depth, name: 'head', location: applyLineOffset(position) },
-          interator(children, ctx),
-        )
-      },
-      ':text': (writer, processor) => (node, ctx, interator) => {
-        const { children, position, ...attr } = node
-        return node.value
-        // return mkNode({type:"text", value: node.value})
-      },
-      ':list': (writer, processor) => (node, ctx, interator) => {
-        const savedListLevel = ctx['listLevel'] || 0
-        const { children, position, ...attr } = node
-        return mkBlock(
-          { type: 'list', level: savedListLevel + 1, list: node.ordered ? 'ordered' : 'itemized' },
-          interator(children, { ...ctx, listLevel: savedListLevel + 1, ordered: node.ordered }),
-        )
-      },
-      ':listItem': (writer, processor) => (node, ctx, interator) => {
-        const savedListLevel = ctx['listLevel'] || 0
-        const { children, position, checked, ...attr } = node
-        const blockAttrs: any = {
-          name: 'item',
-          type: 'block',
-          level: ctx['listLevel'],
-          location: applyLineOffset(position),
-        }
-
-        if (checked !== null && checked !== undefined) {
-          blockAttrs.checked = checked
-          blockAttrs.config = [{ name: 'checked', value: checked, type: 'boolean' }]
-        }
-
-        return mkBlock(blockAttrs, interator(children, { ...ctx, listLevel: savedListLevel, ordered: node.ordered }))
-      },
-      ':paragraph': (writer, processor) => (node, ctx, interator) => {
-        const { children, position, ...attr } = node
-        return mkBlock(
-          { type: 'para', location: applyLineOffset(position), text: 'text', margin: '' },
-          interator(children, { ...ctx }),
-        )
-      },
-      ':linkReference': (writer, processor) => (node, ctx, interator) => {
-        const { children, position, ...attr } = node
-        const definition = definitionMap[attr.identifier]
-        const meta = definition?.url || ''
-        return mkFomattingCodeL({ meta }, interator(children, { ...ctx }))
-      },
-      ':definition': (writer, processor) => (node, ctx, interator) => {
-        return null
-      },
-      ':inlineCode': (writer, processor) => (node, ctx, interator) => {
-        const { children, position, ...attr } = node
-        return mkFomattingCode({ name: 'C' }, [node.value])
-      },
-      ':strong': (writer, processor) => (node, ctx, interator) => {
-        const { children, position, ...attr } = node
-        return mkFomattingCode({ name: 'B' }, interator(children, { ...ctx }))
-      },
-      ':emphasis': (writer, processor) => (node, ctx, interator) => {
-        const { children, position, ...attr } = node
-        return mkFomattingCode({ name: 'I' }, interator(children, { ...ctx }))
-      },
-      ':link': (writer, processor) => (node, ctx, interator) => {
-        const { children, position, ...attr } = node
-        return mkFomattingCodeL({ meta: node.url }, interator(children, { ...ctx }))
-      },
-      ':html': (writer, processor) => (node, ctx, interator) => {
-        const { children, position, ...attr } = node
-        return mkBlock({ type: 'block', name: 'Html', location: applyLineOffset(position) }, [mkVerbatim(node.value)])
-      },
-      ':code': (writer, processor) => (node, ctx, interator) => {
-        const { children, position, lang, meta, ...attr } = node
-        if (lang === 'mermaid' || lang === 'diagram') {
-          return mkBlock({ type: 'block', name: 'Mermaid', config: [], location: applyLineOffset(position) }, [
-            mkVerbatim(node.value),
-          ])
-        }
-        let config = []
-        if (lang) {
-          config.push({ name: 'lang', value: lang, type: 'string' })
-        }
-        if (meta) {
-          config.push({ name: 'meta', value: meta, type: 'string' })
-        } //  filled as is from markdown
-        return mkBlock({ type: 'block', name: 'code', config, location: applyLineOffset(position) }, [
-          mkVerbatim(node.value),
-        ])
-      },
-      ':image':
-        (writer, processor) =>
-        (node, ctx, interator): BlockImage => {
-          const { title, alt, url, position, ...attr } = node
-          let config = []
-          const content: any[] = [mkImage(url, alt)]
-          if (title) content.push(mkCaption([title]))
-          return mkBlock({ type: 'block', name: 'Image', config, location: applyLineOffset(position) }, content)
-        },
-      ':thematicBreak': (writer, processor) => (node, ctx, interator) => {
-        return null // TODO: add support for "thematic break"
-      },
-      ':blockquote': (writer, processor) => (node, ctx, interator) => {
-        const { children, position, ...attr } = node
-        return mkBlock({ name: 'nested', location: applyLineOffset(position) }, interator(children, { ...ctx }))
-      },
-      //table section
-      ':table': (writer, processor) => (node, ctx, interator) => {
-        const { children, position, align, ...attr } = node
-        return mkBlock(
-          { name: 'table', location: applyLineOffset(position), align },
-          interator(children, { ...ctx, isHeaderUsed: 0 }),
-        )
-      },
-      ':tableRow': (writer, processor) => (node, ctx, interator) => {
-        const { children, position, ...attr } = node
-        const isHeaderUsed = ctx.isHeaderUsed++
-        const blockAttrs: Record<string, unknown> = {
-          name: 'row',
-          location: applyLineOffset(position),
-        }
-        if (!isHeaderUsed) {
-          blockAttrs.config = [{ name: 'header', value: true, type: 'boolean' }]
-        }
-        return mkBlock(blockAttrs, interator(children, { ...ctx }))
-      },
-      ':tableCell': (writer, processor) => (node, ctx, interator) => {
-        const { children, position, ...attr } = node
-        return mkBlock({ name: 'cell', location: applyLineOffset(position) }, interator(children, { ...ctx }))
-      },
-      ':delete': (writer, processor) => (node, ctx, interator) => {
-        const { children, position, ...attr } = node
-        return mkFomattingCodeO(interator(children, { ...ctx }))
-      },
-      ':break': (writer, processor) => (node, ctx, interator) => {
-        return null
-      },
-    })
-    .run(md_tree)
-  return res.interator
-}