orz-paged 0.1.0

package/dist/doc/settings.js

@@ -0,0 +1,390 @@
+/**
+ * Document settings — M1.
+ *
+ * Reads the single `{{nyml kind: document}}` block from a Markdown source,
+ * normalizes its snake_case keys into a {@link DocSettingsLayer}, and merges
+ * template + user layers over {@link DEFAULTS} into a fully-resolved
+ * {@link DocSettings}.
+ *
+ * Source of truth for defaults and aliases: `docs/document-model.md`
+ * (the curated subset; see DESIGN.md §8).
+ */
+/* ─────────────────────────── defaults ─────────────────────────── */
+/** Every field at its documented default (docs/document-model.md). */
+export const DEFAULTS = {
+    // page
+    pageSize: 'A4',
+    marginTop: 20,
+    marginBottom: 20,
+    marginLeft: 20,
+    marginRight: 20,
+    // typography — fontPreset / decorationColor intentionally unset so a theme's
+    // own font + accent apply by default; an explicit setting (or a template)
+    // overrides them (page CSS is added last and only emits a token when set).
+    fontSize: 12,
+    lineHeight: 1.5,
+    // page numbers
+    pageNumberPosition: 'footer-center',
+    pageNumberStyle: 'simple',
+    pageNumberStartPage: 1,
+    firstPageSkipNumber: false,
+    // running headers / footers
+    headerLeft: '',
+    headerCenter: '',
+    headerRight: '',
+    headerRule: true,
+    headerFontSize: 9,
+    footerLeft: '',
+    footerCenter: '',
+    footerRight: '',
+    footerRule: true,
+    footerFontSize: 9,
+    firstPageHideHeader: false,
+    firstPageHideFooter: false,
+    frontMatterClean: false,
+    // layout behavior
+    limitImageToPage: true,
+    keepImageTogether: true,
+    repeatTableHeader: true,
+    avoidTableRowBreaks: true,
+    // theme — the default look (font + accent + element style) when a document
+    // doesn't pick one. Templates set layout only, never a theme.
+    theme: 'light-academic-1',
+    // dynamic switch — empty by default (no conditional content removed).
+    dynamicChoices: {},
+};
+/* ─────────────────────────── parsing ─────────────────────────── */
+/**
+ * Locate the first `{{nyml ... }}` block whose body declares `kind: document`,
+ * parse its `key: value` lines (including `key: |` multiline blocks) into a
+ * {@link RawDocSettings}, and return the source with that block removed so it
+ * is not rendered as content. No document block → `{ raw: {}, body: source }`.
+ */
+export function parseDocSettings(source) {
+    let searchFrom = 0;
+    while (searchFrom < source.length) {
+        const open = source.indexOf('{{nyml', searchFrom);
+        if (open === -1)
+            break;
+        // Find the matching closing `}}` for this block, allowing `}` inside the
+        // body as long as it is not the `}}` terminator.
+        const close = findClosing(source, open + '{{nyml'.length);
+        if (close === -1)
+            break;
+        const inner = source.slice(open + '{{nyml'.length, close);
+        if (isDocumentBlock(inner)) {
+            const raw = parseNymlBody(inner);
+            const body = stripLeadingBlank(source, open, close);
+            return { raw, body };
+        }
+        searchFrom = close + 2;
+    }
+    return { raw: {}, body: source };
+}
+/** Find the index of the `}}` that closes a `{{nyml` opened at/after `from`. */
+function findClosing(source, from) {
+    for (let i = from; i < source.length - 1; i++) {
+        if (source[i] === '}' && source[i + 1] === '}')
+            return i;
+    }
+    return -1;
+}
+/** Remove the block `[open, close+2)` and collapse a resulting blank gap. */
+function stripLeadingBlank(source, open, close) {
+    const before = source.slice(0, open);
+    let after = source.slice(close + 2);
+    // If the block sat on its own line(s), drop one trailing newline pair so we
+    // don't leave a large blank hole where it was.
+    if (/\n[ \t]*$/.test(before) || before === '') {
+        after = after.replace(/^[ \t]*\n/, '');
+    }
+    return before + after;
+}
+/** True if the nyml body contains a `kind: document` declaration. */
+function isDocumentBlock(inner) {
+    return /(^|\n)\s*kind\s*:\s*document\s*(\n|$)/.test(inner);
+}
+/**
+ * Parse a nyml body into a flat `key: value` map. Supports `key: |` multiline
+ * blocks: subsequent lines indented more than the key are joined (newline
+ * separated) as that key's value. The `kind:` line itself is skipped.
+ */
+function parseNymlBody(inner) {
+    const raw = {};
+    const lines = inner.split('\n');
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const m = /^(\s*)([A-Za-z0-9_]+)\s*:\s?(.*)$/.exec(line);
+        if (!m) {
+            i++;
+            continue;
+        }
+        const indent = m[1].length;
+        const key = m[2];
+        let value = m[3];
+        if (key === 'kind') {
+            i++;
+            continue;
+        }
+        if (value.trim() === '|') {
+            // Multiline block: gather following lines indented more than this key.
+            // Dedent by the indentation of the first content line (block style).
+            const collected = [];
+            let blockIndent = -1;
+            i++;
+            while (i < lines.length) {
+                const next = lines[i];
+                if (next.trim() === '') {
+                    collected.push('');
+                    i++;
+                    continue;
+                }
+                const nextIndent = next.match(/^[ \t]*/)?.[0].length ?? 0;
+                if (nextIndent <= indent)
+                    break;
+                if (blockIndent === -1)
+                    blockIndent = nextIndent;
+                collected.push(next.slice(Math.min(blockIndent, nextIndent)));
+                i++;
+            }
+            // Drop trailing blank lines from the collected block.
+            while (collected.length && collected[collected.length - 1] === '') {
+                collected.pop();
+            }
+            raw[key] = collected.join('\n');
+            continue;
+        }
+        raw[key] = stripQuotes(value.trim());
+        i++;
+    }
+    return raw;
+}
+/** Strip a single pair of matching surrounding quotes, if present. */
+function stripQuotes(s) {
+    if (s.length >= 2) {
+        const first = s[0];
+        const last = s[s.length - 1];
+        if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+            return s.slice(1, -1);
+        }
+    }
+    return s;
+}
+/* ─────────────────────────── normalization ─────────────────────────── */
+const PAGE_SIZE_ALIASES = {
+    a3: 'A3',
+    a4: 'A4',
+    a5: 'A5',
+    letter: 'Letter',
+    legal: 'Legal',
+};
+function normPageSize(v) {
+    const key = v.trim().toLowerCase();
+    return PAGE_SIZE_ALIASES[key] ?? v.trim();
+}
+function toNumber(v) {
+    if (typeof v === 'number')
+        return v;
+    if (typeof v === 'boolean')
+        return v ? 1 : 0;
+    const n = parseFloat(String(v).trim());
+    return Number.isFinite(n) ? n : undefined;
+}
+function toBool(v) {
+    if (typeof v === 'boolean')
+        return v;
+    if (typeof v === 'number')
+        return v !== 0;
+    const s = String(v).trim().toLowerCase();
+    return s === 'true' || s === 'yes' || s === '1' || s === 'on';
+}
+function toStr(v) {
+    return String(v);
+}
+/**
+ * Map snake_case raw keys → camelCase {@link DocSettings} fields, coercing
+ * types and normalizing aliases. Only keys present in `raw` are included;
+ * unknown keys are ignored.
+ */
+export function normalizeRawToLayer(raw) {
+    const out = {};
+    const setNum = (key, v) => {
+        const n = toNumber(v);
+        if (n !== undefined)
+            out[key] = n;
+    };
+    const setBool = (key, v) => {
+        out[key] = toBool(v);
+    };
+    const setStr = (key, v) => {
+        out[key] = toStr(v);
+    };
+    for (const [k, v] of Object.entries(raw)) {
+        if (v === undefined)
+            continue;
+        switch (k) {
+            // page
+            case 'page_size':
+                out.pageSize = normPageSize(toStr(v));
+                break;
+            case 'margin_top':
+                setNum('marginTop', v);
+                break;
+            case 'margin_bottom':
+                setNum('marginBottom', v);
+                break;
+            case 'margin_left':
+                setNum('marginLeft', v);
+                break;
+            case 'margin_right':
+                setNum('marginRight', v);
+                break;
+            case 'page_background':
+                setStr('pageBackground', v);
+                break;
+            // typography
+            case 'font_preset':
+                out.fontPreset = toStr(v).trim();
+                break;
+            case 'font_family':
+                setStr('fontFamily', v);
+                break;
+            case 'font_heading_preset':
+                out.fontHeadingPreset = toStr(v).trim();
+                break;
+            case 'font_margin_box_preset':
+                out.fontMarginBoxPreset = toStr(v).trim();
+                break;
+            case 'font_size':
+                setNum('fontSize', v);
+                break;
+            case 'line_height':
+                setNum('lineHeight', v);
+                break;
+            case 'decoration_color':
+                setStr('decorationColor', v);
+                break;
+            // page numbers
+            case 'page_number_position':
+                out.pageNumberPosition = toStr(v).trim();
+                break;
+            case 'page_number_style':
+                out.pageNumberStyle = toStr(v).trim();
+                break;
+            case 'page_number_start_page':
+                setNum('pageNumberStartPage', v);
+                break;
+            case 'first_page_skip_number':
+                setBool('firstPageSkipNumber', v);
+                break;
+            // headers / footers
+            case 'header_left':
+                setStr('headerLeft', v);
+                break;
+            case 'header_center':
+                setStr('headerCenter', v);
+                break;
+            case 'header_right':
+                setStr('headerRight', v);
+                break;
+            case 'header_rule':
+                setBool('headerRule', v);
+                break;
+            case 'header_rule_color':
+                setStr('headerRuleColor', v);
+                break;
+            case 'header_font_size':
+                setNum('headerFontSize', v);
+                break;
+            case 'footer_left':
+                setStr('footerLeft', v);
+                break;
+            case 'footer_center':
+                setStr('footerCenter', v);
+                break;
+            case 'footer_right':
+                setStr('footerRight', v);
+                break;
+            case 'footer_rule':
+                setBool('footerRule', v);
+                break;
+            case 'footer_rule_color':
+                setStr('footerRuleColor', v);
+                break;
+            case 'footer_font_size':
+                setNum('footerFontSize', v);
+                break;
+            case 'first_page_hide_header':
+                setBool('firstPageHideHeader', v);
+                break;
+            case 'first_page_hide_footer':
+                setBool('firstPageHideFooter', v);
+                break;
+            case 'front_matter':
+            case 'front_matter_clean': {
+                const fm = toStr(v).toLowerCase();
+                out.frontMatterClean =
+                    fm === 'clean' || fm === 'plain' || toBool(v);
+                break;
+            }
+            // layout behavior
+            case 'limit_image_to_page':
+                setBool('limitImageToPage', v);
+                break;
+            case 'keep_image_together':
+                setBool('keepImageTogether', v);
+                break;
+            case 'repeat_table_header':
+                setBool('repeatTableHeader', v);
+                break;
+            case 'avoid_table_row_breaks':
+                setBool('avoidTableRowBreaks', v);
+                break;
+            // theme / template / escape hatch
+            case 'theme':
+                out.theme = toStr(v).trim();
+                break;
+            case 'template':
+                out.template = toStr(v).trim();
+                break;
+            case 'custom_css':
+                setStr('customCss', v);
+                break;
+            case 'dynamic_choices': {
+                // multiline `key: value` map → object with normalized keys
+                // (lowercase, hyphens → underscores), matching data-*-when resolution.
+                const map = {};
+                for (const line of toStr(v).split(/\r?\n/)) {
+                    const idx = line.indexOf(':');
+                    if (idx < 0)
+                        continue;
+                    const key = line.slice(0, idx).trim().toLowerCase().replace(/-/g, '_');
+                    if (key)
+                        map[key] = line.slice(idx + 1).trim();
+                }
+                out.dynamicChoices = map;
+                break;
+            }
+            default:
+                // unknown key — ignore
+                break;
+        }
+    }
+    return out;
+}
+/* ─────────────────────────── merging ─────────────────────────── */
+/**
+ * Shallow-merge layers left → right (later wins). Intended use:
+ * `mergeSettings(DEFAULTS, templateLayer, userLayer)`.
+ */
+export function mergeSettings(...layers) {
+    const out = { ...DEFAULTS };
+    for (const layer of layers) {
+        for (const [k, v] of Object.entries(layer)) {
+            if (v !== undefined)
+                out[k] = v;
+        }
+    }
+    return out;
+}

