@north-light/crouter 0.3.197 → 0.3.199

package/dist/commands/human/doc.js

@@ -1,144 +0,0 @@
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { tmpdir } from 'node:os';
-import { defineBranch, defineLeaf } from '../../core/command.js';
-import { InputError } from '../../core/io.js';
-import { readConfig } from '../../core/config.js';
-import { derivePageManifest } from '../../core/human/page.js';
-import { checkMarkdown, renderMarkdown } from '../../core/termrender/termrender.js';
-function documentSource(input, context) {
-    const path = input['path'];
-    const body = input['body'];
-    const stdinProvided = context?.providedParams.has('body') === true;
-    if (path === undefined && !stdinProvided) {
-        throw new InputError({
-            error: 'missing_parameter',
-            message: 'provide exactly one document source: PATH or stdin',
-            next: 'Run `crtr human doc check -h` or `crtr human doc render -h` and provide a path or pipe a document on stdin.',
-        });
-    }
-    if (path !== undefined && path !== '-' && stdinProvided && body.trim() !== '') {
-        throw new InputError({
-            error: 'bad_invocation',
-            message: 'both a positional path and piped stdin were provided',
-            field: 'path, body',
-            next: 'Pass exactly one document source: either PATH or piped stdin, not both.',
-        });
-    }
-    if (path === undefined || path === '-')
-        return { body };
-    const abs = resolve(path);
-    if (!existsSync(abs)) {
-        throw new InputError({
-            error: 'file_not_found',
-            message: `file not found: ${abs}`,
-            field: 'path',
-            next: 'Provide a path to an existing markdown or HTML file, or pipe a document on stdin.',
-        });
-    }
-    return { body: readFileSync(abs, 'utf8'), path: abs };
-}
-function markdownSource(input, context) {
-    return documentSource(input, context).body;
-}
-function pageDialect(source) {
-    const extension = source.path?.toLowerCase();
-    if (extension?.endsWith('.html') || extension?.endsWith('.htm'))
-        return 'html';
-    if (/^\s*<!doctype\b/i.test(source.body) || /^\s*<html(?:\s|>)/i.test(source.body))
-        return 'html';
-    if (source.body.startsWith('---'))
-        return 'md';
-    return undefined;
-}
-function checkPage(source, dialect) {
-    const config = readConfig('user');
-    if (dialect === 'html' && !config.html_pages) {
-        return { ok: false, error: 'HTML page validation requires the user-scope html_pages capability flag to be enabled (html_pages is false).' };
-    }
-    let tempDir;
-    try {
-        const sourcePath = source.path ?? (() => {
-            tempDir = mkdtempSync(join(tmpdir(), 'crtr-human-doc-'));
-            const path = join(tempDir, dialect === 'html' ? 'page.html' : 'page.md');
-            writeFileSync(path, source.body, 'utf8');
-            return path;
-        })();
-        derivePageManifest(sourcePath, dialect, config.page_components);
-        return { ok: true };
-    }
-    catch (error) {
-        return { ok: false, error: error instanceof Error ? error.message : String(error) };
-    }
-    finally {
-        if (tempDir !== undefined)
-            rmSync(tempDir, { recursive: true, force: true });
-    }
-}
-const humanDocCheck = defineLeaf({
-    name: 'check',
-    description: 'validate a directive-flavored markdown body or page source',
-    whenToUse: 'validating a page source or review body before submitting it.',
-    help: {
-        name: 'human doc check',
-        summary: 'validate directive-flavored markdown or a page through the managed renderer and page schemas',
-        guide: 'Plain markdown is checked by the pinned renderer. A file with page front matter or an HTML document is parsed as a page; HTML page validation requires the user-scope html_pages capability flag.',
-        params: [
-            { kind: 'positional', name: 'path', type: 'path', required: false, constraint: 'Markdown or HTML file to validate. Files ending in .html/.htm, HTML documents beginning with a doctype or <html, and markdown beginning with --- front matter are checked as pages. Provide exactly one of PATH or stdin; use - to read stdin.' },
-            { kind: 'stdin', name: 'body', required: false, constraint: 'Markdown or HTML to validate. Provide exactly one of piped stdin or PATH.' },
-        ],
-        output: [
-            { name: 'ok', type: 'boolean', required: true, constraint: 'True when the markdown is valid.' },
-            { name: 'error', type: 'string', required: false, constraint: 'The renderer or page-parser validation error when ok is false.' },
-        ],
-        outputKind: 'object',
-        effects: ['Read-only: invokes the private managed renderer or page parser to validate the supplied document.'],
-    },
-    run: async (input, context) => {
-        const source = documentSource(input, context);
-        const dialect = pageDialect(source);
-        if (dialect !== undefined)
-            return checkPage(source, dialect);
-        return checkMarkdown(source.body);
-    },
-});
-const humanDocRender = defineLeaf({
-    name: 'render',
-    description: 'render a directive-flavored markdown body',
-    whenToUse: 'previewing how a page or review body renders before submitting it.',
-    help: {
-        name: 'human doc render',
-        summary: 'render directive-flavored markdown through the pinned managed renderer',
-        guide: 'The pinned renderer runs from a private managed venv and is not on PATH, so this is the only way to render a page or review body before submitting it.',
-        params: [
-            { kind: 'positional', name: 'path', type: 'path', required: false, constraint: 'Markdown file to render. Provide exactly one of PATH or stdin; use - to read stdin.' },
-            { kind: 'stdin', name: 'body', required: false, constraint: 'Markdown to render. Provide exactly one of piped stdin or PATH.' },
-            { kind: 'flag', name: 'width', type: 'int', required: false, default: process.stdout.columns || 100, constraint: 'Render width in columns. Default: current stdout width, or 100.' },
-            { kind: 'flag', name: 'color', type: 'bool', required: false, default: true, constraint: 'Emit ANSI color. Default true; false strips ANSI escape sequences.' },
-        ],
-        output: [
-            { name: 'lines', type: 'string[]', required: true, constraint: 'Rendered terminal lines in display order.' },
-            { name: 'width', type: 'integer', required: true, constraint: 'The render width in columns.' },
-        ],
-        outputKind: 'object',
-        effects: ['Read-only: invokes the private managed renderer to render the supplied body.'],
-    },
-    run: async (input, context) => {
-        const width = input['width'];
-        const color = input['color'];
-        const lines = renderMarkdown(markdownSource(input, context), width);
-        return { lines: color ? lines : lines.map((line) => line.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '')), width };
-    },
-    render: (result) => result['lines'].join('\n'),
-});
-export const humanDoc = defineBranch({
-    name: 'doc',
-    description: 'validate or render directive-flavored markdown bodies',
-    whenToUse: 'validating or previewing a directive-flavored markdown body before submitting it.',
-    help: {
-        name: 'human doc',
-        summary: 'validate and render directive-flavored markdown bodies',
-        model: 'Both leaves read exactly one body from a path or stdin through the private managed renderer.',
-    },
-    children: [humanDocCheck, humanDocRender],
-});

