@podlite/schema 0.0.67 → 0.0.69

package/lib/exportHtml.js

@@ -47,24 +47,45 @@ const plugin_clean_location_1 = __importDefault(require("./plugin-clean-location
 const ast_helpers_1 = require("./ast-helpers");
 const link_config_1 = require("./helpers/link-config");
 const entities_1 = require("entities");
-const quoteValue = (value) => value.replace(/"/g, '"');
+const html_attr_1 = require("./helpers/html-attr");
+// HTML gives an anchor without href to a link whose target the author never
+// wrote; an empty href would claim the current document instead. The address is
+// quoted like every other attribute value: a quote inside it would otherwise
+// close the attribute and let the document write markup of its own.
+const hrefAttr = (node, ctx) => {
+    const target = (0, ast_helpers_1.linkTarget)(node);
+    if (target === undefined)
+        return '';
+    const address = (0, ast_helpers_1.sameDocTarget)(target, ctx);
+    // A link level one refused points at nothing, and an anchor with no href is what
+    // html gives that case. An address shaped from a target that was never there only
+    // looks like a working link.
+    return address === undefined ? '' : ` href="${(0, html_attr_1.quoteAttribute)(String(address))}"`;
+};
 const linkConfigAttrs = config => {
     const { newContext, title, lang, download } = (0, link_config_1.readLinkConfig)(config);
     const attrs = [];
     if (newContext)
         attrs.push(' target="_blank"');
     if (title !== undefined)
-        attrs.push(` title="${quoteValue(title)}"`);
+        attrs.push(` title="${(0, html_attr_1.quoteAttribute)(title)}"`);
     if (lang !== undefined)
-        attrs.push(` hreflang="${quoteValue(lang)}"`);
+        attrs.push(` hreflang="${(0, html_attr_1.quoteAttribute)(lang)}"`);
     if (download === true)
         attrs.push(' download');
     else if (typeof download === 'string')
-        attrs.push(` download="${quoteValue(download)}"`);
+        attrs.push(` download="${(0, html_attr_1.quoteAttribute)(download)}"`);
     return attrs.join('');
 };
+// Shaped by the same rule the address is: an anchor keeping a dot the address drops
+// is how :id<v1.2> came to render an unreachable target. Every place that writes an
+// anchor goes through here, or the two sides part again.
+const anchorOf = (node, ctx) => {
+    const written = (0, ast_helpers_1.getExplicitNodeId)(node, ctx);
+    return written === null ? null : (ctx?.__anchors?.shape || ast_helpers_1.toFragment)(written);
+};
 const openTag = (tag, node, ctx, attrs = '') => {
-    const id = (0, ast_helpers_1.getExplicitNodeId)(node, ctx);
+    const id = anchorOf(node, ctx);
     return `<${tag}${id ? ` id="${id}"` : ''}${attrs}>`;
 };
 const rules = {
@@ -147,18 +168,12 @@ const rules = {
     'H<>': (0, handlers_1.wrapContent)('<sup>', '</sup>'),
     'J<>': (0, handlers_1.wrapContent)('<sub>', '</sub>'),
     'L<>': (0, handlers_1.setFn)((node, ctx) => {
-        let { meta } = node;
-        if (meta === null) {
-            meta = node.content;
-        }
-        return (0, handlers_1.wrapContent)(`<a href="${(0, ast_helpers_1.sameDocTarget)(meta, ctx)}"${linkConfigAttrs((0, config_1.codeConfigWithDefaults)(node, ctx))}>`, `</a>`);
+        const attrs = linkConfigAttrs((0, config_1.codeConfigWithDefaults)(node, ctx));
+        return (0, handlers_1.wrapContent)(`<a${hrefAttr(node, ctx)}${attrs}>`, `</a>`);
     }),
     'W<>': (0, handlers_1.setFn)((node, ctx) => {
-        let { meta } = node;
-        if (meta === null) {
-            meta = node.content;
-        }
-        return (0, handlers_1.wrapContent)(`<a href="${(0, ast_helpers_1.sameDocTarget)(meta, ctx)}"${linkConfigAttrs((0, config_1.codeConfigWithDefaults)(node, ctx))} class="backlink">`, `</a>`);
+        const attrs = linkConfigAttrs((0, config_1.codeConfigWithDefaults)(node, ctx));
+        return (0, handlers_1.wrapContent)(`<a${hrefAttr(node, ctx)}${attrs} class="backlink">`, `</a>`);
     }),
     /**
        * CSS rules for footnotes
@@ -244,6 +259,19 @@ const rules = {
     pod: handlers_1.content,
     ':code': (0, handlers_1.wrapContent)('<pre><code>', '</code></pre>'),
     code: (0, handlers_1.handleNested)((0, handlers_1.setFn)((node, ctx) => (0, handlers_1.wrapContent)(`${openTag('pre', node, ctx)}<code>`, '</code></pre>'))),
+    // a folded section is a heading plus the nodes under it; the disclosure is
+    // native so the reader needs no script to open it
+    _folded_section: (writer, processor) => (node, ctx, interator) => {
+        const [heading, ...rest] = (node.content || []);
+        const open = node.foldedState === false || node.foldedState === 0 || node.foldedState === '0';
+        writer.writeRaw(`<details class="folded-section"${open ? ' open' : ''}>`);
+        writer.writeRaw('<summary class="folded-section-summary">');
+        if (heading)
+            interator([heading], ctx);
+        writer.writeRaw('</summary><div class="folded-section-content">');
+        interator(rest, ctx);
+        writer.writeRaw('</div></details>');
+    },
     data: handlers_1.emptyContent,
     ':verbatim': (writer, processor) => (node, ctx, interator) => {
         if (node.error) {
@@ -277,7 +305,7 @@ const rules = {
     // block =para
     // With an :id the block owns the <p> so the anchor lands on it; without one
     // the inner paragraph renders as before.
-    para: (0, handlers_1.handleNested)((0, handlers_1.setFn)((node, ctx) => (0, ast_helpers_1.getExplicitNodeId)(node, ctx)
+    para: (0, handlers_1.handleNested)((0, handlers_1.setFn)((node, ctx) => anchorOf(node, ctx)
         ? (0, handlers_1.subUse)({ ':para': handlers_1.content }, (0, handlers_1.wrapContent)(openTag('p', node, ctx), '</p>'))
         : handlers_1.content)),
     ':para': (0, handlers_1.setFn)((node, ctx) => (0, handlers_1.wrapContent)(openTag('p', node, ctx), '</p>')),
@@ -316,7 +344,7 @@ const rules = {
     'comment:block': handlers_1.emptyContent,
     'boundary:block': (writer, processor) => (node, ctx) => {
         const conf = (0, config_1.default)(node, ctx);
-        const id = (0, ast_helpers_1.getExplicitNodeId)(node, ctx);
+        const id = anchorOf(node, ctx);
         const idAttr = id ? ` id="${id}"` : '';
         if (conf.exists('caption')) {
             writer.writeRaw(`<hr${idAttr} title="`);
@@ -329,7 +357,7 @@ const rules = {
     },
     // The term opens the pair, so an :id on the definition lands on its <dt>.
     defn: (0, handlers_1.setFn)((node, ctx) => {
-        const id = (0, ast_helpers_1.getExplicitNodeId)(node, ctx);
+        const id = anchorOf(node, ctx);
         return id
             ? (0, handlers_1.subUse)({ 'term:para': (0, handlers_1.wrapContent)(`<dt id="${id}">`, '</dt><dd>') }, (0, handlers_1.wrapContent)('', '</dd>'))
             : (0, handlers_1.wrapContent)('', '</dd>');
@@ -421,7 +449,12 @@ const rules = {
     ':toc-list': (0, handlers_1.setFn)((node, ctx) => (0, handlers_1.wrapContent)(`<ul class="toc-list listlevel${node.level}">`, '</ul>')),
     ':toc-item': (0, handlers_1.setFn)((node, ctx) => (0, handlers_1.wrapContent)('<li class="toc-item">', '</li>')),
     ':image': (writer, processor) => (node, ctx, interator) => {
-        writer.writeRaw(`<img src="${(0, image_base_1.applyImageBase)(node.src, ctx?.base)}" alt="${node.alt || ''}"/>`);
+        const src = (0, html_attr_1.quoteAttribute)(String((0, image_base_1.applyImageBase)(node.src, ctx?.base) ?? ''));
+        // html reads a missing alt as "this image is part of the content" and an empty
+        // one as "decorative", so an alternative text the author never wrote is left out
+        const altText = (0, ast_helpers_1.writtenValue)(node.alt);
+        const alt = altText === undefined ? '' : ` alt="${(0, html_attr_1.quoteAttribute)(altText)}"`;
+        writer.writeRaw(`<img src="${src}"${alt}/>`);
     },
 };
 const toHtml = opt => (0, exportAny_1.default)({

package/lib/exportMarkdown.js

@@ -52,6 +52,26 @@ const linkTitle = config => {
     const { title } = (0, link_config_1.readLinkConfig)(config);
     return title === undefined ? '' : ` "${title.replace(/"/g, '\\"')}"`;
 };
+// Markdown has no form for a link whose target the author never wrote — an empty
+// address there claims the current document — so the text is written on its own.
+// A bracket or a space inside the address would end it where markdown looks for
+// the closing one, so such an address is written in angle brackets, the form
+// markdown keeps for exactly that. An angle of its own is percent-encoded rather
+// than dropped, so the address survives the round trip — no source text reaches
+// here holding one today, since the parser ends the code on it.
+const markdownAddress = (address) => /[()\s]/.test(address) ? `<${address.replace(/</g, '%3C').replace(/>/g, '%3E')}>` : address;
+const linkWrap = (node, ctx) => {
+    const target = (0, ast_helpers_1.linkTarget)(node);
+    if (target === undefined)
+        return (0, handlers_1.wrapContent)('', '');
+    const resolved = (0, ast_helpers_1.sameDocTarget)(target, ctx, markdownAnchors(ctx));
+    // Markdown has no anchor without an address either, so a refused link keeps its
+    // text and loses the brackets.
+    if (resolved === undefined)
+        return (0, handlers_1.wrapContent)('', '');
+    const address = String(resolved);
+    return (0, handlers_1.wrapContent)(`[`, `](${markdownAddress(address)}${linkTitle((0, config_1.codeConfigWithDefaults)(node, ctx))})`);
+};
 // A cell's own text is written whole. Trimming each fragment on its own eats the
 // spaces that sit between them — between a word and a markup code, or around a
 // sign the parser split the text on — so only the cell edges are stripped.
@@ -122,20 +142,8 @@ const rules = {
     },
     'H<>': (0, handlers_1.wrapContent)('<sup>', '</sup>'),
     'J<>': (0, handlers_1.wrapContent)('<sub>', '</sub>'),
-    'L<>': (0, handlers_1.setFn)((node, ctx) => {
-        let { meta } = node;
-        if (meta === null) {
-            meta = node.content;
-        }
-        return (0, handlers_1.wrapContent)(`[`, `](${(0, ast_helpers_1.sameDocTarget)(meta, ctx, markdownAnchors(ctx))}${linkTitle((0, config_1.codeConfigWithDefaults)(node, ctx))})`);
-    }),
-    'W<>': (0, handlers_1.setFn)((node, ctx) => {
-        let { meta } = node;
-        if (meta === null) {
-            meta = node.content;
-        }
-        return (0, handlers_1.wrapContent)(`[`, `](${(0, ast_helpers_1.sameDocTarget)(meta, ctx, markdownAnchors(ctx))}${linkTitle((0, config_1.codeConfigWithDefaults)(node, ctx))})`);
-    }),
+    'L<>': (0, handlers_1.setFn)((node, ctx) => linkWrap(node, ctx)),
+    'W<>': (0, handlers_1.setFn)((node, ctx) => linkWrap(node, ctx)),
     'N<>': (writer, processor) => {
         writer.addListener('end', () => {
             if (!writer.hasOwnProperty('FOOTNOTES')) {
@@ -457,7 +465,11 @@ const rules = {
     ':toc-list': handlers_1.emptyContent,
     ':toc-item': handlers_1.emptyContent,
     ':image': (writer, processor) => (node, ctx, interator) => {
-        writer.writeRaw(`![${node.alt || ''}](${(0, image_base_1.applyImageBase)(node.src, ctx?.base)})`);
+        // the alternative text sits between square brackets, where a `]` of its own
+        // would end it, and the address between round ones — the same shape a link has
+        const alt = ((0, ast_helpers_1.writtenValue)(node.alt) ?? '').replace(/([[\]\\])/g, '\\$1');
+        const src = markdownAddress(String((0, image_base_1.applyImageBase)(node.src, ctx?.base) ?? ''));
+        writer.writeRaw(`![${alt}](${src})`);
     },
 };
 const toMarkdown = opt => (0, exportAny_1.default)({

package/lib/folded-sections.d.ts

@@ -0,0 +1 @@
+export declare const applyFoldedSections: (node: any) => any;

package/lib/folded-sections.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyFoldedSections = void 0;
+// Folding of a section belongs to the tree, not to one renderer: the command
+// line and every build-time producer read the same document as the editor does.
+// Moved here from @podlite/to-jsx, where it lived and left exportHtml and
+// exportMarkdown unable to fold anything.
+// `:folded` on a heading folds the whole section — the heading plus every
+// following node up to the next same-or-higher-level heading. Detect the
+// attribute on =head nodes in a container's content array and wrap that
+// range in a synthetic `_folded_section` block so the JSX renderer can emit
+// <details> around it.
+const getFoldedAttr = (node) => {
+    const config = node && node.config;
+    if (!Array.isArray(config))
+        return null;
+    const entry = config.find((c) => c && c.name === 'folded');
+    return entry ? entry.value : null;
+};
+const isHeadBlock = (node) => node && node.type === 'block' && node.name === 'head' && node.level !== undefined && node.level !== null;
+const headLevel = (node) => Number(node.level);
+const groupFoldedSections = (content) => {
+    if (!Array.isArray(content))
+        return content;
+    const result = [];
+    let i = 0;
+    while (i < content.length) {
+        const node = content[i];
+        if (isHeadBlock(node)) {
+            const folded = getFoldedAttr(node);
+            if (folded !== null) {
+                const level = headLevel(node);
+                const sectionNodes = [node];
+                let j = i + 1;
+                while (j < content.length) {
+                    const next = content[j];
+                    if (isHeadBlock(next) && headLevel(next) <= level)
+                        break;
+                    sectionNodes.push(next);
+                    j++;
+                }
+                result.push({
+                    type: 'block',
+                    name: '_folded_section',
+                    content: sectionNodes,
+                    foldedState: folded,
+                    location: node.location,
+                });
+                i = j;
+                continue;
+            }
+        }
+        result.push(node);
+        i++;
+    }
+    return result;
+};
+// Walk the AST and apply `groupFoldedSections` to every block's `content`
+// array, so :folded heads inside named blocks, defn, nested etc. fold the
+// same way they do at the pod-level. Inside an already-built
+// `_folded_section`, the first element is the heading the wrapper belongs
+// to — skip it when grouping the rest, otherwise the same head would be
+// re-wrapped on every recursion. Nested folds (a folded heading inside a
+// folded section's body) are still picked up by grouping the remainder.
+const applyFoldedSections = (node) => {
+    if (!node || typeof node !== 'object')
+        return node;
+    if (Array.isArray(node))
+        return node.map(exports.applyFoldedSections);
+    if (!Array.isArray(node.content))
+        return node;
+    if (node.name === '_folded_section') {
+        const [head, ...rest] = node.content;
+        const grouped = groupFoldedSections(rest);
+        return {
+            ...node,
+            content: [(0, exports.applyFoldedSections)(head), ...grouped.map(exports.applyFoldedSections)],
+        };
+    }
+    const grouped = groupFoldedSections(node.content);
+    return { ...node, content: grouped.map(exports.applyFoldedSections) };
+};
+exports.applyFoldedSections = applyFoldedSections;
+//# sourceMappingURL=folded-sections.js.map