package/dist/doc/templates.js

@@ -0,0 +1,147 @@
+/**
+ * Curated document templates — LAYOUT defaults + a starter skeleton.
+ *
+ * Responsibility split: a **template** owns layout only (page size, margins,
+ * furniture, and which elements appear / where). A **theme** owns the look —
+ * font, accent/decoration color, and element styling — so the same theme renders
+ * the same across every template (see ../doc/theme-fonts.ts + assets/themes/*).
+ * The default theme is `light-academic-1` (settings.ts DEFAULTS.theme).
+ *
+ * Each template carries:
+ *   - a {@link DocSettingsLayer} of *layout defaults* (page size; no font/theme),
+ *     merged under any `kind: document` field the user sets,
+ *   - picker metadata (`label`, `description`, `group`),
+ *   - a `skeleton` stem naming the starter Markdown in `assets/templates/<stem>.md`.
+ *
+ * `article` / `report` / `exam` ship in two variants — `-page` (a dedicated
+ * title/cover page) and `-section` (title-on-content) — that differ only in their
+ * skeleton (the title element's `placement: page | section`). Legacy names
+ * (`article`/`report`/`exam`) resolve to the `-section` variant.
+ */
+// Templates set LAYOUT only (page size, margins, furniture). Font, accent, and
+// element style come from the theme — so the same theme looks the same across
+// every template. A document still overrides any of this in its settings block.
+const ARTICLE_SETTINGS = { pageSize: 'Letter' };
+const REPORT_SETTINGS = { pageSize: 'Letter' };
+const EXAM_SETTINGS = { pageSize: 'Letter' };
+/** The 10 curated templates. */
+export const TEMPLATES = {
+    'article-page': {
+        label: 'Article — title page',
+        description: 'Academic paper with a dedicated title page, then abstract + body.',
+        group: 'Article',
+        skeleton: 'article-page',
+        settings: { ...ARTICLE_SETTINGS, template: 'article-page' },
+    },
+    'article-section': {
+        label: 'Article — title section',
+        description: 'Academic paper with an inline title block above the body.',
+        group: 'Article',
+        skeleton: 'article-section',
+        settings: { ...ARTICLE_SETTINGS, template: 'article-section' },
+    },
+    'report-page': {
+        label: 'Report — title page',
+        description: 'Business/technical report with a cover page, TOC, then body.',
+        group: 'Report',
+        skeleton: 'report-page',
+        settings: { ...REPORT_SETTINGS, template: 'report-page' },
+    },
+    'report-section': {
+        label: 'Report — title section',
+        description: 'Business/technical report with an inline title block.',
+        group: 'Report',
+        skeleton: 'report-section',
+        settings: { ...REPORT_SETTINGS, template: 'report-section' },
+    },
+    'exam-page': {
+        label: 'Exam — cover page',
+        description: 'Exam with a cover/instructions page, then numbered questions.',
+        group: 'Exam',
+        skeleton: 'exam-page',
+        settings: { ...EXAM_SETTINGS, template: 'exam-page' },
+    },
+    'exam-section': {
+        label: 'Exam — title section',
+        description: 'Exam with an inline header block, then numbered questions.',
+        group: 'Exam',
+        skeleton: 'exam-section',
+        settings: { ...EXAM_SETTINGS, template: 'exam-section' },
+    },
+    letter: {
+        label: 'Letter',
+        description: 'Formal letter: letterhead, inside address, body, signature.',
+        group: 'Letter',
+        skeleton: 'letter',
+        settings: { template: 'letter', pageSize: 'Letter' },
+    },
+    'cover-letter': {
+        label: 'Cover letter',
+        description: 'Job cover letter: sender header, recipient, body, sign-off.',
+        group: 'Letter',
+        skeleton: 'cover-letter',
+        settings: { template: 'cover-letter', pageSize: 'Letter' },
+    },
+    cv: {
+        label: 'CV — classic',
+        description: 'Résumé: name/contact header and clean sectioned body.',
+        group: 'CV',
+        skeleton: 'cv',
+        settings: { template: 'cv', pageSize: 'Letter' },
+    },
+    'cv-modern': {
+        label: 'CV — modern',
+        description: 'Accent name + rule, uppercase section labels, right-aligned dates, skill chips.',
+        group: 'CV',
+        skeleton: 'cv-modern',
+        settings: { template: 'cv-modern', pageSize: 'Letter' },
+    },
+    'cv-elegant': {
+        label: 'CV — elegant',
+        description: 'Centered, letter-spaced name, hairline rules, two-column "ledger" entries.',
+        group: 'CV',
+        skeleton: 'cv-elegant',
+        settings: { template: 'cv-elegant', pageSize: 'Letter' },
+    },
+    note: {
+        label: 'Note',
+        description: 'Clean readable note: minimal furniture on A4.',
+        group: 'Note',
+        skeleton: 'note',
+        settings: { template: 'note', pageSize: 'A4' },
+    },
+};
+/** Legacy single names → their `-section` variant. */
+const LEGACY_ALIASES = {
+    article: 'article-section',
+    report: 'report-section',
+    exam: 'exam-section',
+};
+/** Canonicalize a (possibly legacy) template name, or `undefined` if unknown. */
+export function canonicalTemplate(name) {
+    if (name in TEMPLATES)
+        return name;
+    if (name in LEGACY_ALIASES)
+        return LEGACY_ALIASES[name];
+    return undefined;
+}
+/** Return a template's *settings* defaults layer, or `{}` for an unknown name. */
+export function resolveTemplate(name) {
+    const key = canonicalTemplate(String(name));
+    return key ? TEMPLATES[key].settings : {};
+}
+/** The starter-markdown file stem for a template, or `undefined` if unknown. */
+export function templateSkeletonName(name) {
+    const key = canonicalTemplate(String(name));
+    return key ? TEMPLATES[key].skeleton : undefined;
+}
+/** Picker catalog: id + metadata for every template (no settings/skeleton text). */
+export function templateList() {
+    return Object.keys(TEMPLATES).map((id) => ({
+        id,
+        label: TEMPLATES[id].label,
+        description: TEMPLATES[id].description,
+        group: TEMPLATES[id].group,
+        skeleton: TEMPLATES[id].skeleton,
+    }));
+}

package/dist/doc/theme-fonts.js

@@ -0,0 +1,10 @@
+export const THEME_FONTS = {
+    none: { body: 'system-serif', heading: 'system-serif' },
+    'light-neat-1': { body: 'inter', heading: 'inter' },
+    'light-neat-2': { body: 'ibm-plex-sans', heading: 'ibm-plex-sans' },
+    'light-neat-3': { body: 'raleway', heading: 'raleway' },
+    'light-academic-1': { body: 'source-serif-4', heading: 'source-serif-4' },
+    'light-academic-2': { body: 'crimson-pro', heading: 'inter' },
+    'beige-decent-1': { body: 'lora', heading: 'lora' },
+    'beige-decent-2': { body: 'noto-serif', heading: 'noto-serif' },
+};