inup 1.5.4 → 1.5.6

package/dist/ui/modal/package-info-sections/release-notes.js

@@ -0,0 +1,161 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildReleaseNotesSections = buildReleaseNotesSections;
+const chalk_1 = __importDefault(require("chalk"));
+const themes_colors_1 = require("../../themes-colors");
+const text_1 = require("./text");
+function formatReleaseNotesMarkdown(markdown, width, repositoryUrl) {
+    const lines = [];
+    const rawLines = markdown.split('\n');
+    let prevBlank = false;
+    for (const rawLine of rawLines) {
+        const trimmed = rawLine.trim();
+        if (trimmed === '') {
+            if (!prevBlank && lines.length > 0) {
+                lines.push('');
+                prevBlank = true;
+            }
+            continue;
+        }
+        prevBlank = false;
+        if (/^```/.test(trimmed) || /^---+$/.test(trimmed)) {
+            continue;
+        }
+        const cleaned = (0, text_1.sanitizeMarkdownText)(trimmed);
+        if (!cleaned) {
+            continue;
+        }
+        const quoteMatch = trimmed.match(/^>\s*(.+)/);
+        if (quoteMatch) {
+            const quoteBody = (0, text_1.linkifyMarkdownText)((0, text_1.sanitizeMarkdownText)(quoteMatch[1]), repositoryUrl);
+            const admonitionMatch = quoteBody.match(/^\[!([A-Z]+)\]$/i);
+            if (admonitionMatch) {
+                const label = `${admonitionMatch[1][0]}${admonitionMatch[1].slice(1).toLowerCase()}`;
+                if (lines.length > 0 && lines[lines.length - 1] !== '') {
+                    lines.push('');
+                }
+                lines.push(chalk_1.default.blue.bold(`  ${label}`));
+            }
+            else {
+                (0, text_1.pushWrappedLines)(lines, quoteBody, width, '  ', '  ', chalk_1.default.gray);
+            }
+            continue;
+        }
+        const headerMatch = cleaned.match(/^(#{1,6})\s+(.+)/);
+        if (headerMatch) {
+            const title = (0, text_1.sanitizeMarkdownText)(headerMatch[2]);
+            const lower = title.toLowerCase();
+            let style = chalk_1.default.white.bold;
+            if (lower.includes('breaking')) {
+                style = chalk_1.default.red.bold;
+            }
+            else if (lower.includes('feature') ||
+                lower.includes('added') ||
+                lower.includes('improvement')) {
+                style = chalk_1.default.green.bold;
+            }
+            else if (lower.includes('fix') || lower.includes('bug')) {
+                style = chalk_1.default.yellow.bold;
+            }
+            else if (lower.includes('deprecat')) {
+                style = chalk_1.default.magenta.bold;
+            }
+            if (lines.length > 0 && lines[lines.length - 1] !== '') {
+                lines.push('');
+            }
+            lines.push(style(`  ${title}`));
+            continue;
+        }
+        const bulletMatch = cleaned.match(/^(\s*)[*-]\s+(.+)/);
+        if (bulletMatch) {
+            const indentLevel = Math.min(2, Math.floor(bulletMatch[1].length / 2));
+            const prefix = `  ${'  '.repeat(indentLevel)}${chalk_1.default.gray('•')} `;
+            const restPrefix = `  ${'  '.repeat(indentLevel + 1)}`;
+            const style = /breaking/i.test(bulletMatch[2]) ? chalk_1.default.red : undefined;
+            (0, text_1.pushWrappedLines)(lines, (0, text_1.linkifyMarkdownText)((0, text_1.sanitizeMarkdownText)(bulletMatch[2]), repositoryUrl), width, prefix, restPrefix, style);
+            continue;
+        }
+        const orderedMatch = cleaned.match(/^(\s*)(\d+)\.\s+(.+)/);
+        if (orderedMatch) {
+            const indentLevel = Math.min(2, Math.floor(orderedMatch[1].length / 2));
+            const marker = `${orderedMatch[2]}.`;
+            const prefix = `  ${'  '.repeat(indentLevel)}${marker} `;
+            const restPrefix = `  ${'  '.repeat(indentLevel)}${' '.repeat(marker.length + 1)}`;
+            (0, text_1.pushWrappedLines)(lines, (0, text_1.linkifyMarkdownText)((0, text_1.sanitizeMarkdownText)(orderedMatch[3]), repositoryUrl), width, prefix, restPrefix);
+            continue;
+        }
+        const style = (0, text_1.isLowSignalTrailerLine)(cleaned) ? chalk_1.default.gray : undefined;
+        (0, text_1.pushWrappedLines)(lines, (0, text_1.linkifyMarkdownText)(cleaned, repositoryUrl), width, '  ', '  ', style);
+    }
+    while (lines.length > 0 && lines[lines.length - 1] === '') {
+        lines.pop();
+    }
+    return lines;
+}
+function buildReleaseNotesSections(state, modalWidth) {
+    const sections = [];
+    if (!state.releaseNotesVersions || state.releaseNotesVersions.length === 0) {
+        return sections;
+    }
+    const loaded = state.releaseNotesLoaded;
+    const viewIndex = state.releaseNotesViewIndex ?? 0;
+    const totalVersions = state.releaseNotesVersions.length;
+    const currentVersion = state.releaseNotesVersions[viewIndex];
+    if (!currentVersion)
+        return sections;
+    if (state.releaseNotesLoadingVersion === currentVersion) {
+        sections.push({
+            key: 'release-loading',
+            rows: [chalk_1.default.gray(`Loading release notes for v${currentVersion}...`)],
+            behavior: 'status',
+        });
+        return sections;
+    }
+    if (!loaded || !loaded.has(currentVersion)) {
+        sections.push({
+            key: 'release-pending',
+            rows: [chalk_1.default.gray(`Press ←/→ to load release notes for v${currentVersion}`)],
+            behavior: 'status',
+        });
+        return sections;
+    }
+    const content = loaded.get(currentVersion);
+    if (!content) {
+        sections.push({
+            key: 'release-none',
+            rows: [chalk_1.default.gray.italic(`No release notes found for v${currentVersion}`)],
+            behavior: 'status',
+        });
+    }
+    else {
+        const versionHeader = (0, themes_colors_1.getThemeColor)('primary')(`Version ${currentVersion}`);
+        const navHint = totalVersions > 1 ? chalk_1.default.gray(` (${viewIndex + 1}/${totalVersions})`) : '';
+        const rows = [chalk_1.default.bold(versionHeader) + navHint];
+        const formatted = formatReleaseNotesMarkdown(content, modalWidth - 4, state.repository);
+        rows.push(...formatted);
+        sections.push({
+            key: `release-${currentVersion}`,
+            rows,
+            behavior: 'body',
+        });
+    }
+    const canGoNewer = viewIndex > 0;
+    const canGoOlder = viewIndex < totalVersions - 1;
+    if (canGoNewer || canGoOlder) {
+        const hints = [];
+        if (canGoNewer)
+            hints.push('← newer');
+        if (canGoOlder)
+            hints.push('→ older');
+        sections.push({
+            key: 'release-nav',
+            rows: [chalk_1.default.gray(hints.join('  ·  '))],
+            behavior: 'status',
+        });
+    }
+    return sections;
+}
+//# sourceMappingURL=release-notes.js.map

package/dist/ui/modal/package-info-sections/sections.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUsedBySections = buildUsedBySections;
+exports.buildPackageInfoSections = buildPackageInfoSections;
+const node_path_1 = __importDefault(require("node:path"));
+const chalk_1 = __importDefault(require("chalk"));
+const themes_colors_1 = require("../../themes-colors");
+const vulnerability_1 = require("../../presenters/vulnerability");
+const utils_1 = require("../../utils");
+const release_notes_1 = require("./release-notes");
+function formatNumber(num) {
+    if (!num)
+        return 'N/A';
+    if (num >= 1000000)
+        return (num / 1000000).toFixed(1) + 'M';
+    if (num >= 1000)
+        return (num / 1000).toFixed(1) + 'K';
+    return num.toString();
+}
+function getUsedByPaths(state) {
+    return state.packageJsonPaths ?? [state.packageJsonPath];
+}
+function buildTabBarSuffix(activeTab, usedByCount) {
+    const styleFor = (tab) => tab === activeTab ? chalk_1.default.bold.underline : chalk_1.default.gray;
+    const usedByLabel = `Used by${usedByCount > 0 ? ` (${usedByCount})` : ''}`;
+    return ('  ' +
+        chalk_1.default.gray('[ ') +
+        styleFor('info')('Info') +
+        chalk_1.default.gray(' │ ') +
+        styleFor('usedBy')(usedByLabel) +
+        chalk_1.default.gray(' ]'));
+}
+function buildUsedBySections(state, modalWidth) {
+    const paths = getUsedByPaths(state);
+    const cwd = process.cwd();
+    const contentWidth = Math.max(10, modalWidth - 4);
+    const formatRelative = (absolutePath) => {
+        const display = node_path_1.default.relative(cwd, absolutePath) || absolutePath;
+        return (0, utils_1.truncatePlainText)(display, contentWidth);
+    };
+    return [
+        {
+            key: 'used-by-summary',
+            rows: [
+                chalk_1.default.bold(`${paths.length} package.json file${paths.length === 1 ? '' : 's'} depend on ${state.name}`),
+                chalk_1.default.gray(`Type: ${state.type}`),
+            ],
+            required: true,
+            behavior: 'pinned',
+        },
+        {
+            key: 'used-by-list',
+            rows: paths.map((p) => `${chalk_1.default.gray('•')} ${formatRelative(p)}`),
+            behavior: 'body',
+        },
+    ];
+}
+function buildPackageInfoSections(state, modalWidth, activeTab) {
+    const title = chalk_1.default.bold('Package: ') +
+        (0, themes_colors_1.getThemeColor)('packageName')(state.name) +
+        buildTabBarSuffix(activeTab, getUsedByPaths(state).length);
+    const authorLicense = chalk_1.default.gray(`${state.author || 'Unknown'} • ${state.license || 'MIT'}`);
+    const currentVersion = chalk_1.default.yellow(state.currentVersionSpecifier);
+    const targetVersion = chalk_1.default.green(state.selectedOption === 'range' ? state.rangeVersion : state.latestVersion);
+    const sections = [
+        {
+            key: 'header',
+            rows: [title, authorLicense],
+            required: true,
+            behavior: 'pinned',
+        },
+    ];
+    if (activeTab === 'usedBy') {
+        sections.push(...buildUsedBySections(state, modalWidth));
+        return sections;
+    }
+    sections.push({
+        key: 'meta',
+        rows: [
+            `Current: ${currentVersion}  Target: ${targetVersion}`,
+            ...(state.weeklyDownloads !== undefined
+                ? [(0, themes_colors_1.getThemeColor)('primary')(`Downloads/week: ${formatNumber(state.weeklyDownloads)}`)]
+                : []),
+        ],
+        required: true,
+        behavior: 'pinned',
+    });
+    if (state.homepage) {
+        sections.push({
+            key: 'homepage',
+            rows: [
+                `Homepage: ${chalk_1.default.underline((0, themes_colors_1.getThemeColor)('primary')((0, utils_1.truncatePlainText)(state.homepage, modalWidth - 14)))}`,
+            ],
+            behavior: 'pinned',
+        });
+    }
+    if (state.description) {
+        sections.push({
+            key: 'description',
+            rows: (0, utils_1.wrapPlainText)(state.description, modalWidth - 4)
+                .slice(0, 4)
+                .map((line, index, rows) => index === rows.length - 1 && rows.length === 4
+                ? (0, utils_1.truncatePlainText)(line, modalWidth - 4)
+                : line),
+            behavior: 'pinned',
+        });
+    }
+    if (state.vulnerability && state.vulnerability.count > 0) {
+        const representative = (0, vulnerability_1.selectRepresentativeAdvisory)(state.vulnerability);
+        const severityColor = (0, vulnerability_1.getVulnerabilitySeverityColor)(state.vulnerability.highestSeverity);
+        const vulnerabilityRows = [
+            chalk_1.default.red.bold(`${state.vulnerability.count} known vulnerabilit${state.vulnerability.count === 1 ? 'y' : 'ies'} (${severityColor(state.vulnerability.highestSeverity.toUpperCase())})`),
+        ];
+        if (representative) {
+            const severityLabel = ` ${severityColor(`[${representative.severity.toUpperCase()}]`)} `;
+            const availableTitleWidth = Math.max(0, modalWidth - 4 - (0, utils_1.getVisualLength)(severityLabel));
+            vulnerabilityRows.push(`${severityLabel}${(0, utils_1.truncatePlainText)(representative.title, availableTitleWidth)}`);
+        }
+        const detailsUrl = state.vulnerability.detailsUrl || representative?.url;
+        if (detailsUrl) {
+            const linkPrefix = ` ${(0, vulnerability_1.getVulnerabilityLinkLabel)(detailsUrl)} `;
+            const availableLinkWidth = Math.max(0, modalWidth - 4 - (0, utils_1.getVisualLength)(linkPrefix));
+            vulnerabilityRows.push(`${linkPrefix}${chalk_1.default.underline((0, themes_colors_1.getThemeColor)('primary')((0, utils_1.truncatePlainText)(detailsUrl, availableLinkWidth)))}`);
+        }
+        if (state.vulnerability.count > 1) {
+            vulnerabilityRows.push(chalk_1.default.gray(` ... and ${state.vulnerability.count - 1} more`));
+        }
+        sections.push({
+            key: 'vulnerability',
+            rows: vulnerabilityRows,
+            required: true,
+            behavior: 'pinned',
+        });
+    }
+    if (state.repository) {
+        sections.push({
+            key: 'changelog',
+            rows: [
+                `Changelog: ${chalk_1.default.underline((0, themes_colors_1.getThemeColor)('primary')((0, utils_1.truncatePlainText)(state.repository, modalWidth - 15)))}`,
+            ],
+            behavior: 'pinned',
+        });
+    }
+    sections.push(...(0, release_notes_1.buildReleaseNotesSections)(state, modalWidth));
+    return sections;
+}
+//# sourceMappingURL=sections.js.map

package/dist/ui/modal/package-info-sections/text.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTerminalLink = formatTerminalLink;
+exports.getRepositoryBaseUrl = getRepositoryBaseUrl;
+exports.sanitizeMarkdownText = sanitizeMarkdownText;
+exports.linkifyContributorMentions = linkifyContributorMentions;
+exports.linkifyRepositoryReferences = linkifyRepositoryReferences;
+exports.linkifyMarkdownText = linkifyMarkdownText;
+exports.pushWrappedLines = pushWrappedLines;
+exports.isLowSignalTrailerLine = isLowSignalTrailerLine;
+const utils_1 = require("../../utils");
+function formatTerminalLink(label, url) {
+    return `]8;;${url}${label}]8;;`;
+}
+function getRepositoryBaseUrl(repositoryUrl) {
+    if (!repositoryUrl) {
+        return null;
+    }
+    return repositoryUrl.replace(/\/releases\/?$/, '');
+}
+function sanitizeMarkdownText(text) {
+    return text
+        .replace(/<[^>]+>/g, '')
+        .replace(/\[([^\]]+)\]\(([^)]+)\)/g, '$1')
+        .replace(/[`*_~]/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function linkifyContributorMentions(text) {
+    return text.replace(/(^|[\s(])@([a-zA-Z0-9-]+)/g, (_match, prefix, username) => {
+        return `${prefix}${formatTerminalLink(`@${username}`, `https://github.com/${username}`)}`;
+    });
+}
+function linkifyRepositoryReferences(text, repositoryUrl) {
+    const repoBaseUrl = getRepositoryBaseUrl(repositoryUrl);
+    if (!repoBaseUrl || !repoBaseUrl.includes('github.com')) {
+        return text;
+    }
+    return text
+        .replace(/(^|[\s(])#(\d+)\b/g, (_match, prefix, number) => {
+        return `${prefix}${formatTerminalLink(`#${number}`, `${repoBaseUrl}/pull/${number}`)}`;
+    })
+        .replace(/(^|[\s(])([0-9a-f]{7,40})\b/gi, (_match, prefix, hash) => {
+        return `${prefix}${formatTerminalLink(hash, `${repoBaseUrl}/commit/${hash}`)}`;
+    });
+}
+function linkifyMarkdownText(text, repositoryUrl) {
+    return linkifyRepositoryReferences(linkifyContributorMentions(text), repositoryUrl);
+}
+function pushWrappedLines(lines, text, width, firstPrefix, restPrefix = firstPrefix, style) {
+    const firstWidth = Math.max(1, width - (0, utils_1.getVisualLength)(firstPrefix));
+    const restWidth = Math.max(1, width - (0, utils_1.getVisualLength)(restPrefix));
+    const segments = (0, utils_1.wrapPlainText)(text, firstWidth);
+    if (segments.length === 0) {
+        lines.push(firstPrefix.trimEnd());
+        return;
+    }
+    lines.push(firstPrefix + (style ? style(segments[0]) : segments[0]));
+    for (let i = 1; i < segments.length; i++) {
+        const wrappedSegments = (0, utils_1.wrapPlainText)(segments[i], restWidth);
+        for (const segment of wrappedSegments) {
+            lines.push(restPrefix + (style ? style(segment) : segment));
+        }
+    }
+}
+function isLowSignalTrailerLine(text) {
+    const normalized = text.toLowerCase();
+    return (normalized.startsWith('compare') ||
+        normalized.startsWith('full changelog') ||
+        normalized.startsWith('see full changelog') ||
+        normalized.startsWith('release notes') ||
+        normalized.includes('/compare/') ||
+        /^\w+: https?:\/\//.test(normalized));
+}
+//# sourceMappingURL=text.js.map