package/dist/commands/human/inbox.d.ts

@@ -1,2 +0,0 @@
-import { type BranchDef } from '../../core/command.js';
-export declare const humanInbox: BranchDef;

package/dist/core/human/__tests__/page-render.test.js

@@ -1,49 +0,0 @@
-// Two properties of the default page template whose absence would be SILENT —
-// every ordinary page still renders and still looks right when either breaks.
-// Nothing else about rendering is pinned here; prose shape is the renderer's
-// own business and a change there is visible the moment anyone looks at a page.
-import assert from 'node:assert/strict';
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import test from 'node:test';
-import { derivePageManifest } from '../page.js';
-import { renderPageHtml } from '../page-render.js';
-function render(name, source) {
-    const dir = mkdtempSync(join(tmpdir(), 'crtr-page-render-test-'));
-    try {
-        const path = join(dir, name);
-        writeFileSync(path, source);
-        return renderPageHtml(derivePageManifest(path, name.endsWith('.md') ? 'md' : 'html'), readFileSync(path, 'utf8'));
-    }
-    finally {
-        rmSync(dir, { recursive: true, force: true });
-    }
-}
-test('a config value carrying script markup cannot end its own <script> element', () => {
-    const html = render('page.md', [
-        '---', 'title: Escaping', '---', '',
-        'Pick one.', '',
-        '```slot:options',
-        '{"id":"esc","mode":"single","options":[{"id":"a","label":"</script><script>x</script>"},{"id":"b","label":"<!-- c -->"}]}',
-        '```', '',
-    ].join('\n'));
-    const config = /<crtr-options slot-id="esc"><script type="application\/json">([\s\S]*?)<\/script>/.exec(html)?.[1];
-    assert.ok(config !== undefined, `no options config in payload:\n${html}`);
-    // The mutation this catches: dropping the `<` escape for a plain JSON.stringify.
-    assert.ok(!config.includes('<'), `config text still carries a raw "<": ${config}`);
-    assert.equal(JSON.parse(config).options[0].label, '</script><script>x</script>');
-});
-test('an authored html slot id is mirrored to the slot-id the runtime reads', () => {
-    const html = render('page.html', [
-        '<!doctype html><html><head><meta name="crtr-page-title" content="Sign-off"></head><body>',
-        '<crtr-pages><crtr-page label="Window">',
-        '<crtr-options id="window"><script type="application/json">{"mode":"single","options":[{"id":"sat","label":"Saturday"}]}</script></crtr-options>',
-        '</crtr-page></crtr-pages>',
-        '</body></html>',
-    ].join('\n'));
-    // Without this, every element mounts and renders and no response ever
-    // reaches the host, because `src/pages` keys responses by `slot-id`.
-    assert.match(html, /<crtr-options id="window" slot-id="window">/);
-    assert.match(html, /<crtr-page label="Window">/);
-});

package/dist/core/human/markdown-html.d.ts

@@ -1,8 +0,0 @@
-/** Escape text for an HTML text node. */
-export declare function escapeHtmlText(raw: string): string;
-/** Escape a value for a double-quoted HTML attribute. */
-export declare function escapeHtmlAttribute(raw: string): string;
-/** Render one markdown document fragment as HTML. */
-export declare function renderMarkdownToHtml(markdown: string): string;
-/** Render inline markdown. Exported for callers rendering a single line. */
-export declare function renderInline(source: string): string;